设计模式——工厂模式

工厂模式是Java基础中一个重要的设计模式；工厂模式又可分为简单工厂模式、工厂方法模式和抽象工厂模式。

1、简单工厂模式

简单工厂模式专门定义一个类用来创建其它类的实例，被创建的实例通常都具有共同的父类。包括一个抽象产品类、具体产品类和一个工厂。优点简单易于实现，易于解耦；但添加具体产品需要修改工厂，违反OCP（开闭原则）。
例如：刘同学准备去买笔记本，他到商城发现有两款电脑他特别喜欢, 一款是 Macbook Pro, 另一款是 Surface Pro。

import java.util.Scanner;
 
interface Computer {    
	void printComputer(); 
}
 
class MacbookProComputer 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");    
    } 
}
 
class ComputerFactory {    
	public static Computer getInstance(String type) {        			 
			Computer computer = null;        
			if (type.equals("macbook")) {            							
				computer = new MacbookProComputer();        
			}else if (type.equals("surface")) {            
				computer = new SurfaceBookComputer();        
			}        
			return computer;    
	} 
}
 
public class Client {    
	public void buyComputer(Computer computer) {        
		computer.printComputer();    
	}   
	public static void main(String[] args) {        
		Client client = new Client();        
	 	Scanner scanner = new Scanner(System.in);        
	 	System.out.println("请输入您想要的电脑型号...");        
	 	String type = scanner.nextLine();       
		Computer computer =ComputerFactory.getInstance(type);        
	 	client.buyComputer(computer);
	 }
}

2、工厂方法模式

工厂方法模式定义一个用来创建对象的接口，让子类决定实例化哪一个类，让子类决定实例化延迟到子类。包括了一个抽象产品类，多个具体产品类，一个抽象工厂，多个具体工厂该。模式降低了代码的耦合度，每次添加子产品时，不需要修改原有代码，实现了开闭原则；其缺点是增加了代码行，每一个具体的产品都要有一个具体的工厂；而且当增加其他产品时，也违背OCP；
同样是上面的例子，也可以采用工厂方法模式：

interface Computer {    
	void printComputer();
 }
class MacbookProComputer 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 ComputerFactory {    
	Computer createComputer(); 
}
 
class MsFactory implements ComputerFactory {
    public Computer createComputer() {        
    	return new SurfaceBookComputer();    
    } 
}
 
class AppleFactory implements ComputerFactory {
    public Computer createComputer() {        
	    return new MacbookProComputer();    
    } 
}
 
public class Client {    
	public void buyComputer(Computer computer) {        
		computer.printComputer();    
	}    
	public static void main(String[] args) {        
		Client client = new Client();        
		ComputerFactory factory = new AppleFactory();        
		client.buyComputer(factory.createComputer());    
} 
}

3、抽象工厂模式

该模式与工厂方法模式基本类似，但包含多个抽象产品类。该模式实现了多个产品族，很好的满足了OCP原则，而且可以定义实现不知一个接口。缺点是扩展产品族相当麻烦。
例如：要生产新的一类产品操作系统 Mac Os 和 Windows 8的电脑时；

package test;


interface Computer {
	void printComputer();
}

class MacbookProComputer implements Computer{
	public void printComputer() {
		System.out.println("this is a Macbook");
	}
}

class SuefaceBookComputer implements Computer{
	public void printComputer() {
		System.out.println("this is Surfacebook");
	}
}

interface OperatingSystem{
	void printSystem();
}

class MacOsSystem implements OperatingSystem{
	public void printSystem() {
		System.out.println("This is a mac os");
	}
}

class Window8System 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 MacbookProComputer();
	}
	public OperatingSystem createSystem() {
		return new MacOsSystem();
	}
}

class MsFactory implements ProductionFactory{
	public Computer createComputer() {
		return new SuefaceBookComputer();
	}
	public OperatingSystem createSystem() {
		return new Window8System();
	} 
}
public class InterfaceTest {
	public void buyComputer(Computer computer) {
		computer.printComputer();
	}
	public void useSystem(OperatingSystem system) {
		system.printSystem();
	}
    public static void main(String[] args) {
    	InterfaceTest it = new InterfaceTest();
    	ProductionFactory factory = new AppleFactory();
    	Computer computer =  factory.createComputer();
    	OperatingSystem system = factory.createSystem();
    	it.buyComputer(computer);
    	it.useSystem(system);
    }
}

总结：
简单工厂模式最大的优点就是工厂内有具体的逻辑去判断生成什么产品，将类的实例化交给了工厂，这样当我们需要什么产品只需要修改工厂的调用而不需要去修改客户端，对于客户端来说降低了与具体产品的依赖
工厂方法模式是简单工厂的扩展，工厂方法模式把原先简单工厂中的实现那个类的逻辑判断交给了客户端，如果像添加功能只需要修改客户和添加具体的功能，不用去修改之前的类。
抽象工厂模式进一步扩展了工厂方法模式，它把原先的工厂方法模式中只能有一个抽象产品不能添加产品族的 缺点克服了，抽象工厂模式不仅仅遵循了OCP原则，而且可以添加更多产品(抽象产品),具体工厂也不仅仅可以 生成单一产品，而是生成一组产品，抽象工厂也是声明一组产品，对应扩展更加灵活，但是要是扩展族系就会很笨重。