java设计模式——工厂模式

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

用于：

需要大量实例化某批某些类（都是同一种产品，但某些加工方式不同，加工工厂不同）的对象时，随着需求的改变实例化对象也不同。

依赖抽象的原则：

    1.变量不要持有具体类的引用  ，解释下就是不要直接new一个具体的实例，而是获取通过工厂方法返回的对象实例

    2.不要让类继承自具体类，要继承自抽象类或接口

    3.不要覆盖类中已实现的方法

三种工厂模式实现方法

简单工厂模式

定义了一个创建对象的类，由这个类来封装实例化对象的行为。

（献上我的奇怪画笔...以后再也不画了） 

package FactoryPattern.SimpleFactory;

/**
 * Description:Pizza超类
 * @author tzw
 * CreateTime 10:22 2020/3/19
 **/
public abstract class Pizza {

    private String name;

    public void setName(String name)
    {
        this.name=name;
    }

    public abstract void prepare();

    public void bake(){
        System.out.println(name+"bake");
    }

    public void cut(){
        System.out.println(name+"cut");
    }

    public void box(){
        System.out.println(name+"box");
    }

}




package FactoryPattern.SimpleFactory;

/**
 * Description:A类型pizza
 * @author tzw
 * CreateTime 10:26 2020/3/19
 **/
public class A_Pizza extends Pizza{

    @Override
    public void prepare() {
        super.setName("A_pizza");
        System.out.println("A_prepare");
    }

}


package FactoryPattern.SimpleFactory;

/**
 * Description:B类型pizza
 * @author tzw
 * CreateTime 10:28 2020/3/19
 **/
public class B_Pizza extends Pizza{

    public void prepare() {
        super.setName("B_Pizza");
        System.out.println("B_prepare");
    }

}


package FactoryPattern.SimpleFactory;

/**
 * Description:将pizza类型判断封装入工厂
 * @author tzw
 * CreateTime 10:29 2020/3/19
 **/
public class SimpleFactory {


    public Pizza createPizza(String orderType)
    {
        if(orderType.equals("A"))
            return new A_Pizza();
        else if(orderType.equals("B"))
            return new B_Pizza();
        else
            return null;
    }
}




package FactoryPattern.SimpleFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * Description:将工厂封装进类里
 * @author tzw
 * CreateTime 10:37 2020/3/19
 **/
public class OrderPizza {
    SimpleFactory simpleFactory;

    public OrderPizza(SimpleFactory simpleFactory)
    {
        setSimpleFactory(simpleFactory);
    }
    public void setSimpleFactory(SimpleFactory simpleFactory)
    {
        Pizza pizza=null;
        String orderType;
        this.simpleFactory=simpleFactory;
        do{
            orderType=getType();
            pizza=simpleFactory.createPizza(orderType);
            if(pizza!=null)
            {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }
        }while (true);
    }

    private String getType() {
        try {
            System.out.println("input Pizza type:");
            BufferedReader str=new BufferedReader(new InputStreamReader(System.in));
            return str.readLine();
        }catch (IOException e)
        {
            e.printStackTrace();
            return "";
        }
    }
}


package FactoryPattern.SimpleFactory;

/**
 * Description:Main方法
 * @author tzw
 * CreateTime 10:48 2020/3/19
 **/
public class Main {

    public static void main(String[] args) {

        OrderPizza orderPizza=new OrderPizza(new SimpleFactory());
    }
}

工厂方法模式

此时中国卖的很好，有联盟店加入辽，去美国啦。利用简单工厂方法就还需要新的pizza生产地来生产不同口味的pizza，就有n种类型Pizza*n个不同工厂的类需要写，耦合性太高。

定义一个用于创建对象的接口，让子类决定实例化哪一个类。

package FactoryPattern.FactoryMethod;

import FactoryPattern.SimpleFactory.A_Pizza;
import FactoryPattern.SimpleFactory.B_Pizza;
import FactoryPattern.SimpleFactory.Pizza;
import FactoryPattern.SimpleFactory.SimpleFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * Description:抽象类定义
 * @author tzw
 * CreateTime 10:54 2020/3/19
 **/
public abstract class OrderPizza {

    public OrderPizza()
    {
        Pizza pizza=null;
        String orderType;
        do{
            orderType=getType();
            pizza=createPizza(orderType);
            if(pizza!=null)
            {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }
        }while (true);
    }

    abstract Pizza createPizza(String orderType);


    private String getType() {
        try {
            System.out.println("input Pizza type:");
            BufferedReader str=new BufferedReader(new InputStreamReader(System.in));
            return str.readLine();
        }catch (IOException e)
        {
            e.printStackTrace();
            return "";
        }
    }
}



package FactoryPattern.FactoryMethod;

