工厂模式

意义

1. 将创建者和调用者进行分离，创建过程细节隐蔽，实现更好的扩展

工厂模式的分类

• 简单工厂（静态工厂）

1. 定义一个抽象产品类
2. 实现具体的产品类
3. 创建工厂实现被调用产品实例的方法
4. 外部类通过工厂调用实例方法、

抽象产品类

public interface ICreatProduct{
    void creatProduct();
}

具体产品A

public class A implements ICreatProduct{
    @Override
    public void creatProduct(){
        System.out.println("创建商品 A");
    }
}

具体产品B

public class B implements ICreatProduct{
    @Override
    public void creatProduct(){
        System.out.println("创建商品 B")
    }
}

工厂类

public class Factory {
    public static ICreatProduct getProductA(){
        return new A();
    }
    public static ICreatProduct getProductB(){
        return new B();
    }
}

调用

public class User {
    public static void main (String[] args){
        ICreatProduct a = Factory.getProductA();
        a.creatProduct();
        ICreatProduct b = Factory.getProductB(); 
        b.creatProduct();
    }
}

• 工厂方法

1. 定义一个抽象的产品类
2. 实现具体的产品类
3. 创建多个抽象的工厂类
4. 实现具体的工厂类，并提供被调用的产品的实例 的方法
5. 外部类通过工厂调用实例方法

抽象产品

public interface ICreatProduct{
    void creatProduct();
}

具体产品 A

public class A implements ICreatProduct{
    @Override
    public void creatProduct(){
        System.out.println("创建商品 A");
    }
}

具体产品 B

public class B implements ICreatProduct{
    @Override
    public void creatProduct(){
        System.out.println("创建商品 B");
    }
}

抽象工厂

public interface ICreatFactory{
    ICreatProduct productMethod();
}

具体工厂 A

public class AFactory implements ICreatFactory{
    @Override
    public ICreatProduct productMethod(){
        return new A();
    }
    
}

具体工厂 B

public class BFactory implements ICreatFactory{
    @Override
    public ICreatProduct productMethod(){
        return new B();
    }
}

调用

public class User {
    ICreatFactory factroyA = new AFactory();
    factoryA.creatProduct();
    
    
    ICreatFactory factoryB = new BFactory();
    factoryB.creatProduct();
    
}

• 抽象工厂

1. 定义多个抽象的产品类
2. 实现具体的产品类
3. 创建多个抽象的工厂类
4. 实现具体的工厂类，并提供被调用的产品的实例 的方法
5. 外部类通过工厂调用实例方法

抽象产品类

public interface ICreatProduct{
    void creatProduct();
}

具体产品 A

public class A interface ICreatProduct{
    @Override
    public void creatProduct () {
        System.out.println("创建产品 A");
    }
}

具体产品 B

public class B interface ICreatProduct{
    @Override
    public void creatProduct () {
        System.out.println("创建产品 B");
    }
}

创建另一种抽象产品

public interface ICreatOtherProduct{
    void creatOtherProduct();
}

创建具体产品 X

public class X implements ICreatOtherProduct{
    @Override
    public void creatOtherProduct(){
        System.out.println("创建其他产品 X");
    }
}

创建具体产品 Y

public class Y implements ICreatOtherProduct{
    @Override
    public void creatOtherProduct(){
        System.out.println("创建其他产品 Y");
    }
}

创建抽象工厂

public interface ICreatFactory{
    ICreatProduct creatProduct();
    ICreatOtherProduct creatProduct();
}

产品组合工厂

public class FactoryAX implements ICreatFactory{
    @Override 
    public ICreatProduct creatProduct(){
        return new A ();
    }
    
    @Override
    public ICreatOtherProduct creatOtherProduct(){
        return new X ();
    }
}

产品组合工厂

public class FactoryBY implements ICreatFactory{
    @Override 
    public ICreatProduct creatProduct(){
        return new B ();
    }
    
    @Override
    public ICreatOtherProduct creatOtherProduct(){
        return new Y ();
    }
}

调用者

public class  User {
    ICreatFactory factoryAX = new CreatFactoryAX
    factoryAX.creatProduct();
    factoryAX.creatOtherProduct();
    
    ICreatFactory factoryBY = new CreatFactoryBY
    factoryBY.creatProduct();
    factoryBY.creatOtherProduct();
}

• 代码中如有相关错误请指出、纯手工敲、未运行过、重要是思路、