JAVA——工厂设计模式（简单工厂模式）（工厂方法模式）（抽象工厂模式）

工厂设计模式（简单工厂模式）（工厂方法模式）（抽象工厂模式）

工厂设计模式介绍：

实例分析：
我想买一部手机->手机型号有iphone，HUAWEI
分析图如下：

(一）使用接口的基础方法实现

代码如下：

interface Phone{
	
	void printInfo();
}

class Iphone implements Phone{
	public void printInfo(){
	  System.out.println("这是一部苹果手机。");
	}
}

class Huawei implements Phone{
	public void printInfo(){
		System.out.println("这是一部华为手机。");
	}
}

//客户端
public class Client{
	
	public void buyPhone(Phone phone){
		phone.printInfo();
	}
	
	public static void main(String[] args){
		Client client = new Client();
		client.buyPhone(new Iphone());
	}
}

运行结果如下：
观察以上代码可以发现，手机类型不仅仅只有iPhone和华为，还有vivo,oppo等各种各样的类型，所以当我们不想要iPhone 而想要vivo时，此时修改代码就要在客户端重新进行实例化，让客户端支持vivo手机。
此时我们可以想一个解决办法，就是在拥有各种类型手机的时候，选择我们想要的类型，并且每次重新进行选择时不会每次都在客户端实例化，将客户端代码封装起来。
要想将客户端代码封装起来，即只要将实例化部分单独提取出来。
我们可以为实例化对象单独定义一个类，这个类就用来实例化。可以把这个类想象成一个产生实例化对象的工厂。
这个就是简单工厂模式。
（二）简单工厂模式

代码如下：

//导入包
import java.util.Scanner;
//1.定义接口
interface Phone{
	void printInfo();
}

//2. 子类实现接口
class Iphone implements Phone{
	public void printInfo(){
	  System.out.println("这是一部苹果手机。");
	}
}

class Huawei implements Phone{
	public void printInfo(){
		System.out.println("这是一部华为手机。");
	}
}

//3. 定义实例化工厂
//若有新的需求，则可以在工厂中直接修改
class Factory{
	public static Phone getInstance(String type){
		Phone phone = null;
		if(type.equals("iphone")){
			phone = new Iphone();
		}else{
			phone = new Huawei();
		}
		return phone;
	}
}

//客户端
public class Client{
	
	public void buyPhone(Phone phone){
		phone.printInfo();
	}
	
	public static void main(String[] args){
		Client client = new Client();
		Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您想要的手机型号...");
		String type = scanner.nextLine();
		Phone phone = Factory.getInstance(type);
		client.buyPhone(phone);
		
	}
}

运行结果如下：
对简单工厂模式的总结：
（1）一个抽象产品类
（2）具体实现类
（3）一个实例化工厂
（4）客户端
缺点：不符合开闭原则（对修改关闭，对扩展开放）

所以在此代码的基础上还可以进行优化，避免其缺陷，使其尽量复合开闭原则。
定义一个用来创建对象的接口，让子类决定实例化哪一个类，将实例化延迟到子类。——即工厂方法模式。

（三）工厂方法模式

工厂方法模式是针对每个产品提供一个工厂类，在客户端中判断使用哪个工厂类去创建对象。
我们将之前的 Factory 抽象成一个接口，那么创建相应具体的工厂类（子类）去实现该接口的方法。
代码如下：

//1. 定义产品抽象类
interface Phone{
	void printInfo();
}
//2. 定义多个产品实现类
class Iphone implements Phone{
	public void printInfo(){
	  System.out.println("这是一部苹果手机。");
	}
}

class Huawei implements Phone{
	public void printInfo(){
		System.out.println("这是一部华为手机。");
	}
}

//3. 定义一个抽象工厂类
//该抽象类用来实例化，但是对于具体的实例化交由子类实现，符合开闭原则
interface Factory{
	Phone createPhone();
}

//4.定义多个产品工厂，每个产品类对应的实例化 
class IphoneFactory implements Factory{
	public Phone createPhone(){
		return new Iphone();
	}
}

class HuaweiFactory implements Factory{
	public Phone createPhone(){
		return new Huawei();
	}
}


//客户端
public class Client{
	
	public void buyPhone(Phone phone){
		phone.printInfo();
	}
	
	public static void main(String[] args){
		Client client = new Client();
		Factory factory = new HuaweiFactory();
		client.buyPhone(factory.createPhone());
		
	}
}

运行结果如下：

观察以上代码会发现，当添加某一类型的新产品时，符合开闭原则，不需要修改原有代码；
但是，当添加一个新的产品类时，依然不符合开闭原则。
工厂方法模式：
（1）一个抽象产品类
（2）多个具体产品类
（3）一个抽象工厂
（4）多个具体工厂（每个具体工厂对应一个具体产品类）

（四）抽象工厂模式

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
工厂方法模式和抽象工厂模式基本类似，可以这么理解：当工厂只生产一个产品的时候，即为工厂方法模式，而工
厂如果生产两个或以上的商品即变为抽象工厂模式。

例如本案例，现在需要添加一个操作系统类，操作系统有Android 和 ios。

具体代码如下：

interface Phone{
	
	void printInfo();
}

class Iphone implements Phone{
	public void printInfo(){
	  System.out.println("这是一部苹果手机。");
	}
}

class Huawei implements Phone{
	public void printInfo(){
		System.out.println("这是一部华为手机。");
	}
}

interface OperationSytem{
	void printSystem();
}

class Android implements OperationSytem{
	public void printSystem(){
		System.out.println("该操作系统是安卓系统。");
	}
}
class Ios implements OperationSytem{
	public void printSystem(){
		System.out.println("该操作系统是iOS操作系统。");
	}
}

interface Factory{
	Phone createPhone();
	OperationSytem createSystem();
}

class AppleFactory implements Factory{
	public Phone createPhone(){
		return new Iphone();
	}
	public OperationSytem createSystem(){
		return new Ios();
	}
}

class OtherFactory implements Factory{
	public Phone createPhone(){
		return new Huawei();
	}
	public OperationSytem createSystem(){
		return new Android();
	}
}


//客户端
public class Client{
	
	public void buyPhone(Phone phone){
		phone.printInfo();
	}
	public void useSystem(OperationSytem operation){
		operation.printSystem();
	}
	
	public static void main(String[] args){
		Client client = new Client();
		
		Factory factory = new AppleFactory();
		client.buyPhone(factory.createPhone());
		client.useSystem(factory.createSystem());
		
	}
}

运行结果如下：

抽象工厂模式：
（1）多个抽象产品类
（2）具体产品类
（3）抽象工厂类 - 声明(一组)返回抽象产品的方法
（4） 具体工厂类 - 生成(一组)具体产品