Java设计模式之工厂模式

一、简单工厂模式
简单工厂模式属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。
简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

该模式中包含的角色及其职责：
1.工厂（Creator）
简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
2.抽象产品（Product）
简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
3.具体产品（Concrete Product）
是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

工厂（Creator）：

public class FoodFactory {
    public static Food getFood(String type){
         if(type.equals("Pizza")) {
                return new Pizza();

            } else if(type.equals("Hamburger")) {
                return new Hamburger();
            } else {
                System.out.println("哎呀！找不到相应的实例化类啦！");
                return null;
            }
    }
}

抽象产品（Product）：

public interface Food {
     public void get();
}

具体产品（Concrete Product）：

public class Pizza implements Food {

    @Override
    public void get() {
        System.out.println("吃披萨");
    }

}

public class Hamburger implements Food {

    @Override
    public void get() {
        System.out.println("吃汉堡");
    }

}

测试客户端：

public class Client {

    public static void main(String[] args) {
        Food f =FoodFactory.getFood("Pizza"); 
        f.get();
    }

}

二、工厂方法模式（FACTORY METHOD）
是一种常用的对象创建型设计模式,此模式的核心精神是封装类中不变的部分。它的核心结构有四个角色，分别是抽象工厂、具体工厂、抽象产品、具体产品。
工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。
工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。首先完全实现‘开－闭 原则’，实现了可扩展。工厂方法模式对简单工厂模式进行了抽象。有一个抽象的Factory类（可以是抽象类和接口），这个类将不再负责具体的产品生产，而是只制定一些规范，具体的生产工作由其子类去完成。在这个模式中，工厂类和产品类往往可以依次对应。即一个抽象工厂对应一个抽象产品，一个具体工厂对应一个具体产品，这个具体的工厂就负责生产对应的产品。工厂方法模式是最典型的模板方法模式(Template Method pattern)应用。
抽象工厂(Creator)角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
具体工厂(Concrete Creator)角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。
抽象产品(Product)角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。
具体产品(Concrete Product)角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。
工厂方法经常用在以下两种情况中:
第一种情况是对于某个产品，调用者清楚地知道应该使用哪个具体工厂服务，实例化该具体工厂，生产出具体的产品来。Java Collection中的iterator() 方法即属于这种情况。
第二种情况，只是需要一种产品，而不想知道也不需要知道究竟是哪个工厂为生产的，即最终选用哪个具体工厂的决定权在生产者一方，它们根据当前系统的情况来实例化一个具体的工厂返回给使用者，而这个决策过程这对于使用者来说是透明的。
抽象工厂：

public interface Factory {
    public Product create();
}

具体工厂：

public class Afactory implements Factory {

    @Override
    public Product create() {
        System.out.print("A工厂生产出");
        return new Aproduct();
    }


}

public class Bfactory implements Factory {
    @Override
    public Product create() {
        System.out.print("B工厂生产出");
        return new Bproduct();
    }
}

抽象产品：

public interface Product {
    public void method();
}

具体产品：

public class Aproduct implements Product {

    @Override
    public void method() {
        System.out.println("一等产品");
    }

}

public class Bproduct implements Product {
    @Override
    public void method() {
        System.out.println("二等产品");
    }
}

测试客户端：

public class Client {
    public static void main(String[] args) {
        Factory afactory = new Afactory();  
        Product aproduct = afactory.create();  
        aproduct.method();  
        Factory bfactory = new Bfactory();  
        Product bproduct = bfactory.create();  
        bproduct.method(); 
    }
}

控制台输出：

A工厂生产出一等产品
B工厂生产出二等产品

三、抽象工厂模式
是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。
每一个模式都是针对一定问题的解决方案。抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则需要面对多个产品等级结构。
在学习抽象工厂具体实例之前，应该明白两个重要的概念：产品族和产品等级。
所谓产品族，是指位于不同产品等级结构中，功能相关联的产品组成的家族。比如AMD的主板、芯片组、CPU组成一个家族，Intel的主板、芯片组、CPU组成一个家族。而这两个家族都来自于三个产品等级：主板、芯片组、CPU。一个等级结构是由相同的结构的产品组成，示意图如下：

如果采用工厂方法模式，就势必要使用三个独立的工厂等级结构来对付这三个产品等级结构。由于这三个产品等级结构的相似性，会导致三个平行的工厂等级结构。随着产品等级结构的数目的增加，工厂方法模式所给出的工厂等级结构的数目也会随之增加。如下图：

抽象工厂模式的好处：同一个工厂等级结构负责三个不同产品等级结构中的产品对象的创建。　可以看出，一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象。显然，这时候抽象工厂模式比简单工厂模式、工厂方法模式更有效率。对应于每一个产品族都有一个具体工厂。而每一个具体工厂负责创建属于同一个产品族，但是分属于不同等级结构的产品。

抽象工厂接口

public interface Factory {
    public Cpu createCpu();//CPU

    public Mainboard createMainboard();//主板
}

Intel工厂

public class IntelFactory implements Factory {

    public IntelFactory() {
        System.out.println("这里是Intel公司");
    }
    @Override
    public Cpu createCpu() {
        return new IntelCpu();
    }

    @Override
    public Mainboard createMainboard() {
        return new IntelBoard();
    }

}

Amd工厂

public class AmdFactory implements Factory {

    public AmdFactory() {
        System.out.println("这里是Amd公司");
    }

    @Override
    public Cpu createCpu() {
        return new AmdCpu();
    }

    @Override
    public Mainboard createMainboard() {
        return new AmdBoard();
    }
}

产品族中各个产品接口

public interface Cpu {
    public void cpuDescripe();
}
public interface Mainboard {
    public void boardDescripe();
}

Intel产品族

public class IntelCpu implements Cpu {

    @Override
    public void cpuDescripe() {
        System.out.println("Intel公司的CPU");
    }

}
public class IntelBoard implements Mainboard {
    @Override
    public void boardDescripe() {
        System.out.println("Intel公司的主板");
    }
}

Amd产品族

public class AmdCpu implements Cpu {

    @Override
    public void cpuDescripe() {
        System.out.println("Amd公司的CPU");
    }

}
public class AmdBoard implements Mainboard {

    @Override
    public void boardDescripe() {
        System.out.println("Amd公司的主板");
    }

}

测试客户端：

public class Client {
    public static void main(String[] args) {
        Factory a=new AmdFactory();
        a.createCpu().cpuDescripe();;
        a.createMainboard().boardDescripe();
        System.out.println("------------");
        Factory i=new IntelFactory();
        i.createCpu().cpuDescripe();
        i.createMainboard().boardDescripe();
    }
}

控制台输出：

这里是Amd公司
Amd公司的CPU
Amd公司的主板
------------
这里是Intel公司
Intel公司的CPU
Intel公司的主板