工厂模式

工厂模式分为三种模式,分别为:

  •  简单工厂(Simple Factory)模式:又称静态工厂方法模式(Static Factory Method Pattern)
  • 工厂方法(Factory Method)模式:又称多态性工厂模式(Polymorphic Factory Pattern)或虚拟构造子模式(Virtual Construct Pattern)
  • 抽象工厂(Abstract Factory)模式:又称工具箱模式(Kit或Tookit)

下面就分别介绍一下这三种设计模式:

  1.  简单工厂模式(Simple Factory):

  简单工厂模式就是由一个工厂类根据传入的参数量,来决定创建哪一种产品类的实例。(仔细理解这句话,非常重要)

结构图:

 

上图涉及三个类:

  • 工厂类(Creator):担任工厂模式的核心。工厂类在客户端的调用下直接创建对象,它往往由一个具体类java类实现。
  • 抽象产品类(Product):具体产品类的接口或抽象类。
  • 具体产品类(ConcreteProduct):工厂方法模式所创建的任何角色都是这个角色的实例

源代码实例:

抽象产品类(Product):

Product.java:

public interface Product {
}

具体产品类(ConcreteProduct):

ConcreteProductA.java:

public class ConcreteProductA implements Product{
    public ConcreteProductA(){
        System.out.println("具体产品类A");
    }
}

ConcreteProductB.java:

public class ConcreteProductB implements Product{
    public ConcreteProductB(){
        System.out.println("具体产品类B");
    }
}

工厂类(Creator):

Creator.java:

public class Creator {
    
    public static Product factory(String which){
        if (which.equalsIgnoreCase("ConcreteProductA")) {
            return new ConcreteProductA();
        }else if (which.equalsIgnoreCase("ConcreteProductB")) {
            return new ConcreteProductB();
        }else {
            return null;
        }
    }
}

客户端:

public class Client {
    public static void  main(String[] args){
        Creator creator = new Creator();
        creator.factory("ConcreteProductB");
        creator.factory("ConcreteProductA");
        
    }
}

输出:

具体产品类B
具体产品类A

    2、工厂方法模式(Factory Method)

     工厂方法模式中核心工厂类变为一个抽象类,仅负责给出具体工厂子类必须实现的接口,不再接触哪一个产品类被实例化这种细节。

工厂模式_第1张图片

结构中成员类和上面差不多,:

  • 抽象工厂类(Creator):为所有具体工厂类提供接口。
  • 具体工厂类(ConcreteCreator):担任这个角色是实现了抽象工厂接口的具体java类,并且受到应用程序的调用来创建产品。
  • 抽象产品(Product)
  • 具体产品(ConcreteProduct)

抽象方法将某一个产品和一个工厂进行了绑定,这是他与另外两个工厂模式的区别。下面注意看代码:源代码:

抽象产品(Product):

public interface Product {

}

 

 具体产品(ConcreteProduct)类:

ConcreProductA.java:

public class ConcreteProductA implements Product{
    public ConcreteProductA(){
        System.out.println("具体产品类A");
    }
}

 

ConcreProductB.java:

public class ConcreteProductB implements Product{
    public ConcreteProductB(){
        System.out.println("具体产品类B");
    }
}

 

抽象工厂类(Creator):

Creator.java:

public interface Creator {
    public Product factory();
}

 

具体工厂类(ConcreteCreator):

ConcreteCreatorA.java:

public class ConcreteCreatorA implements Creator{

    @Override
    public Product factory() {
        return new ConcreteProductA();
    }
}

 

ConcreteCreatorB.java:

public class ConcreteCreatorB implements Creator{
    
    @Override
    public Product factory() {
        return new ConcreteProductB();
    }
    
}

客户端:

public class Client {

    public static void main(String[] args){
        Creator creatorA = new ConcreteCreatorA();
        creatorA.factory();
        Creator creatorB = new ConcreteCreatorB();
        creatorB.factory();
    }
}

 

输出:

具体产品类A
具体产品类B

 

    3、抽象工厂模式(Abstract Factory)

  抽象工厂模式是对象的创建模式,他是工厂方法模式的进一步扩展。使用抽象工厂模式,可以创建来自不同工厂的各种产品。

工厂模式_第2张图片

 

 

 

 

结构图中的角色:

  • 抽象工厂类(Creator)
  • 具体工厂类(ConcreteCreator)
  • 抽象产品(Product)
  • 具体产品(ConcreteProduct)

源代码:

抽象产品类(Product):

ProductA.java

public interface ProductA {
}

 

ProductB.java

public interface ProductB {
}

 

具体产品类(ConcreteProduct):

ProductA1.java

public class ProductA1 implements ProductA{
    
    public ProductA1(){
        System.out.println("具体产品A1");
    }
}

 

productA2.java、productB1.java、productB2.java与上类似,不在列出。

抽象工厂类(Creator):

Creator.java

public interface Creator {
    
    public ProductA factoryA();
    public ProductB factoryB();
}

 

 具体工厂类(ConcreteCreator):

ConcreteCreator1.java

public class ConcretCreator1 implements Creator{

    public ConcretCreator1(){
        System.out.println("具体工厂1:");
    }
    public ProductA factoryA(){
        return new ProductA1();
    }
    public ProductB factoryB(){
        return new ProductB1();
    }

}

 

ConcreteCreator2.java

public class ConcretCreator2 implements Creator{

    public ConcretCreator2(){
        System.out.println("具体工厂2:");
    }
    public ProductA factoryA() {
        return new ProductA2();
    }

    public ProductB factoryB() {
        return new ProductB2();
    }

}

 

 客户端:

public class client {
    public static void main(String[] args){
        //抽象工厂1
        Creator creator1 = new ConcretCreator1();
        creator1.factoryA();
        creator1.factoryB();
        Creator creator2 = new ConcretCreator2();
        creator2.factoryA();
        creator2.factoryB();
    }
}

 

 输出:

具体工厂1:
具体产品A1
具体产品B1
具体工厂2:
具体产品A2
具体产品B2

 

你可能感兴趣的:(工厂模式)