简单工厂模式

介绍

  1. 简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式
  2. 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)
  3. 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式.

案例

客户买车
image-20201018185958096.png

  1. //车的抽象类
  2. public abstract class Car {
  3.      String name;
  5.     public Car(String name) {
  6.         this.name = name;
  7.     }
  8. }
  10. //特斯拉汽车
  11. public class Tesla extends Car{
  12.     public Tesla(String name) {
  13.         super(name);
  14.     }
  15. }
  17. //五菱汽车
  18. public class Wuling extends Car{
  19.     public Wuling(String name) {
  20.         super(name);
  21.     }
  22. }
  1. //车工厂
  2. public class Factory {
  3.     //方法1
  4.     public static Car getCar(String name){
  5.         if (name.equals("特斯拉")){
  6.             return new Tesla(name);
  7.         }else if (name.equals("五菱")){
  8.             return new Wuling(name);
  9.         }else {
  10.             System.out.println("没有此车");
  11.             return null;
  12.         }
  13.     }
  15.  /*
  16.    //方法2
  17.     public static Car getTesla(){
  18.         return new Tesla("特斯拉");
  19.     }
  21.     public static Car getWuling(){
  22.         return new Tesla("五菱");
  23.     }
  24.     */
  25. }
  1. //cliet端使用工厂对象就可以得到车子实例对象
  2. public class Client {
  3.     public static void main(String[] args) {
  4.         Car car = Factory.getCar("特斯拉");
  5.         System.out.println(car.name);
  7.         Car car1 = Factory.getCar("五菱");
  8.         System.out.println(car1.name);
  9.     }
  10. }

个人总结
简单工厂的弊端是：如果需要扩展工厂输出的实例对象，则需要修改工厂类的逻辑代码，违反了开闭原则

工厂方法模式

介绍
定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类

案例
客户买车image-20201018192551844.png

  1. //车的抽象类
  2. public abstract class Car {
  3.      String name;
  5.     public Car(String name) {
  6.         this.name = name;
  7.     }
  8. }
  10. //特斯拉汽车
  11. public class Tesla extends Car{
  12.     public Tesla(String name) {
  13.         super(name);
  14.     }
  15. }
  17. //五菱汽车
  18. public class Wuling extends Car{
  19.     public Wuling(String name) {
  20.         super(name);
  21.     }
  22. }
  1. //工厂抽象类
  2. public interface Factory {
  3.     public Car getCar();
  4. }
  6. //特斯拉工厂
  7. public class TeslaFactory implements Factory{
  8.     @Override
  9.     public Car getCar() {
  10.         return new Tesla("特斯拉");
  11.     }
  12. }
  14. //五菱工厂
  15. public class WulingFactory implements Factory{
  16.     @Override
  17.     public Car getCar() {
  18.         return new Wuling("五菱宏光");
  19.     }
  20. }
  1. //扩展一个大众车子类,并不需要改变原来的代码
  2. public class Dazhong extends Car{
  3.     public Dazhong(String name) {
  4.         super(name);
  5.     }
  6. }
  8. public class DazhongFactory implements Factory{
  9.     @Override
  10.     public Car getCar() {
  11.         return new Dazhong("大众");
  12.     }
  13. }
  1. //Client根据需要买的车创建对应的车工厂得到车
  2. public class Client {
  3.     public static void main(String[] args) {
  4.         Car car1 = new TeslaFactory().getCar();
  5.         System.out.println(car1.name);
  7.         Car car2 = new WulingFactory().getCar();
  8.         System.out.println(car2.name);
  10.         Car car3 = new DazhongFactory().getCar();
  11.         System.out.println(car3.name);
  12.     }
  13. }

个人总结
工厂方法模式虽然符合开闭原则,但是编程难度和类的数量会增加,谨慎使用

抽象工厂模式

介绍

  1. 抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类
  2. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
  3. 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
  4. 将工厂抽象成两层，AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇， 更利于代码的维护和扩展。

原理image-20201018200934195.png
对原理类图的说明-即(职责链模式的角色及职责)
1)productA和productB是某产品的抽象类
2)productA1,productA2,productB1,productB2产品的具体实现类
3)Creator超级工厂(抽象),定义需要生产的抽象产品方法
4)ConcreteCreator1和ConcreteCreator2是具体的工厂

