什么是工厂模式模式? 说说你对工厂模式的理解？

# 工厂模式 功能：将对象的实例化交给工厂去做，你只需要告诉工厂你需要什么对象，我给你造出来就行了。 目的：让使用者只需要关注自己需要的，而不需要关注这个东西是怎么创建的，能用就行。让实例创建和实例使用解耦 ## 需求 我要生产汽车，但是汽车有很多不同的颜色。 ## 简单工厂 ### 类图  ### 实现 ``` public class SimpleFactory { private Map<String, Car> mapCar = new HashMap<>(); public SimpleFactory(){ mapCar.put("yellow",new YellowCar()); mapCar.put("black",new BlackCar()); } public Car createCar(String color){ System.out.println(String.format("简单工厂正在生产%s汽车", color)); Car car = mapCar.get(color); if (null == car) { System.out.println("对不起，没有这种颜色的汽车"); } return car; } } ``` ### 测试 ``` public class Test { public static void main(String[] args) { SimpleFactory simpleFactory = new SimpleFactory(); while (true){ System.out.println("请问需要什么颜色的汽车？yellow or black?"); Scanner input=new Scanner(System.in); String color=input.next();//读取输入的字符串 Car car = simpleFactory.createCar(color); if (Objects.nonNull(car)){ car.carColor(); car.carSpeed(); car.carPrice(); } } } } ``` ## 工厂方法 ### 类图  ### 实现 抽象一个工厂 ``` public abstract class CarFactory { abstract Car createCar(); } ``` 创建黑色汽车工厂 ``` public class BlackCarFactory extends CarFactory { public Car createCar() { System.out.println("工厂方法 正在生产黑色汽车...."); return new BlackCar(); } } ``` 创建黄色汽车工厂 ``` public class YellowCarFactory extends CarFactory{ public Car createCar(){ System.out.println("工厂方法 正在生产黄色汽车...."); return new YellowCar(); } } ``` ### 测试 ``` public class Test { public static void main(String[] args) { while (true){ CarFactory carFactory =null; System.out.println("请问需要什么颜色的汽车？yellow or black?"); Scanner input = new Scanner(System.in); String color=input.next();//读取输入的字符串 if (color.equals("yellow")){ carFactory = new YellowCarFactory(); }else if(color.equals("black")){ carFactory = new BlackCarFactory(); }else{ System.out.println("没有此类颜色的车"); continue; } Car car = carFactory.createCar(); if (Objects.nonNull(car)){ car.carColor(); car.carSpeed(); car.carPrice(); } } } } ``` ## 抽象工厂 ### 类图  ### 需求 我要生产汽车，但是汽车有很多不同的颜色。而且有不同的型号 ### 实现 创建抽象工厂,包含生产两个型号 ``` public abstract class CarFactory { abstract Car createCar1(); abstract Car createCar2(); } ``` 创建黑色汽车工厂，包含两个车型 ``` public class BlackCarFactory extends CarFactory { public Car createCar1() { System.out.println("抽象工厂 正在生产黑色汽车...."); return new BlackCar(); } public Car createCar2() { System.out.println("抽象工厂 正在生产黑色汽车2...."); return new BlackCar(); } } ``` 创建黄色汽车工厂，包含两个车型 ``` public class YellowCarFactory extends CarFactory { public Car createCar1(){ System.out.println("抽象工厂 正在生产黄色汽车1...."); return new YellowCar(); } public Car createCar2(){ System.out.println("抽象工厂 正在生产黄色汽车2...."); return new YellowCar(); } } ``` ### 测试 ``` public class Test { public static void main(String[] args) { while (true){ CarFactory carFactory =null; System.out.println("请问需要什么颜色的汽车？yellow or black?"); Scanner input = new Scanner(System.in); String color=input.next();//读取输入的字符串 if (color.equals("yellow")){ carFactory = new YellowCarFactory(); }else if(color.equals("black")){ carFactory = new BlackCarFactory(); }else{ System.out.println("没有此类颜色的车"); continue; } Car car = null; System.out.println("请问需要什么型号的汽车？1 or 2?"); input = new Scanner(System.in); String type=input.next();//读取输入的字符串 if (type.equals("1")){ car = carFactory.createCar1(); }else if(type.equals("2")){ car = carFactory.createCar2(); }else{ System.out.println("没有此类型号的车"); continue; } if (Objects.nonNull(car)){ car.carColor(); car.carSpeed(); car.carPrice(); } } } } ```

