前言

工厂模式是一种创建型设计模式，其作用是将对象的创建和使用进行解耦，用于提高代码的可维护性和可扩展性。通过提供给外部负责创建对象的工厂类，外部类通过工厂来创建对象。工厂模式包括简单工厂、工厂方法以及抽象工厂三种模式。

简单工厂模式

简单工厂模式如其名，非常简单，定义一个工厂类，提供给外部创建对象的方法，会根据传入的参数创建不同的对象。

代码实现：

/*水果接口*/
public interface Fruit {
}
/* 水果接口的两个具体的实现类 */
public class Apple implements Fruit{
}
public class Pear implements Fruit{
}
/* 创建对象的工厂*/
public class FruitFactory {public Fruit creat(String fruit){if (fruit.equals("apple")){return new Apple();}else if (fruit.equals("pear")){return new Pear();}throw  new IllegalArgumentException("参数值输入不正确");}
}

优缺点

优点：代码实现简单，如果需要扩展对象的创建不需要额外创建类
缺点：不符合开闭原则，若要扩展对象的创建会修改工厂类的代码
开闭原则：对扩展是开放的，对修改是关闭的。在不修改原代码的前提下进行行为的扩展。

工厂方法模式

工厂方法模式，其实现需要定义一个接口/抽象类以及创建对象的抽象方法，并且定义多个具体工厂，继承或者实现抽象工厂类，并重写其抽象方法，完成具体对象的创建。
代码实现：

/*抽象工厂类*/
public interface IFruitFactory {abstract Fruit create();
}/* 苹果工厂类*/
public class AppleFactory implements IFruitFactory{@Overridepublic Fruit create() {return new Apple();}
}
/*梨工厂类 */
public class PearFactory implements IFruitFactory{@Overridepublic Fruit create() {return new Pear();}
}
/*测试*/
public class Test {public static void main(String[] args) {// 创建对应对象的工厂类IFruitFactory factory=new AppleFactory();// 根据具体工厂的创建行为创建对象Fruit fruit = factory.create();System.out.println(fruit);}
}

优缺点

优点：符合开闭原则，当需要扩展对象的创建时，只需要扩展一个工厂类即可。
缺点：每次进行扩展都需要定义一个新的类

抽象工厂

对于一些存在关系的类，例如公司和产品，一个公司有许多产品。举个具体的例子，小米和苹果是两个公司，它们有很多相同的产品种类，例如手机、电脑等等。而抽象工厂模式则是定义一个抽象工厂类，其包含多个产品创建的抽象方法，通过创建具体工厂继承或实现抽象工厂，重写其方法完成产品的具体创建。

/*汽车、手机、电脑的接口*/
public interface Computer {abstract void go();
}
public interface Phone {abstract void begin();
}
public interface Car {abstract void start();
}
/*具体的实现类*/
public class MiCar implements Car{@Overridepublic void start() {System.out.println("小米汽车启动");}
}
public class MiComputer implements Computer{@Overridepublic void go() {System.out.println("小米电脑开机");}
}
public class MiPhone implements Phone{@Overridepublic void begin() {System.out.println("小米手机启动");}
}
苹果的实现类省略。。。/*我们不妨定义一个抽象工厂，其包含公司各个产品的创建方法*/
public abstract ICompany {abstract Car getCar();abstract Computer getComputer();abstract Phone getPhone();
}
/*具体工厂*/
public class MiCompany extend ICompany{@Overridepublic Car getCar() {return new MiCar();}@Overridepublic Computer getComputer() {return new MiComputer();}@Overridepublic Phone getPhone() {return new MiPhone();}
}public class AppleCompany extend ICompany{@Overridepublic Car getCar() {return new AppleCar();}@Overridepublic Computer getComputer() {return new AppleComputer();}@Overridepublic Phone getPhone() {return new ApplePhone();}
}测试：
public class Test {
/*指定具体的工厂类以及方法创建对象*/public static void main(String[] args) {ICompany company=new AppleCompany();Car car = company.getCar();car.start();ICompany company1=new MiCompany();Computer computer = company1.getComputer();computer.go();}
}

抽象工厂和工厂方法相比，其实两者很像但是也存在区别，两者都是创建抽象类，以及创建具体的实现类，由实现类完成对象的具体的创建。两者的区别在于工厂方法针对一个接口，抽象工厂针对一组存在依赖关系的接口。

优缺点

优点：可以减少类的创建，对于上面举得例子，我们完成每个具体对象的创建其实只定义了三个类，一个是抽象工厂，另外两个是具体的工厂。如果我们使用工厂方法来做，需要定义手机抽象工厂、汽车抽象工厂、电脑抽象工厂，以及小米手机具体工厂、苹果手机具体工厂…会多了很多类。
缺点：不符合开闭原则，并且扩展比较复杂，如果新增一些其他行为，例如电视的创建，就需要修改抽象工厂以及具体工厂的代码。