7.2.Java_（重点）工厂设计模式：简单工厂模式、工厂方法模式、抽象工厂模式的定义/组成/优缺点

一、简单工厂：用于没有产品族且产品个数较少–Spring-BeanFactory

1.定义：

专门定义一个类（或者说第三方）用来创建其它类的实例，并且被创建的实例通常具有共同的父类。 （解耦：将客户端创建对象的操作解耦到外部第三方类中）

2.组成：

• 一个抽象产品类
• N个具体产品类
• 一个工厂类

import java.util.Scanner;
//1个抽象产品类
interface Computer{
	void printComputer();
}

//3个具体产品类
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.");
	}
}

//1个第三方工厂类
class ComputerFactory{
	public static Computer getInstance(String type){
		if(type.equals("mac")){
			return new MacbookPro();
		}else if(type.equals("surface")){
			return new SurfaceBook();
		}else if(type.equals("alienware")){
			return new Alienware();
		}
		return null;
	}
}

public class Test{
	//客户端
	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();
	}
}

运行结果：

3.优点：

• 简单易于实现
• 把类的实例化交给工厂，易于解耦

4.缺点：

添加具体产品需要修改工厂，违反OCP开放封闭原则。

二、工厂方法模式：优点在于横向扩展—用于产品族

1.定义：

定义一个用来创建对象的接口，让子类决定将哪一个工厂实例化，将类的实例化延迟到子类去实现。

2.组成：

• 一个抽象产品类
• N个具体产品类
• 一个抽象工厂
• N个具体工厂（每个产品族对应一个具体工厂）

//1个抽象产品类
interface Computer{
	void printComputer();
}

//2个具体产品类
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();
}

//2个具体工厂
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());
	}
}

运行结果：

This is a MacbookPro

3.优点：

• 降低了代码耦合度，对象的生成交给子类去完成
• 实现了开闭原则，每次添加子产品，不需要修改原有代码

4.缺点：

• 增加了代码量，每个具体产品都需要一个具体工厂
• 当增加抽象产品，也就是添加一个其它产品族，需要修改工厂，违背OCP

三、抽象工厂模式：多个产品线混合

1.定义：

提供一个创建一系列相关或相互依赖对象的接口（抽象工厂，多条产品线），而无需指定它们具体的类。

工厂方法模式和抽象工厂模式基本类似，可以这样理解：当工厂只生产一个产品的时候，是工厂方法模式；如果生产两个或以上的商品时，是抽象工厂模式。

2.组成：

• 多个抽象产品类
• 具体产品类
• 抽象工厂类-声明一组返回抽象产品的方法
• 具体工厂类-生成一组具体产品

在抽象工厂接口中新增创建系统的方法，并由实例工厂类去实现。

//第一个抽象产品类：电脑类
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 OperatingSystem{
    void printSystem();
}
//具体产品类
class MsOsSystem 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 windows8");
    }
}


//抽象工厂类
interface ProductionFactory{
    Computer createComputer();
    OperatingSystem createSystem();
}
//具体工厂类
class AppleFactory implements ProductionFactory{
    public Computer createComputer(){
        return new MacbookProComputer();
    }
    public OperatingSystem createSystem(){
        return new MsOsSystem();
    }
}
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);
    }
}

运行结果：

3.优点：

• 代码解耦
• 实现多个产品族，而工厂方法模式的单个产品，可以满足更多的生产需求
• 满足OCP开闭原则
• 可以定义不止一个接口，一个工厂类可以生成不止一个产品类。对于复杂对象的生产相当灵活，易扩展。

4.缺点：

• 扩展产品族非常麻烦，而且会违反OCP，因为要修改所有的工厂。
• 抽象工厂模式是工厂方法模式的扩展，代码冗杂很笨重。

JDK中用到工厂设计模式的典型操作：
1、Collection中的iterator方法（集合中的迭代器）
2、java.util包中的sql相关操作