文章目录
- 工厂模式
- 简单工厂模式
- 简单工厂模式使用的场景
- 工厂方法模式
- 工厂方法模式使用场景
- 抽象工厂模式
- 抽象工厂模式使用场景
工厂模式
功能：将对象的创建交给工厂，我们只需要告诉工厂我们要什么对象就可以得到该对象。
目的：实现创建对象和使用对象分离；让我们更加关注需要什么，而不是这个是怎么来的。
工厂模式根据不同的创建场景和创建需求可以分为：简单工厂、工厂方法、抽象工厂。
例如：现在需要制造汽车，汽车有不同的颜色，将不同的颜色分成类。
将汽车抽象为一个Car抽象类，不同颜色的汽车分别继承它。
public abstract class Car {String color;public abstract void carColor();public void carSpeed(){System.out.println(String.format("正在生产%s的汽车,时速100KM/h",color));}public void carPrice(){System.out.println(String.format("正在生产%s的汽车,价格10W",color));}
}public class BlackCar extends Car {public BlackCar() {this.color = "黑色";}@Overridepublic void carColor() {System.out.println(String.format("生产的是%s的车",color));}
}public class PinkCar extends Car {public PinkCar() {this.color = "粉色";}@Overridepublic void carColor() {System.out.println(String.format("生产的是%s的车",color));}
}在最开始我们要创建什么汽车就会手动的new对应的汽车，
简单工厂模式
简单工厂不是一种设计模式，它是为接下来的工厂方法模式提供基础的。
通过简单工厂模式会创建如下的一个工厂：
public class SimpleFactory {public Car creatCar(String color){if ("pink".equals(color)){return new PinkCar();}else if("black".equals(color)){return new BlackCar();}else {System.out.println("无法制造"+color+"颜色的车");return null;}}
}
测试代码：
public class Test {public static void main(String[] args) {SimpleFactory factory = new SimpleFactory();Car pink = factory.creatCar("pink");pink.carColor();pink.carPrice();pink.carSpeed();}
}/*
生产的是粉色的车
正在生产粉色的汽车,价格10W
正在生产粉色的汽车,时速100KM/h
*/
类图如下：
用标识符“pink”传递非常容易出错，我们可以使用java提供的反射，此时简单工厂变为：
public class SimpleFactory {public Car creatCar(Class<? extends Car> clazz){try {return clazz.newInstance();} catch (InstantiationException e) {throw new RuntimeException(e);} catch (IllegalAccessException e) {throw new RuntimeException(e);}}
}
测试代码变为：
public class Test {public static void main(String[] args) {SimpleFactory factory = new SimpleFactory();Car pink = factory.creatCar(PinkCar.class);pink.carColor();pink.carPrice();pink.carSpeed();}
}
类图如下：用户之和工厂之间有联系，而和具体的汽车类是没有联系的。
简单工厂模式使用的场景
工厂负责创建的对象较少。
客户端只需要出入一个工厂类的参数，对于内部的逻辑不用关心。
优点：只需要插入一个正确的参数，无需在意细节。
缺点：工厂类的职责相对较重，新增产品时需要修改工厂的逻辑，违背开闭原则。不宜扩展过于复杂的产品结构。
工厂方法模式
简单工厂模式中，一旦需要大规模的添加新的创建对象时需要修改工厂的逻辑，违背开闭原则，不方便使用。
工厂方法模式与简单工厂模式不同的是：方法工厂模式会为每一个类创建一个工厂，用的时候就会创建自己对应的工厂，通过对应的工厂创建对象；再创建一个总工厂，就是对工厂的抽象。
三个汽车类不变，
创建对应的工厂类
public abstract class CarFactory {abstract Car creatCar();
}
public class PinkCarFactory extends CarFactory{@OverrideCar creatCar() {System.out.println("正在生产粉色汽车");return new PinkCar();}
}
public class BlackCarFactory extends CarFactory {@OverrideCar creatCar() {System.out.println("正在生产黑色汽车");return new BlackCar();}
}
测试：
public static void main(String[] args) {CarFactory carFactory = null ;Scanner scanner = new Scanner(System.in);System.out.println("请输入您想要生产的汽车颜色");String s = scanner.next();if(s.equals("black")){carFactory = new BlackCarFactory();}else if(s.equals("pink")){carFactory = new PinkCarFactory();}else {System.out.println("没有这类颜色的车");}carFactory.creatCar();}
工厂方法模式使用场景
创建对象需要大量重复的代码。
优点：
产品只需要要关心对应的工厂，无需关心创建细节。
加入新的产品时符合开闭原则，提高系统的可扩展性。
缺点：
类的数量过多，增加了代码结构的复杂度。
增加了系统的抽象性和理解难度。
抽象工厂模式
是为访问类提供一个创建一系列相关或相互依赖对象的接口，无需指定他们具体的类，就能得到同族的不同等级的产品。
什么意思呢？
利用B站视屏的例子：
左图中商务一套搭配属于同一族，右边运动服属于一族，右边的外套和左边的外套属于不同组的同一个等级，右图中的上衣，裤子，鞋是同族的不同等级产品。
以上提到的只是汽车的颜色不同，例如，无论什么颜色的车都有七座和五座两种。
结构
- 抽象工厂：提供创建产品的接口，包含多个创建产品的方法，可以创建多个不同等级的产品。
- 具体工厂：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
- 抽象产品：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
- 具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。
还是上面那个汽车案例，要求：黑色汽车安装A类引擎，粉色汽车安装B类引擎。则黑色汽车和A类引擎是同一族，粉色汽车和黑色汽车是同一等级。
具体实现：
具体产品和抽象产品:
public abstract class Car {String color;public abstract void carColor();
}
public class BlackCar extends Car {public BlackCar() {this.color = "黑色";}@Overridepublic void carColor() {System.out.println(String.format("生产的是%s的车", color));}
}
public class PinkCar extends Car {public PinkCar() {this.color = "粉色";}@Overridepublic void carColor() {System.out.println(String.format("生产的是%s的车", color));}
}
public abstract class Engine {abstract void getEngine();
}
public class EngineA extends Engine{@Overridevoid getEngine() {System.out.println("引擎A");}
}
public class EngineB extends Engine{@Overridevoid getEngine() {System.out.println("引擎B");}
}
具体工厂和抽象工厂:
public abstract interface CarFactory {//生产汽车Car creatCar();//生产引擎Engine creatEngine();
}
public class BlackFactory implements CarFactory{@Overridepublic Car creatCar() {return new BlackCar();}@Overridepublic Engine creatEngine() {return new EngineA();}
}
public class PinkCarFactory implements CarFactory {@Overridepublic Car creatCar() {return new PinkCar();}@Overridepublic Engine creatEngine() {return new EngineB();}
}
test:
public class Test {public static void main(String[] args) {BlackFactory blackFactory = new BlackFactory();Car car = blackFactory.creatCar();Engine engine = blackFactory.creatEngine();car.carColor();engine.getEngine();PinkCarFactory pinkCarFactory = new PinkCarFactory();Car car1 = pinkCarFactory.creatCar();Engine engine1 = pinkCarFactory.creatEngine();car1.carColor();engine1.getEngine();}
}
/*
生产的是黑色的车
引擎A
生产的是粉色的车
引擎B
*/
如果要加入同一个产品族的话,只需要再加一个对应的工厂类即可，不需要修改其他产品族的对象。
抽象工厂模式使用场景
- 当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机，洗衣机，空调等。
- 系统中有多个产品族，但每次使用其中的某一族产品。如有人只喜欢某一个品牌的衣服和鞋。
- 系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖具体实现。
优点：当产品族中多个对象被设计成在一起工作时，他能保证客户端始终只使用同一个产品族中的对象。（固定搭配）
缺点：如果要在产品族中添加一个产品的话，所有的工厂类都需要改动。