工厂模式是一种创建型设计模式，提供了一种创建对象的方式，使得客户端无需关心对象的具体创建过程。 ### 工厂模式的类型 1. **简单工厂模式（Simple Factory）** 2. **工厂方法模式（Factory Method）** 3. **抽象工厂模式（Abstract Factory）** ### 简单工厂模式 简单工厂模式又叫静态工厂方法模式，它通过一个工厂类来决定创建哪一种产品类的实例。虽然严格意义上不属于设计模式的范畴，但它非常常用。 #### 简单工厂模式的实现 ```java // 产品接口 public interface Coffee { void drink(); } // 具体产品类 public class Mocha implements Coffee { @Override public void drink() { System.out.println("Drinking Mocha"); } } public class Latte implements Coffee { @Override public void drink() { System.out.println("Drinking Latte"); } } // 简单工厂类 public class CoffeeFactory { public static Coffee createCoffee(String type) { if (type.equals("Mocha")) { return new Mocha(); } else if (type.equals("Latte")) { return new Latte(); } else { throw new IllegalArgumentException("Unknown coffee type"); } } } // 客户端代码 public class Client { public static void main(String[] args) { Coffee coffee = CoffeeFactory.createCoffee("Mocha"); coffee.drink(); } } ``` ### 工厂方法模式 工厂方法模式定义一个用于创建对象的接口，但由子类决定实例化哪一个类。工厂方法让类的实例化推迟到子类。 #### 工厂方法模式的实现 ```java // 产品接口 public interface Coffee { void drink(); } // 具体产品类 public class Mocha implements Coffee { @Override public void drink() { System.out.println("Drinking Mocha"); } } public class Latte implements Coffee { @Override public void drink() { System.out.println("Drinking Latte"); } } // 工厂方法接口 public interface CoffeeFactory { Coffee createCoffee(); } // 具体工厂类 public class MochaFactory implements CoffeeFactory { @Override public Coffee createCoffee() { return new Mocha(); } } public class LatteFactory implements CoffeeFactory { @Override public Coffee createCoffee() { return new Latte(); } } // 客户端代码 public class Client { public static void main(String[] args) { CoffeeFactory factory = new MochaFactory(); Coffee coffee = factory.createCoffee(); coffee.drink(); } } ``` ### 抽象工厂模式 抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式通过将产品类分组，让工厂创建相应的产品对象。 #### 抽象工厂模式的实现 ```java // 产品接口 public interface Coffee { void drink(); } public interface Dessert { void eat(); } // 具体产品类 public class Mocha implements Coffee { @Override public void drink() { System.out.println("Drinking Mocha"); } } public class Latte implements Coffee { @Override public void drink() { System.out.println("Drinking Latte"); } } public class Cake implements Dessert { @Override public void eat() { System.out.println("Eating Cake"); } } public class Cookie implements Dessert { @Override public void eat() { System.out.println("Eating Cookie"); } } // 抽象工厂接口 public interface CafeFactory { Coffee createCoffee(); Dessert createDessert(); } // 具体工厂类 public class MochaCafeFactory implements CafeFactory { @Override public Coffee createCoffee() { return new Mocha(); } @Override public Dessert createDessert() { return new Cake(); } } public class LatteCafeFactory implements CafeFactory { @Override public Coffee createCoffee() { return new Latte(); } @Override public Dessert createDessert() { return new Cookie(); } } // 客户端代码 public class Client { public static void main(String[] args) { CafeFactory factory = new MochaCafeFactory(); Coffee coffee = factory.createCoffee(); Dessert dessert = factory.createDessert(); coffee.drink(); dessert.eat(); } } ``` ### 工厂模式的优点 - 工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品。 - 客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可。 - 通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。 ### 工厂模式的缺点 - 不易扩展，一旦添加新的产品类型，就不得不修改工厂的创建逻辑。 - 产品类型较多时，工厂的创建逻辑可能过于复杂，一旦出错可能造成所有产品的创建失败，不利于系统的维护。