工厂模式

简单工厂模式（编码方式 不是设计模式）（接口抽象对象）

public class FactoryMod {
    public static void main(String[] args) {
        Application application = new Application();
        Product product = application.getObject(1);
        product.doSomething();
    }
}
interface Product {
    void doSomething();
}
//简单工厂模式（不是设计模式 是编程的一种习惯）
class SimpleFactory {
    public static Product getProduct(Integer i) {
        if (i.equals(0)) {
            return new ProductA();
        } else if (i.equals(1)) {
            return new ProductA();
        }
        return null;
    }
}
class ProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("ProductA.DoSomething excute");
        System.out.println("===============>");
    }
}
class ProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("ProductB.DoSomething excute");
        System.out.println("===============>");
    }
}
class Application {
    //    创建对应的实例
    private Product createProduct(Integer type) {
//        。。。。。doSomething
       // return new ProductA();
        return SimpleFactory.getProduct(type);
    }
    Product getObject(Integer type) {
       // ProductA productA = createProduct();
        Product product = createProduct(type);
        // 业务处理
        return product;
    }
}

工厂方法模式

abstract class Application1 {
    //    创建对应的实例
    abstract Product createProduct();
    Product getObject(Integer type) {
       // ProductA productA = createProduct();
        Product product = createProduct();
        // 业务处理
        return product;
    }
}
class ConCreateProductA extends Application1{
    @Override
    Product createProduct() {
        return new ProductA();
    }
}
class ConCreateProductB extends Application1{
    @Override
    Product createProduct() {
        return new ProductB();
    }
}

定义一个用于创建对象的接口，让子类决定实例化哪一个类。
FactoryMethod 使得一个类的实例化延迟到子类（抽象 abstract 或interface完成）

应用场景

1：当你不知道该使用对象的确切类型的时候
2：当你希望为库或框架提供扩展其内部组件的方式时

主要优点

1：将具体产品和创建者解耦
2：符合单一职责原则
3：符合开闭原则

步骤 1

创建一个接口:

Shape.java

public interface Shape {
   void draw();
}

public interface Shape { void draw();}

步骤 2

创建实现接口的实体类。

Rectangle.java

public class Rectangle implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}

Square.java

public class Square implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}

Circle.java

public class Circle implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

步骤 3

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

ShapeFactory.java

public class ShapeFactory {
   //使用 getShape 方法获取形状类型的对象
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
}

步骤 4

使用该工厂，通过传递类型信息来获取实体类的对象。

FactoryPatternDemo.java

public class FactoryPatternDemo {
   public static void main(String[] args) {
      ShapeFactory shapeFactory = new ShapeFactory();
      //获取 Circle 的对象，并调用它的 draw 方法
      Shape shape1 = shapeFactory.getShape("CIRCLE");
      //调用 Circle 的 draw 方法
      shape1.draw();
      //获取 Rectangle 的对象，并调用它的 draw 方法
      Shape shape2 = shapeFactory.getShape("RECTANGLE");
      //调用 Rectangle 的 draw 方法
      shape2.draw();
      //获取 Square 的对象，并调用它的 draw 方法
      Shape shape3 = shapeFactory.getShape("SQUARE");
      //调用 Square 的 draw 方法
      shape3.draw();
   }
}

步骤 5

Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.

抽象工厂模式

一系列工厂方法模式的组合

应用场景：

程序需要处理不用系列的相关产品，但是我们不希望它依赖于这些产品的具体类的是时候可以使用抽象工厂

优点：

1. 可以确信你的从工厂得到的产品是彼此兼容的
2. 可以避免具体产品和客户端代码之间的紧密耦合
3. 符合单一职责原则
4. 符合开闭原则（扩展开放，修改关闭）