设计模式-工厂模式

设计模式的六大原则

1、开闭原则（Open Close Principle）

开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

3、依赖倒转原则（Dependence Inversion Principle）

这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

5、迪米特法则，又称最少知道原则（Demeter Principle）

最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。

工厂模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

---

介绍

1. 主要解决：主要解决接口选择的问题。
2. 何时使用：我们明确地计划不同条件下创建不同实例时。
3. 应用实例： 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。

实现

步骤1

public interface Car {
   void createCar();
}

步骤 2

public class Baoma implements Car {
 
   @Override
   public void createCar() {
      System.out.println("创造了一个宝马车");
   }
}

public class Luhu implements Car {
 
   @Override
   public void createCar() {
      System.out.println("创造了一个路虎车");
   }
}

步骤 3
创建一个工厂，生成基于给定信息的实体类的对象。

public class CarFactory {
    
   //使用 getCar 方法获取形状类型的对象
   public Car getCar(String carType){
      if(carType == null){
         return null;
      }        
      if(carType.equals("baoma")){
         return new Baoma();
      } else if(carType.equals("luhu")){
         return new Luhu();
      } 
      return null;
   }
}

步骤 4

public class FactoryCarDemo {
 
   public static void main(String[] args) {
      CarFactory carFactory = new CarFactory();
 
      //获取宝马的对象
      Car baomaCar = carFactory.getCar("baoma");
 
      //调用宝马的创建车方法
      baomaCar.createCar();
 
      //获取路虎的对象
      Car luhuCar = carFactory.getCar("luhu");
 
      //调用路虎的创建车方法
      luhuCar.createCar();
   }
}

执行结果

创造了一个宝马车
创造了一个路虎车

---

抽象工程模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
介绍

1. 主要解决：主要解决接口选择的问题。
2. 何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
3. 应用实例：工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。假设一种情况（现实中是不存在的，要不然，没法进入共产主义了，但有利于说明抽象工厂模式），在您的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OO 的思想去理解，所有的衣柜（具体工厂）都是衣柜类的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），这些具体的上衣其实也都是上衣（抽象产品），具体的裤子也都是裤子（另一个抽象产品）。
   实现

步骤1

public interface Car {
   void createCar();
}

步骤 2

public class Baoma implements Car {
 
   @Override
   public void createCar() {
      System.out.println("创造了一个宝马车");
   }
}

public class Luhu implements Car {
 
   @Override
   public void createCar() {
      System.out.println("创造了一个路虎车");
   }
}

步骤 3
为颜色创建一个接口。

public interface Color {
   void fill();
}

步骤 4
为颜色创建一个接口。

public class Red implements Color {
 
   @Override
   public void fill() {
      System.out.println("添加红色");
   }
}

public class Blue implements Color {
 
   @Override
   public void fill() {
      System.out.println("添加蓝色");
   }
}

步骤 5
为 car 和 color 对象创建抽象类来获取工厂。

public abstract class AbstractFactory {
   public abstract Car getCar(String carType);
   public abstract Color getColor(String colorType) ;
}

步骤 6
创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。

public class BaomaFactory extends AbstractFactory {
    
   @Override
   public Car getCar(){
      return new Baoma();
   }
   
   @Override
   public Color getColor() {
      return new Red();
   }
}

public class LuhuFactory extends AbstractFactory {
    
   @Override
   public Car getCar(String carType){
      return new Luhu()
   }
   
   @Override
   public Color getColor() {
      return new Blue();
   }
}

步骤 7
创建一个工厂创造器/生成器类，获取工厂。

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equals("baoma")){
         return new BaomaFactory();
      } else if(choice.equals("luhu")){
         return new LuhuFactory();
      }
      return null;
   }
}

步骤 8

public class AbstractFactoryPatternDemo {
	public static void main(String[] args){
		AbstractFactory baomaFactory=FactoryProducer.getFactory("baoma");
     	Car baomaCar = baomaFactory.getCar();
     	Color redColor=baomaFactory.getColor();
     	baomaCar.createCar(); // 输出创造了一个宝马车
     	redColor.fill(); // 添加红色
     	
     	AbstractFactory luhuFactory=FactoryProducer.getFactory("luhu");
     	Car luhuCar = luhuFactory.getCar();
     	Color blueColor=luhuFactory.getColor();
     	luhuCar.createCar();// 输出创造了一个路虎车
     	redColor.fill();// 添加蓝色
	}
}

---

抽象工厂类图介绍

---

---