设计模式（二） 工厂模式

起源

我们一般在创建对象中，直接new一个实例，就可以创建对象。
但是，当我们创建对象有一个系列的步骤，并且这些对象利用次数较高。我们若是每次都要去new一个对象的过程，使得代码的耦合度变大，以及程序变得复杂。

类型

工厂模式分为三种：简单工厂模式，工厂模式，抽象工厂模式

• 简单工厂模式

创建一个工厂，该工厂有某一抽象产品，工厂实现不是通过接口实现的。

public abstract Plate{
  public void getPlate();
}

public class Flower extends Plate{
   @Override
   public void getPlate{
       system.out.println("Flower");
  }
}

public class Algae extends Plate{
  @Override
   public void getPlate{
       system.out.println("Algae");
  }
}

public class PlateFactory{
    public static Plate getPlate(String plate){
       Plate plate = null;
        switch(plate){
            case "Flower": 
                plate  = new FlowerFactory ();
                break;
            case "Algae":
                plate = new AlgaeFactory ();
                break;
        }
        return plate;
    }
}

public static void main(String[] args){
   PlateFactory plateFactory = new PlateFactory();
   Plate plate = plateFactory .getPlate("Flower");
   plate.getPlate();
}

• 工厂方法模式

特点：工厂模式是一个创建一个抽象工厂，这个抽象工厂中有一个抽象对象，为了遵循开闭原则【为了解耦】，使用抽象类是工厂模式的重点。

public interface PlateFactory{
  public Plate getPlate();
}

 public class FlowerFactory implement PlateFactory{
    @Override
    public Plate getPlate{
        return new Flower();
   }
 }

 public class AlgaeFactory implement PlateFactory{
    @Override
    public Plate getPlate{
        return new Algae ();
   }
 }

 public abstract class Plate{
     public String getPlate();
 }

 public class Flower extends Plate{
      @Override
      public String getPlate(){
        system.out.println("Flower");
     }
 }

public class Algae extends Plate{
      @Override
      public String getPlate(){
        system.out.println("Algae");
     }
}

public static void main(String[] args){
   AlgaeFactory algaeFactory = new AlageFactory();
   Algae algae = algaeFactory.getPlate(); 
}

• 抽象工厂模式

特点：一个抽象工厂有多个抽象产品。
缺点：若是增加产品族，则遵循开闭原则【用的下面的模式2，才能遵循】；若是某个产品，则违背了开闭原则。
抽象工厂模式有两种情况：
1. 某一个工厂生产某一个抽象产品，相当于多个工厂模式的组合。【违背接口隔离原则】
2. 某一个工厂中生产的某个具体的产品，具体产品组成的部件为抽象产品的多个产品之和。相当于是多个普通工厂模式之和。【耦合度较高,限制较高】
适用条件：对于多个抽象产品有大概的规划。

public abstract class Plate{
     public String getPlate();
 }

 public class Flower extends Plate{
      @Override
      public String getPlate(){
        system.out.println("Flower");
     }
 }

public class Algae extends Plate{
      @Override
      public String getPlate(){
        system.out.println("Algae");
     }
}

public abstract class Color{
   public abstract void fill();
}

public class Red extends Color{
  @Override
   public void fill(){
      system.out.println("Fill Red");
   }
}

public class Blue extends Color{
  @Override
   public void fill(){
      system.out.println("Fill Blue");
   }
}

多个普通工厂模式 组成的抽象工厂模式形式

public abstract class AbstractFactory{
     public abstract Color getColor(String color);
     public abstract  Plate getPlate(String plate);
}

public class FlowerFactory implement AbstractFactory {
    @Override
    public Plate getPlate(String plate){
        Plate plate = null;
        switch(plate){
            case "Flower": 
                plate  = new FlowerFactory ();
                break;
            case "Algae":
                plate = new AlgaeFactory ();
                break;
        }
        return plate;
    }
    
   @Override
    public Color getColor(String color){
        return null;
    }
}

public class ColorFactory implement AbstractFactory {
    @Override
    public Color getColor(String color){
        Color color= null;
        switch(color){
            case "Blue": 
                color  = new Blue();
                break;
            case "Red":
                color = new Red();
                break;
        }
        return color;
    }
    
   @Override
    public Plate getPlate(String plate){
        return null;
    }
}

多个工厂模式 组成的抽象工厂模式形式

public abstract class AbstractFactory{
     public abstract Color getColor();
     public abstract  Plate getPlate();
}

public class RedFlowerFactory implement AbstractFactory {
    @Override
    public Plate getPlate(){
        return new Flower();
    }
    
   @Override
    public Color getColor(String color){
       return new Red();
    }
}

public class BlueAlgaeFactory implement AbstractFactory {
    @Override
    public Color getColor(String color){
        return new Blue();
    }
    
   @Override
    public Plate getPlate(String plate){
         return new Algae();
    }
}

总结

工厂模式的目的是为了解耦，虽然我觉得抽象工厂模式有很多地方不能完美的满足六大原则，但是实际运用场景太多了。通过工厂模式，发现解耦的核心是运用接口，使其分离开，不产生太大的影响【这感觉就是迪米特法则的核心了】。