设计模式学习笔记（三）--工厂模式

Factory (工厂)模式

工厂模式的定义：
假如你有一个类A，要实例化这个类，最简单的方法就是A a=new A()。如果要做一 些初始化的工作，通常会把这些操作写在A的构造方法里例如：A a =new A(parmeter);
但是，也许有很多的初始化内容，如果把所有内容都放在构造函数里面，就很不合适。在这种情境下就可以使用工厂模式，协助完成一系列初始化工作。

工厂模式通常有3种形态：简单工厂模式、工厂方法模式、抽象工厂模式。
下面就以农产品管理系统的集中水果和蔬菜（苹果、橘子、葡萄、番茄、冬瓜、胡萝卜）为例简要介绍这三种形态的工厂

一、Simple Factory(简单工厂)模式

SimpleFactory模式的结构如图

SimpleFactory模式的目的是专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有相同的父类

代码实现

//定义水果（Fruit）接口
public interface Fruit {
        public void grow();  //水果是被栽培的
        public  void expressedJuice();//水果是可以榨汁的
}
//定义苹果类实现水果接口
public class Apple implements Fruit {
    @Override
    public void grow() {
        System.out.println("栽培苹果");
    }
    @Override
    public void expressedJuice() {
        System.out.println("榨苹果汁");
    }
}
//定义葡萄类实现水果接口
public class Grape implements Fruit{
    @Override
    public void grow() {
        System.out.println("栽培葡萄");
    }
    @Override
    public void expressedJuice() {
        System.out.println("榨葡萄汁");
    }
}

//定义橙子类实现水果接口
public class Orange implements Fruit{
    @Override
    public void grow() {
        System.out.println("栽培橘子");     
    }
    @Override
    public void expressedJuice() {
        System.out.println("榨橙汁");      
    }
}
//定义水果工厂（FruitFactory）类
public class FruitFactory {
        public Fruit trafficFruit(int which) {
            if(which==1) {//如果是1，则返回苹果实例
                return new Apple();
            }else if(which==2){//如果是2，则返回葡萄实例
                return new Grape();
            }else if (which==3) {//如果是3，则返回橙子实例
                return new Orange();
            }else {
                return null;
            }       
        }
}
//编写客户（Client）类
public class Client {
    public static void main(String[] args) {
                FruitFactory fruit = new FruitFactory();//实例化水果工厂，可以开始运输水果了
                fruit.trafficFruit(1).expressedJuice();//调用苹果的expressedJuice()方法，用于榨苹果汁
                fruit.trafficFruit(2).expressedJuice();//调用葡萄的expressedJuice()方法，用于榨葡萄汁
                fruit.trafficFruit(3).expressedJuice();//调用橙子的expressedJuice()方法，用于榨橙汁
    }
}

输出结果：

从上面代码可以看出，当要运送水果时，只需向水果工厂（FruitFactory）请求就可以了。水果工厂在街道请求后，会自行判断创建和提供哪种水果。

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

对于简单工厂模式，如果要引增加一种或者几种水果就比较麻烦。这是除了要定义及个新增的水果类外，还必须修改水果工厂和客户端。从而可以看出比较麻烦，Simple Factory 模式开放性比较差。
要解决这种开放性比较差的问题，需要用到下面介绍的Factory Method(工厂方法模式)

Factory Method模式的结构如图

代码实现

//将水果工厂定义为接口而不是类
public interface FruitFactory {
  public Fruit trafficFruit();
}

//定义运送苹果类(TrafficApple)实现水果工厂(FruitFactory)接口
public class TrafficApple implements FruitFactory{
    public Fruit trafficFruit() {
        return new Apple();
    }
}

//定义运送葡萄类(TrafficApple)实现水果工厂(FruitFactory)接口
public class TrafficGrape implements FruitFactory{
    public Fruit trafficFruit() {
        return new Grape();
    }
}

//定义运送橙子类(TrafficApple)实现水果工厂(FruitFactory)接口
public class TrafficOrange implements   FruitFactory{   
    public Fruit trafficFruit() {
        return new Orange();
    }
}

//客户类
public class Client {

    public static void main(String[] args) {
        TrafficApple traffic = new TrafficApple();
        //开始运送苹果
        traffic.trafficFruit().expressedJuice();
        //调用橙子的expressedJuice()方法，用于榨苹果汁
    }
}

测试结果：

从上面的代码可以看出，工厂模式的核心在于一个抽象工厂类，它允许许多具体类从抽象工厂类中继承其创建行为。

三、Abstract Factory 模式

Factory Method模式针对只是一种类别（Fruit）,如果还要运送蔬菜就不行了。在这种情况下，必须用到下面将要介绍的Abstract Factory(抽象工厂模式)。

代码实现

//定义一个蔬菜(Vegetable)接口
public interface Vegetable {
    public void grow();//蔬菜是种植的
    public void cook();//蔬菜是用来烹调的
}
//定义冬瓜(WhiteGourd)类实现蔬菜接口
public class WhiteGourd implements Vegetable {
    @Override
    public void grow() {
        System.out.println("种冬瓜");
    }
    @Override
    public void cook() {
        System.out.println("煮冬瓜");
    }
}
//定义胡萝卜(Carrot)类实现蔬菜接口

public class Carrot implements  Vegetable{

    @Override
    public void grow() {
        System.out.println("种胡萝卜");
    }
    @Override
    public void cook() {
        System.out.println("煮胡萝卜");     
    }

}
//定义番茄(Tomato)类实现蔬菜接口
public class Tomato implements Vegetable {
    @Override
    public void grow() {
        System.out.println("种番茄");      
    }
    @Override
    public void cook() {
        System.out.println("煮番茄");      
    }
}
//定义运送工厂接口
public class TrafficFactory implements   ITrafficFactory {

    @Override
    public Fruit trafficFruit(Fruit whichFruit) {
        return whichFruit;
    }
    @Override
    public Vegetable trafficVegetable(Vegetable whichVegetable) {
        return whichVegetable;
    }
}


//定义运送工厂(ITrafficFactory)类实现运送工厂接口(TrafficFactory)
public class TrafficFactory implements   ITrafficFactory {
    @Override
    public Fruit trafficFruit(Fruit whichFruit) {
        return whichFruit;
    }
    @Override
    public Vegetable trafficVegetable(Vegetable whichVegetable) {
        return whichVegetable;
    }
}
//编写客户类
public class Client {
    public static void main(String[] args) {
        Fruit orange = new Orange();//橙子实例
        Vegetable carrot= new Carrot();//胡萝卜实例
        TrafficFactory factory = new TrafficFactory();//运送工厂实例
        factory.trafficFruit(orange).expressedJuice();//运送橙子，榨橙子
        factory.trafficVegetable(carrot).cook();//运送胡萝卜，煮胡萝卜
    }
}

测试结果：

Abstract Factory 模式只需向客户端提供一个接口，使得客户端在不必指定运送农产品的具体类的情况下，创建多个类型中的产品对象。