import FactoryPattern.SimpleFactory.A_Pizza;
import FactoryPattern.SimpleFactory.B_Pizza;
import FactoryPattern.SimpleFactory.Pizza;

/**
 * Description:美国加盟店制作pizza
 * @author tzw
 * CreateTime 14:58 2020/3/19
 **/
public class UNOrderPizza extends OrderPizza {

    Pizza createPizza(String orderType) {
        Pizza pizza=null;

        if(orderType.equals("A"))
            pizza= new UNA_Pizza();
        else if(orderType.equals("B"))
            pizza=new UNB_Pizza();

        return pizza;

    }
}

public class UNA_Pizza extends Pizza {

    public void prepare() {
        System.out.println("UNA_Pizza prepare");
        super.setName("UNA_Pizza");
    }
}

public class UNB_Pizza extends Pizza {

    public void prepare() {
        System.out.println("UNB_Pizza prepare");
        super.setName("UNB_Pizza");
    }
}



package FactoryPattern.FactoryMethod;

import FactoryPattern.SimpleFactory.Pizza;

/**
 * Description:中国点制作pizza
 * @author tzw
 * CreateTime 14:58 2020/3/19
 **/
public class ChineseOrderPizza extends OrderPizza {

    Pizza createPizza(String orderType) {
        Pizza pizza=null;

        if(orderType.equals("A"))
            pizza=new ChineseA_Pizza();
        else if(orderType.equals("B"))
            pizza=new ChineseB_Pizza();

        return pizza;
    }
}


public class ChineseA_Pizza extends Pizza {

    public void prepare() {
        System.out.println("ChineseA_Pizza prepare");
        super.setName("ChineseA_Pizza");
    }
}

public class ChineseB_Pizza extends Pizza {

    public void prepare() {
        System.out.println("ChineseB_Pizza prepare");
        super.setName("ChineseB_Pizza");
    }
}



public class Main {

    public static void main(String[] args) {

        OrderPizza orderPizza;
        orderPizza=new ChineseOrderPizza();

    }
}

 

抽象工厂模式

用于：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。每个生成的工厂都能按照工厂模式提供对象。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。

 

超级工厂创建在中国或者美国的工厂，工厂可不仅生产pizza，还有其他。

这里只列举制作pizza

public interface AbstractFactory  {
    public Pizza CreatePizza(String ordertype);
}



package FactoryPattern.AbstractFactory;

import FactoryPattern.FactoryMethod.UNA_Pizza;
import FactoryPattern.FactoryMethod.UNB_Pizza;
import FactoryPattern.SimpleFactory.Pizza;

/**
 * Description:美国工厂
 * @author tzw
 * CreateTime 21:29 2020/3/19
 **/
public class UNFactory implements AbstractFactory {

    public Pizza CreatePizza(String ordertype) {
        Pizza pizza=null;

        if(ordertype.equals("A"))
            pizza= new UNA_Pizza();
        else if(ordertype.equals("B"))
            pizza=new UNB_Pizza();

        return pizza;
    }
}


package FactoryPattern.AbstractFactory;

import FactoryPattern.FactoryMethod.ChineseA_Pizza;
import FactoryPattern.FactoryMethod.ChineseB_Pizza;
import FactoryPattern.SimpleFactory.Pizza;

/**
 * Description:中国工厂
 * @author tzw
 * CreateTime 21:29 2020/3/19
 **/
public class ChineseFactory implements AbstractFactory {

    public Pizza CreatePizza(String ordertype) {
        Pizza pizza=null;

        if(ordertype.equals("A"))
            pizza=new ChineseA_Pizza();
        else if(ordertype.equals("B"))
            pizza=new ChineseB_Pizza();

        return pizza;
    }
}



package FactoryPattern.AbstractFactory;

import FactoryPattern.SimpleFactory.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * Description:加入超级工厂依赖，决定使用哪个工厂由子类决定
 * @author tzw
 * CreateTime 21:32 2020/3/19
 **/
public class OrderPizza {
    AbstractFactory abstractFactory;

    public OrderPizza(AbstractFactory abstractFactory)
    {
        setAbstractFactory(abstractFactory);

    }
    public void setAbstractFactory(AbstractFactory abstractFactory)
    {
        Pizza pizza=null;
        String orderType;

        this.abstractFactory=abstractFactory;

        do{
            orderType=getType();
            pizza=abstractFactory.CreatePizza(orderType);
            if(pizza!=null)
            {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }
        }while (true);

    }

    private String getType() {
        try {
            System.out.println("input Pizza type:");
            BufferedReader str=new BufferedReader(new InputStreamReader(System.in));
            return str.readLine();
        }catch (IOException e)
        {
            e.printStackTrace();
            return "";
        }
    }
}


public class Main {
    public static void main(String[] args) {
        OrderPizza orderPizza=new OrderPizza(new ChineseFactory());
    }
}