类之间的关系

泛化：空心箭头实线（继承非抽象类）

实现：空心箭头虚线（继承抽象类）

聚合：空心菱形实线（整体和部分不是强依赖的，即使整体不存在了，部分仍然存在）

组合：实心菱形实线（强依赖的特殊聚合关系，如果整体不存在了，则部分也不存在了）

关联：直线，默认不强调方向，表示对象间相互知道；如果特别强调方向，加上箭头（对象之间静态的、天然的结构，如乘车人与车票）

依赖：带箭头的虚线（体现为类构造方法及类方法的传入参数，箭头的指向为调用关系）

1、简单工厂模式

2、工厂方法模式

抽象工厂 + 抽象产品 -> 具体工厂 + 具体产品

将创建的具体工厂/对象，赋值给抽象工厂/对象。

public class FactoryMethodPattern {
    public static void main(String[] args) {
        try {
            AbstractFactory factory1 = new ConcreteFactory1();
            Product product1 = factory1.newProduct();
            product1.show();

            AbstractFactory factory2 = new ConcreteFactory2();
            Product product2 = factory2.newProduct();
            product2.show();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

//抽象产品：提供了产品的接口
interface Product {
    public void show();
}
//具体产品1：实现抽象产品中的抽象方法
class ConcreteProduct1 implements Product {
    @Override
    public void show() {
        System.out.println("具体产品1显示...");
    }
}
//具体产品2：实现抽象产品中的抽象方法
class ConcreteProduct2 implements Product {
    @Override
    public void show() {
        System.out.println("具体产品2显示...");
    }
}

//抽象工厂：提供了厂品的生成方法
interface AbstractFactory {
    public Product newProduct();
}
//具体工厂1：实现了厂品的生成方法
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public Product newProduct() {
        System.out.println("具体工厂1生成-->具体产品1...");
        return new ConcreteProduct1();
    }
}
//具体工厂2：实现了厂品的生成方法
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public Product newProduct() {
        System.out.println("具体工厂2生成-->具体产品2...");
        return new ConcreteProduct2();
    }
}

3、抽象工厂模式

抽象工厂模式的结构与工厂方法模式的结构相似，不同的是其产品的种类不止一个，所以创建产品的方法也不止一个。

例子：在 Spring源码中的 DefaultListableBeanFactory实现了所有工厂的公共逻辑

public class AbstractFactoryPattern {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        factory1.newProduct1().show();
        factory1.newProduct2().show();

        System.out.println("================");
        AbstractFactory factory2 = new ConcreteFactory2();
        factory2.newProduct1().show();
        factory2.newProduct2().show();
    }
}

//抽象产品1
interface Product1 {
    public void show();
}
//具体产品11
class ConcreteProduct11 implements Product1 {
    @Override
    public void show() {
        System.out.println("具体产品11显示...");
    }
}
//具体产品12
class ConcreteProduct12 implements Product1 {
    @Override
    public void show() {
        System.out.println("具体产品12显示...");
    }
}

//抽象产品2
interface Product2 {
    public void show();
}
//具体产品21
class ConcreteProduct21 implements Product2 {
    @Override
    public void show() {
        System.out.println("具体产品21显示...");
    }
}
//具体产品22
class ConcreteProduct22 implements Product2 {
    @Override
    public void show() {
        System.out.println("具体产品22显示...");
    }
}

//抽象工厂：提供了厂品的生成方法
interface AbstractFactory {
    Product1 newProduct1();
    Product2 newProduct2();
}
//具体工厂1：实现了厂品的生成方法
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public Product1 newProduct1() {
        System.out.println("具体工厂1生成-->具体产品11...");
        return new ConcreteProduct11();
    }

    @Override
    public Product2 newProduct2() {
        System.out.println("具体工厂1生成-->具体产品21...");
        return new ConcreteProduct22();
    }

}
//具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public Product1 newProduct1() {
        System.out.println("具体工厂2生成-->具体产品12...");
        return new ConcreteProduct12();
    }

    @Override
    public Product2 newProduct2() {
        System.out.println("具体工厂2生成-->具体产品22...");
        return new ConcreteProduct22();
    }
}