java：工厂模式

1简单工厂： 用于没有产品族而且产品个数较少时
  专门定义一个类（第三方）用来创建其他类实例，被创建的实例通常具有共同的父类。
例子：在这里我们相当于是创建生产电脑的工厂，客户需要购买什么样的电脑，只要输入类型编号就可以获取该电脑。该类的实例化交给工厂易于解耦。
类图如下所示：

import java.util.Scanner;
interface Computer{
	void printComputer();
}
class MacbookPro implements Computer{
	public void printComputer(){
		System.out.println("This is a macbookpro");
	}
}
class SurfaceBook implements Computer{
	public void printComputer(){
		System.out.println("This is a Surfacebook");
	}
}
//第三方工厂类
class ComputerFactory{
	public static Computer getInstance(String type){
		if(type.equals("mac")){
			return new MacbookPro();
		}else if(type.equals("surface")){
			return new SurfaceBook();
		}
		return null;
	}
}
public class Test19{
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入你选择的电脑的型号");
		String type = scanner.nextLine();
		Computer computer = ComputerFactory.getInstance(type);
		computer.printComputer();
	}
}

以上就是简单工厂模式
 组成：
  a. 一个抽象产品类
  b. N个具体产品类
  c. 一个工厂类
 优点
  简单易于实现
  把类的实例化交给工厂，易于解耦
 缺点
  添加具体产品需要返回工厂违反OCP开放封闭原则。
2.工厂方法模式
工厂方法模式：定义一个用来创建对象的接口，让子类决定实例化哪一个工厂。
  工厂方法模式是针对每一个产品提供一个工厂类，在客户端中判断使用哪个工厂类去创建对象。
  还是上面的例子，我们将之前的ComputerFactor抽象成一个接口，那么创建相应具体的工厂类去实现接口的方法。
具体类图实现如下：

例子：

interface Computer{
	void printComputer();
}
class MacbookPro implements Computer{
	public void printComputer(){
		System.out.println("This is a macbookpro");
	}
}
class SurfaceBook implements Computer{
	public void printComputer(){
		System.out.println("This is a Surfacebook");
	}
}
class AlienWare implements Computer{
	public void printComputer(){
		System.out.println("This is a AlienWare");
	}
}
interface ComputerFactory{
	Computer creatComputer();
}
//微软产品工厂
class MsFactory implements ComputerFactory{
	public Computer creatComputer(){
		return new SurfaceBook();
	}
}
//苹果产品工厂
class AppleFactory implements ComputerFactory{
	public Computer creatComputer(){
		return new MacbookPro();
	}
}  
public class Test19{
	public static void main(String[] args){
		ComputerFactory factory = new AppleFactory();
		Computer computer = factory.creatComputer();
		computer.printComputer();		
	}
}

  工厂方法模式是针对每一个产品提供一个工厂类，在客户端中判断使用哪个工厂类去创建对象。
组成：
a. 一个抽象产品类
b. 多个具体产品类
c. 一个抽象工厂
d. 多个具体工厂（每个产品族对应一个具体工厂）
优点：
 降低了代码的耦合度，对象的生成交给子类去完成
 实现了开放封闭原则，每次添加子产品不需要修改原有代码
缺点：
 增加了代码量，每个具体产品都需要一个具体工厂
 当增加抽象产品，也就是添加一个其他产品族，需要修改工厂，违反OCP
3. 抽象工厂模式
这时候如果说要生产新的一类操作系统Mac Os 和 Windows 8，这时候就引申出了抽象工厂模式。
抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
  工厂方法模式和抽象工厂模式基本类似，可以这么理解：当工厂只生产一个产品时，即为工厂方法模式，而工厂如果生产两个或以上的商品即变为抽象工厂模式。
  我们在抽象工厂接口中新增创建系统的方法，并由实例工厂类实现。
类图如下：

interface Computer{
    void printComputer();
}
class MacbookComputer implements Computer{
    public void printComputer(){
        System.out.println("This is a Macbookpro");
    }
}
class SurfaceBookComputer implements Computer {
    public void printComputer() {
        System.out.println("This is a Surfacebook");
    }
}
interface OperatingSystem{
    void printSystem();
}
class MacOsSystem implements OperatingSystem{
    public void printSystem(){
        System.out.println("This is a mac os");
    }
}
class Windows8System implements OperatingSystem{
    public void printSystem() {
        System.out.println("This is a Window 8");
    }
}
interface  ProductionFactory{
    Computer createComputer();
    OperatingSystem createSystem();
}
class AppleFactory implements ProductionFactory{
    public Computer createComputer(){
        return new MacbookComputer();
    }
    public OperatingSystem createSystem(){
        return new MacOsSystem();
    }
}
class MsFactory implements ProductionFactory{
    public Computer createComputer(){
        return new SurfaceBookComputer();
    }
    public OperatingSystem createSystem(){
        return new Windows8System();
    }
}
public class Client{
    public void buyComputer(Computer computer){
        computer.printComputer();
    }
    public void use(OperatingSystem s){
        s.printSystem();
    }

    public static void main(String[] args) {
        Client client = new Client();
        ProductionFactory factory = new AppleFactory();
        Computer computer = factory.createComputer();
        OperatingSystem system = factory.createSystem();
        client.buyComputer(computer);
        client.use(system);
    }
}

组成：
 1.多个抽象产品类
 2.具体产品类
 3.抽象工厂类 - 声明返回抽象产品的方法
 4.具体工厂类 - 生成具体产品
优点：
 代码解耦
 实现多个产品族
 很好的满足OCP开放封闭原则
 对于复杂对象的生产灵活易扩展
缺点：
 扩展产品族相当麻烦，而且扩展产品族会违反OCP，因为要修改所有的工厂
 由于抽闲工厂模式是工厂方法模式的扩展，总体来说很笨重