案例
需要生产华为的手机和路由器和小米的手机和路由器

  1. //抽象手机类
  2. public interface Phone {
  3.     void open();
  4.     void call();
  5.     void  sendMessage();
  6.     void close();
  7. }
  9. //小米手机
  10. public class XiaomiPhone implements Phone{
  11.     @Override
  12.     public void open() {
  13.         System.out.println("小米手机开机");
  14.     }
  16.     @Override
  17.     public void call() {
  18.         System.out.println("小米手机打电话");
  19.     }
  21.     @Override
  22.     public void sendMessage() {
  23.         System.out.println("小米手机发信息");
  24.     }
  26.     @Override
  27.     public void close() {
  28.         System.out.println("小米手机关机");
  29.     }
  30. }
  32. //华为手机
  33. public class HuaweiPhone implements Phone{
  34.     @Override
  35.     public void open() {
  36.         System.out.println("华为手机开机");
  37.     }
  39.     @Override
  40.     public void call() {
  41.         System.out.println("华为手机打电话");
  42.     }
  44.     @Override
  45.     public void sendMessage() {
  46.         System.out.println("华为手机发信息");
  47.     }
  49.     @Override
  50.     public void close() {
  51.         System.out.println("华为手机关机");
  52.     }
  53. }
  1. //抽象路由类
  2. public interface Route {
  3.     void open();
  4.     void set();
  5.     void close();
  6. }
  8. //小米路由
  9. public class XiaomiRoute implements Route{
  10.     @Override
  11.     public void open() {
  12.         System.out.println("小米路由器开启");
  13.     }
  15.     @Override
  16.     public void set() {
  17.         System.out.println("小米路由器设置");
  18.     }
  20.     @Override
  21.     public void close() {
  22.         System.out.println("小米路由器关闭");
  23.     }
  24. }
  26. //华为路由
  27. public class HuaweiRoute implements Route{
  28.     @Override
  29.     public void open() {
  30.         System.out.println("华为路由器开启");
  31.     }
  33.     @Override
  34.     public void set() {
  35.         System.out.println("华为路由器设置");
  36.     }
  38.     @Override
  39.     public void close() {
  40.         System.out.println("华为路由器关闭");
  41.     }
  42. }
  1. //抽象超级工厂(创建工厂的工厂)
  2. public interface SuperFactory {
  3.     public Phone productPhone();
  4.     public Route productRoute();
  5. }
  7. //小米工厂
  8. public class XiaomiFactory implements SuperFactory{
  10.     @Override
  11.     public Phone productPhone() {
  12.         return new XiaomiPhone();
  13.     }
  15.     @Override
  16.     public Route productRoute() {
  17.         return new XiaomiRoute();
  18.     }
  19. }
  21. //华为工厂
  22. public class HuaweiFactory implements SuperFactory{
  23.     @Override
  24.     public Phone productPhone() {
  25.         return new HuaweiPhone();
  26.     }
  28.     @Override
  29.     public Route productRoute() {
  30.         return new HuaweiRoute();
  31.     }
  32. }
  1. //Client端调用(需要哪一个品牌的产品,先把工厂new出来)
  2. public class Client {
  3.     public static void main(String[] args) {
  4.         System.out.println("================小米系列===================");
  5.         XiaomiFactory xiaomiFactory = new XiaomiFactory();
  6.         Phone phone1 = xiaomiFactory.productPhone();
  7.         phone1.open();
  8.         phone1.sendMessage();
  10.         Route route1 = xiaomiFactory.productRoute();
  11.         route1.open();
  12.         route1.set();
  13.         System.out.println("================华为系列===================");
  14.         HuaweiFactory huaweiFactory = new HuaweiFactory();
  15.         Phone phone2 = huaweiFactory.productPhone();
  16.         phone2.open();
  17.         phone2.sendMessage();
  19.         Route route2 = huaweiFactory.productRoute();
  20.         route2.open();
  21.         route2.set();
  23.     }
  24. }

image-20201018211128224.png

工厂模式小结

  1. 工厂模式的意义将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
  2. 三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)
  3. 设计模式的依赖抽象原则

1)创建对象实例时，不要直接 new 类, 而是把这个new 类的动作放在一个工厂的方法中，并返2)回。有的书上说，变量不要直接持有具体类的引用。
2)不要让类继承具体类，而是继承抽象类或者是实现interface(接口)
3)不要覆盖基类中已经实现的方法。