经典设计模式

创建型 模式 简单工厂

class Factory {
    public static Product createProduct(String type) {
        Product productInstance = null;

        switch (type) {
            case "A":
                productInstance = new ProductA();
                break;
            case "B":
                productInstance = new ProductB();
                break;
            default:
                System.out.println("no this type")
                break;
        }
        return productInstance;
    }
}

abstract class Product {
    public abstract void info();
}

class ProductA extends Product {
    @Override // 方法重写
    public void info() {
        System.out.println("this is AAA")
    }
}

class ProductB extends Product {
    @Override
    public void info() {
        System.out.println("this is BBB")
    }
}

工厂方法

interface Factory{
    public Product createProduct();
}

class FactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }

}

interface Product {
    public void info();
}

class ProductA implements Product {
    @Override // 方法重写
    public void info() {
        System.out.println("this is AAA")
    }
}

class ProductB implements Product {
    @Override
    public void info() {
        System.out.println("this is BBB")
    }
}

抽象工厂

interface Factory{
    public AbstractProductA CreateProductA();
    public AbstractProductB CreateProductB();
}

class ConcreateFactory1 implements Factory {
    @Override
    public AbstractProductA CreateProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB CreateProductB() {
        return new ProductB1();
    }
}

class ConcreateFactory2 implements Factory {
    @Override
    public AbstractProductA CreateProductA() {
        return new ProductA2();
    }

    @Override
    public AbstractProductB CreateProductB() {
        return new ProductB2();
    }
}

interface AbstractProductA {
    public void info();
}

interface AbstractProductB {
    public void info();
}

class ProductA1 implements AbstractProductA {
    @Override // 方法重写
    public void info() {
        System.out.println("this is A1")
    }
}
class ProductA2 implements AbstractProductA {
    @Override // 方法重写
    public void info() {
        System.out.println("this is A2")
    }
}

class ProductB1 implements AbstractProductB {
    @Override // 方法重写
    public void info() {
        System.out.println("this is B1")
    }
}
class ProductB2 implements AbstractProductB {
    @Override // 方法重写
    public void info() {
        System.out.println("this is B2")
    }
}

生成器

/* 使用：
    Director director = new Director();
    
    Builder builder1 = new Builder1();
    director.Construct(builder1)
*/


class Director {
    public void Construct(Builder builder) {
        builder.BuildPart();
    }
}

abstract class Builder {
    public abstract void BuildPart();
    public abstract Product getResult();
}

class Builder1 extends Builder {
    Product productInstance = new Product();

    @Override
    public void BuildPart() {
        productInstance.SetFeilds("tom", "man") //初始化方案一
    }

    @Override
    public Product getResult() {
        return Product
    }

}

class Builder2 extends Builder {
    Product productInstance = new Product();

    @Override
    public void BuildPart() {
        productInstance.SetFeilds("cat","woman") //初始化方案二
    }

    @Override
    public Product getResult() {
        return Product
    }

}

class Product {
    public String name = "";
    public String sex = "";

    public void SetFeildsOfName(String caller, String gender) {
        this.name = caller
        this.sex = gender
    }

    public void show() {
        System.out.println(this)
    }
}

原型实例

interface Prototype {
    public Object Clone();
}

class Product implements Prototype {
    private int id;
    private double price;

    public Product(int id, double price) {
        this.id = id;
        this.price = price;
    }

    public int getId() {
        return id
    }

    public double getPrice() {
        return price
    }

    @Override
    public Object Clone() {  //有个该方法， 无需 对象 的 类， 也能 创建出一个 新的 对象。
        Product obj =  new Product();
        obj.id = this.id;
        obj.price = this.price;

        return obj;
    }
}

单例

/**
Singleton obj1 = Singleton.getInstance();
Singleton obj2 = Singleton.getInstance();
Singleton obj3 = Singleton.getInstance();

说明： obj1, obj2, obj3 指向 同一个 对象地址， 确保了 只有一个 实例

*/


class Singleton{
    // 这一步是为了确保 只能有一个实例， 即 类名的 同名方法 如果是 private， 则不能通过 new 的方式创建对象
    private Singleton(){}  

    // 静态方法 只能使用 静态变量， 所以这里 将 instance 设置为 静态变量
    private static Singleton instance = new Singleton();

    // 该方法  就是 全局访问点
    public static Singleton getInstance() {
        return instance
    }
}

结构性 模式 适配器

/*
    将 TypeC 适配 USB 可用的地方

    USB usb = new Adapter();
    usb.Request();

*/

class USB {
    public void Request() {
        System.out.println("USB")
    }
}

class Adapter extends USB {
    private TypeC typeC = new TypeC();

    @Override
    public void Request() {
        typeC.SpecialRequest();
    }
}

class TypeC {
    public void SpecialRequest() {
        System.out.println("TyoeC")
    }
}

桥接

/**
    调用：

        计算儿童票价
        People kid = new Children();

        Tickets aTickets = new ATickets(kid);
        System.out.println("A景区儿童票=" + aTickets.getMoney());

        Tickets bTikcets = new BTickets(kid);
        System.out.println("B景区儿童票=" + bTikcets.getMoney());



        计算老人票价
        People older = new OlderPeople();

        aTickets = new ATickets(olderPeople);
        System.out.println("A景区老人票=" + aTickets.getMoney());
        
        bTikcets = new BTickets(olderPeople);
        System.out.println("B景区老人票=" + bTikcets.getMoney());
*/

//People接口类
public interface People { 
    String getSale();
}

// 儿童类
public class Children implements People {
    @Override
    public String getSale() {
        return "0.6"; //儿童票6折
    }
}

// 老人类
public class OlderPeople implements People {
    @Override
    public String getSale() {
        return "0.5"; // 老人票5折
    }
}

// 门票接口类
public interface Tickets {
    int getMoney();
}

// A景区门票类
public class ATickets implements Tickets{

    private People people;

    public ATickets(People people) {
        this.people = people;
    }

    @Override
    public int getMoney() {
        String sale = people.getSale(); // 获得折扣
        BigDecimal saleBigDecimal = new BigDecimal(sale); // java小数计算会丢失精度，要用BigDecimal来计算
        BigDecimal ticketsBigDecimal = new BigDecimal("100"); // a景区门票原价100
        return ticketsBigDecimal.multiply(saleBigDecimal).intValue(); // 原价门票乘以折扣
    }
}

// B景区门票类
public class BTickets implements Tickets{

    private People people;

    public BTickets(People people) {
        this.people = people;
    }

    @Override
    public int getMoney() {
        String sale = people.getSale(); // 获得折扣
        BigDecimal saleBigDecimal = new BigDecimal(sale); // java小数计算会丢失精度，要用BigDecimal来计算
        BigDecimal ticketsBigDecimal = new BigDecimal("150"); // b景区门票原价100
        return ticketsBigDecimal.multiply(saleBigDecimal).intValue(); // 原价门票乘以折扣
    }
}

行为性 模式