JAVA23种工厂模式

一、设计模式分类

设计模式主要分为三类：

创建模式：工厂方法模式、抽象工厂模式、单列模式、建造者模式、原型模式。（5种）

结构型模式：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。（7种）

行为型模式：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。（11种）

 

二、设计模式的六大原则：

总原则：开闭原则（Open Close Principle）

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

1、单一职责原则

不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，如若不然，就应该把类拆分。

 

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

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

历史替换原则中，子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它。

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

这个是开闭原则的基础，具体内容：面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互。

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

这个原则的意思是：每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。

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

就是说：一个类对自己依赖的类知道的越少越好。也就是说无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。

最少知道原则的另一个表达方式是：只与直接的朋友通信。类之间只要有耦合关系，就叫朋友关系。耦合分为依赖、关联、聚合、组合等。我们称出现为成员变量、方法参数、方法返回值中的类为直接朋友。局部变量、临时变量则不是直接的朋友。我们要求陌生的类不要作为局部变量出现在类中。

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

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

 

1.简单工厂模式

简单工厂模式不属于23种模式，简单工厂模式一般分为：普通简单工厂、多方法简单工厂、静态方法简单工厂。

1.1  普通简单工厂模式

代码示例:

首先，定义一个公共接口

public interface Car{  
    public void run();
    public void stop();  
      
}

其次，创建实现类

public class Bmw implements Car{  
    @Override  
    public void run() {  
        System.out.println("Bmw启动");  
    }  
    @Override
  public void stop() {  
        System.out.println("Bmw刹车");  
    }  
}  

public class Audi implements Car{  
    @Override  
    public void run() {  
        System.out.println("Audi 启动");  
    }  
    @Override
  public void stop() {  
        System.out.println("Audi  刹车");  
    }  
}  

最后，创建工厂类

public class CarFactory {  
  
    public Car produce(String type) {  
        if ("bwm".equals(type)) {  
            return new Bwm();  
        } else if ("audi".equals(type)) {  
            return new Audi();  
        } else { 
            return null;  
        }  
    }  
}  

测试类如下：

public class FactoryTest {  
  
    public static void main(String[] args) {  
        CarFactory factory = new CarFactory();  
        Car car= factory.produce("audi");  
        car.run();  
    }  
}

输出：Audi 启动

1.2 多方法简单工厂

多方法简单工厂是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

将上面的代码做下修改，改动下CarFactory类就行，如下：

public class CarFactory {  
   public Car produceBmw(){  
        return new Bmw();  
    }  
      
    public Car produceAudi(){  
        return new Audi();
    }  
}  

1.3 静态方法简单工厂

将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

public class CarFactory {  
   public static Car produceBmw(){  
        return new Bmw();  
    }  
      
    public static Car produceAudi(){  
        return new Audi();
    }  
}  

 

2.工厂方法模式（Factory Method）

简单工厂模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到工厂方法模式，创建一个工厂接口和创建多个工厂实现类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

代码示例：

public interface Car{  
    public void run();
    public void stop();  
      
}

创建两个实现类

public class Bmw implements Car{  
    @Override  
    public void run() {  
        System.out.println("Bmw启动");  
    }  
    @Override
  public void stop() {  
        System.out.println("Bmw刹车");  
    }  
}  

public class Audi implements Car{  
    @Override  
    public void run() {  
        System.out.println("Audi 启动");  
    }  
    @Override
  public void stop() {  
        System.out.println("Audi  刹车");  
    }  
} 

接着，提供一个接口

 

public interface Provider {  

    public Car produce();  
}

 

接着，创建两个工厂类

public class BmwFactory implements Provider {  
      
    @Override  
    public Car produce(){  
        return new Bmw();
    }  
}

public class AudiFactory implements Provider {  
      
    @Override  
    public Car produce(){  
        return new Audi();
    }  
}

测试类

public class Test {  
  
    public static void main(String[] args) {  
        Provider provider = new BmwFactory();  
        Car car= provider.produce();  
        car.run();
    }  
}

工厂方法模式的好处就是，如果你现在想增加一个功能：只需做一个实现类，实现Car接口，同时做一个工厂类，实现Provider接口，无需去改动现成的代码。这样做，拓展性较好！

3.抽象工厂模式

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。 
一个抽象工厂类，可以派生出多个具体工厂类。 
每个具体工厂类可以创建多个具体产品类的实例，也就是创建的是一个产品线下的多个产品。

代码示例：

创建两个接口

public interface IProductA {
    public void method();
    
}

public interface IProductB {
    public void method();

}

接着，创建两个实现类

public class ProductA1 implements IProductA{

    public void method() {
        System.out.println("我是厂商1。。。生产鼠标");
    }

}


public class ProductA2 implements IProductA{

    public void method() {
        System.out.println("我是厂商2。。。生产鼠标");
        
    }

}

public class ProductB1 implements IProductB{

    public void method() {
        System.out.println("我是厂商1。。。。生产键盘");
        
    }

}

public class ProductB2 implements IProductB{

    public void method() {
        System.out.println("我是厂商2。。。生产键盘");
    }

}

然后，创建两个创建两个抽象类或者是接口（这里我使用抽象类）

public abstract class ProductAFactory {
    abstract IProductA getProductA1();
    abstract IProductB getProductB1();
}

public abstract class ProductBFactory {
    abstract IProductA getProductA2();
    abstract IProductB getProductB2();

}

接着，创建两个类继承上面的两个抽象类

public class ConcreteFactoryA extends ProductAFactory{

    IProductA getProductA1() {
        
        return new ProductA1();
    }

    IProductB getProductB1() {
        
        return new ProductB1();
    }

}

public class ConcreteFactoryB extends ProductBFactory{

    IProductA getProductA2() {
        
        return new ProductA2();
    }

    IProductB getProductB2() {
        
        return new ProductB2();
    }

}

测试类

public class Test {
    public static void main(String[] args) {
        ProductAFactory paf=new ConcreteFactoryA();
        IProductA A1=paf.getProductA1();
        IProductB B1=paf.getProductB1();
        A1.method();
        B1.method();
        
        ProductBFactory pbf=new ConcreteFactoryB();
        IProductA A2=pbf.getProductA2();
        IProductB B2=pbf.getProductB2();
        A2.method();
        B2.method();
        
        }
}

工厂方法模式和抽象工厂模式的区别：

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。