2.工厂模式

工厂模式定义

工厂模式是Java中最常用的设计模式之一。

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可以分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可以分为工厂方法模式和抽象工厂模式

简单工厂模式

 下面我们使用手机生产来讲解该模式：

//Phone类：手机标准规范类(AbstractProduct)
public interface Phone {

   void make();

}

//MiPhone类：制造小米手机（Product1）
public class MiPhone implements Phone {

    public MiPhone() {
        this.make();
    }

    @Override
    public void make() {
        System.out.println("make xiaomi phone");
    }

}

//IPhone类：制造苹果手机（Product2）
public class IPhone implements Phone {

    public IPhone() {
    }

    @Override
    public void make() {
        System.out.println("make iphone");
    }

}

//PhoneFactory类：手机代工厂（Factory）
public class PhoneFactory {

    public Phone makePhone(String phoneType){
        if(phoneType.equalsIgnoreCase("MiPhone")){
            return new MiPhone();
        }else if(phoneType.equalsIgnoreCase("iPhone")){
            return new IPhone();
        }
        return null;
    }
}

//开始调用
public static void main(String[] args) {

        PhoneFactory factory=new PhoneFactory();
        Phone miPhone = factory.makePhone("MiPhone");
        Phone iPhone = factory.makePhone("iPhone");

        System.out.println(miPhone);
        System.out.println(iPhone);

}

工厂方法模式（Factory Method）

简单工厂模式和工厂方法模式将生成具体产品的任务分发给具体的产品工厂，UML类图

//AbstractFactory类：生产不同产品的工厂的抽象类
public interface AbstractFactory {
    Phone makePhone();
}

//XiaoMiFactory类：生产小米手机的工厂（ConcreteFactory1）
public class XiaoMiFactory implements AbstractFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
}

AppleFactory类：生产苹果手机的工厂（ConcreteFactory2）

public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
}

public class Demo {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();            // make xiaomi phone!
        appleFactory.makePhone();        // make iphone!
    }
}

总结：

简单工厂和工厂方法模式的不同在于前者生成产生品的行为封装到一个方法中，根据参数的类型进行实例化，同时不存在抽象接口。而后者则增强了抽象工厂，通过实现不同的工厂方法来创建不同的产品，一个方法通常对应一个产品。这种方式相较于前者扩展性更高，在需求增加时完全符合开闭原则和依赖倒置原则。

抽象工厂模式（Abstract Factory）

以上两种模式，都是针对一类产品。

但是要增加一类新的产品，就需要重新复制一遍工厂方法模式

抽象工厂模式，通过增加产品的接口。在子工厂实现新加的产品

   

 

//pc类：定义pc产品的接口（AbstractPc）
public interface Pc(){
    void make()
}

//MiPc类：定义小米电脑产品（MIPC）
public class MiPC implements PC{

    public MiPC(){
        this.make();
    }
    
    @Verride
    public void make(){
        System.out.println("make xiaomi pc");
    }

}

//MAC类：定义苹果电脑产品（MAC）
public class MAC Implements Pc{

    public MAC(){
        this.make();
    }
    @Override
    public void make(){
        system.out.println("make mac")
    }

}

//AbstractFactory类：增加PC产品制造接口
public interface AbstractFactory{
      Phone makePhone();
      pc makePc();
}

//XiaoMiFactory类：增加小米PC的制造（ConcreteFactory1）

public class XiaoMiFactory implements AbstrctFactory{

    @Override
    public Phone makePhone(){
        return new MiPhone();
    }

    @Override
    public Phone makePc(){
        return new MiPC();
    }


}

//AppleFactory类：增加苹果PC的制造（ConcreteFactory2）
public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
    @Override
    public PC makePC() {
        return new MAC();
    }
}

public class Demo {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();            // make xiaomi phone!
        miFactory.makePC();                // make xiaomi PC!
        appleFactory.makePhone();        // make iphone!
        appleFactory.makePC();            // make MAC!
    }
}

总结：

抽象工厂模式是工厂方法模式的升级，后面面向单个产品，而前者面向的是一个产品族。根据官方定义：为创建一组相关/互相依赖的对象提供一个接口而无需指定它们的具体类。

比如一个汽车共产要生成汽车，而每一种汽车都有车门、车轮胎等一系列产品。这意味着每增加一款汽车就需要增加一个新的工厂来提供新产品的实现。这个时候可以使用抽象工厂模式来进行设计。抽象工厂模式适合于一系列产品族