工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
一、简单工厂模式
简单工厂的定义：提供一个创建对象实例的功能，而无须关心其具体实现。被创建实例的类型可以是接口、抽象类，也可以是具体的类
实现汽车接口：
public interface Car {
String getName();
}
奔驰类：
public class Benz implements Car{
@Override
public String getName() {
return "Benz";
}
}
宝马类：
public class BMW implements Car {
@Override
public String getName() {
return "BMW";
}
}
简单工厂类：
public class SimpleFactory {
public Car getCar(String name){
if (name.equals("Benz"))
return new Benz();
if (name.equals("BMW"))
return new BMW();
else {
System.out.println("这个汽车无法生产");
return null;
}
}
}
测试方法：
public static void main(String[] args) {
SimpleFactory simpleFactory=new SimpleFactory();
Car car=simpleFactory.getCar("Benz");
System.out.println(car.getName());
}
---------------------------------------------
Benz
这种方法的缺点也很明显，违背了设计模式的开闭原则，因为如果你要增加工厂可以初始化的类的时候，你必须对工厂进行改建。
二：工厂方法模式
是设计一个工厂的接口，你想要什么东西，就写个类继承于这个工厂，这样就不用修改什么，直接添加就行了。就相当于，我这个工厂是用来生产鞋子的，而要什么品牌的鞋子具体分到了每个车间，如果新多了一种品牌的鞋子，直接新增一个车间就行了。
工厂接口
public interface Factory {
Car getCar();
}
奔驰工厂
public class BenzFactory implements Factory {
@Override
public Car getCar() {
return new Benz();
}
}
宝马工厂
public class BMWFactory implements Factory {
@Override
public Car getCar() {
return new BMW();
}
}
测试类
public class Test {
public static void main(String[] args) {
Factory factory=new BMWFactory();
System.out.println(factory.getCar().getName());
Factory factory1=new BenzFactory();
System.out.println(factory1.getCar().getName());
}
}
-----------------------------------------------
BMW
Benz
那么问题又来了，如果想要生产自行车怎么办？
三：抽象工厂模式
抽象工厂模式的定义：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定它们的具体类。 这里抽象工厂的接口类是能创建多个相关的对象，而工厂方法的接口类是只创建一个对象。
生产奔驰的接口Benz
public interface Benz {
void carColor();//设置颜色
void carSpeed();//设置速度
void carPrice();//设置价格
}
奔驰工厂的抽象接口类BanzFactory
public interface BanzFactory {
/**
* 创建奔驰的方法
*/
Benz createCar();
}
生产奔驰车辆S450的具体工厂类
/**
* 生产某一个型号奔驰车辆的实际工厂
*/
public class S450Factory implements BanzFactory {
@Override
public Benz createCar() {
return new BenzS450();
}
生产奔驰车辆S450的具体类
/**
* 奔驰S450的生产的具体类
*/
public class BenzS450 implements Benz {
/**
* 构造方法，创建的时候就设置基本属性
*/
public BenzS450() {
carColor();
carPrice();
carSpeed();
}
@Override
public void carColor() {
System.out.println("奔驰S450的颜色是银白色");
}
@Override
public void carSpeed() {
System.out.println("奔驰S450的速度是200公里每小时");
}
@Override
public void carPrice() {
System.out.println("奔驰S450的价格是100万");
}
}
测试类
/**
* 抽象工厂模式调用
* 生产奔驰车S450
*/
public class AbstractFactoryDemo {
public static void main(String[] a) {
System.out.println("生产奔驰车S450");
//父类但对象子类的实例
BanzFactory banzFactory = new S450Factory();//创建一个S450工厂
//调用父类的方法，这就是java多态的一种体现
banzFactory.createCar();//S450工厂生产车辆S450
}
}
1.优点
针对同一组产品创建新的生产线，只需实现那组产品的抽象工厂接口即可创建新的工厂类。
2.缺点
抽象方法模式的最大缺点就是产品族本身的扩展非常困难。如果在产品族中增加一个新的产品类型，则需要修改多个接口，并影响现已有的工厂类。
上面这句话，有些人不怎么理解，我給大家解释一下，打个比方说，你要在这个工厂创建三个对象，原本只是创建两个对象的，那么你就要在抽象方法中添加一个创建对象的方法，那么所有实现了这个接口的类都是要重新添加这个创建对象的方法，这就是对之前的工厂有影响的原因。
来源：https://blog.csdn.net/qq_40942323/article/details/98955552