java实现工厂模式与抽象工厂模式

java—实现工厂模式与抽象工厂模式

1.工厂模式
问题：现有电脑产品windows和apple，请试用工厂模式描述该场景。

思路：

1. 根据描述，我们可以先创建两个产品类：Windows类和Apple类，然后定义一个产品接口，让这两个类实现接口方法表示类已经创建。

public interface Product {
	public void run();
}

public class Windows implements Product {
	@Override
	public void run() {
		System.out.println("product windows run!");
	}
}

public class Apple implements Product{
	@Override
	public void run() {
		System.out.println("product apple run!");
	}
}

2. 创建Test类，测试一下这两个方法

public class Test {
	public static void main(String[] args) {
		Windows windows = new Windows();
		windows.run();
		Apple apple = new Apple();
		apple.run();
	}
}

3. 工厂模式就是一个工厂生产一种产品，因此要定义一个WindowsFactory工厂类专门生产Windows类，定义一个AppleFactory工厂类专门生产Apple类，在此创建这两个工厂类之前，还需要定义一个抽象方法createProduct()让两个工厂实现。

public interface MyFactory {
	public Product createProduct();
}

public class WindowsFactory implements MyFactory{
	@Override
	public Product createProduct() {
		// TODO Auto-generated method stub
		return new Windows();
	}
}

public class AppleFactory implements MyFactory{
	@Override
	public Product createProduct() {
		// TODO Auto-generated method stub
		return new Apple();
	}
}

4. 回到Test类编写代码

public class Test {

	public static void main(String[] args) {
//		Windows windows = new Windows();
//		windows.run();
//		Apple apple = new Apple();
//		apple.run();
		WindowsFactory winFactory = new WindowsFactory();//创建Windows工厂
		Product windows = winFactory.createProduct();//工厂生产产品Windows
		windows.run();
		
		AppleFactory appleFactory = new AppleFactory();
		Product apple = appleFactory.createProduct();
		apple.run();
	}
}

2.抽象工厂模式
问题：现有电脑产品配件厂商基于windows和apple生产不同类型的CPU和RAM，请试用抽象工厂模式描述该场景。

问题分析：
Windows产品包含WindowsCPU和WindowsRAM，
Apple产品包含AppleCPU和AppleRAM，
或者说是CPU包含Windows型和Apple型，RAM包含Windows型和Apple型。

如果是工厂模式，则会创建四个工厂类，分别生产四个产品：WindowsCPU，AppleCPU，WindowsRAM，AppleRAM。

如果是抽象工厂模式，则只需要创建两个工厂类,将这四个产品两两组合（即一个工厂生产多种产品）：
工厂1：WindowsCPU，WindowsRAM。工厂2：AppleCPU，AppleRAM
工厂1：WindowsCPU，AppleCPU。工厂2：WindowsRAM，AppleRAM
工厂1：WindowsCPU，AppleRAM。工厂2：AppleCPU，WindowsRAM

所以抽象工厂模式其实可以对应数学上的组合方式
x包含x1,x2,x3
y包含y1,y2,y3
任意抽出2个，C（6,2）=15种组合，你可以根据这15种组合选择判断创几个工厂比较合适。

思路：

1. 我选择创建两个接口CPU，RAM，分别创建WindowsCPU，WindowsRAM，AppleCPU，AppleRAM四个类来分别实现对应接口。

public interface CPU {
	public void CPURun();
}

public interface RAM {
	public void RAMRun();
}

public class WindowsCPU implements CPU{
	@Override
	public void CPURun() {
		System.out.println("windows cpu run!");
	}	
}

public class WindowsRAM implements RAM{
	public void RAMRun() {
		System.out.println("windows RAM run!");
	}
}

public class AppleCPU implements CPU{
	@Override
	public void CPURun() {
		System.out.println("apple CPU run!");
	}
}

public class AppleRAM implements RAM{
	@Override
	public void RAMRun() {
		System.out.println("apple RAM run!");
	}
}

2.创建Test类来运行一下

public class Test {
	public static void main(String[] args) {
		WindowsCPU  windowsCPU = new WindowsCPU();
		windowsCPU.CPURun();
		
		WindowsRAM windowsRAM = new WindowsRAM();
  	    windowsRAM.RAMRun();
  	    
		AppleCPU appleCPU = new AppleCPU();
		appleCPU.CPURun();
		
		AppleRAM appleRAM = new AppleRAM();
		appleRAM.RAMRun();
	}
}

3.接下来就是创建工厂类了，抽象工厂顾名思义就是抽象工厂类，所以先创建一个抽象接口再来创建两个工厂实现接口。

public interface interfaceFactory {//抽象工厂
	public CPU createCPU();
	public RAM createRAM();
}

public class WindowsFactory implements interfaceFactory{
	@Override
	public CPU createCPU() {
		return new WindowsCPU();
	}
	@Override
	public RAM createRAM() {
		return new WindowsRAM();
	}
}

public class AppleFactory implements interfaceFactory{
	@Override
	public CPU createCPU() {
		return new AppleCPU();
	}
	@Override
	public RAM createRAM() {
		return new AppleRAM();
	}
}

4.到Test类测试一下

public class Test {
	public static void main(String[] args) {
//		WindowsCPU  windowsCPU = new WindowsCPU();
//		windowsCPU.CPURun();

//		WindowsRAM windowsRAM = new WindowsRAM();
//		windowsRAM.RAMRun();

//		AppleCPU appleCPU = new AppleCPU();
//		appleCPU.CPURun();

//		AppleRAM appleRAM = new AppleRAM();
//		appleRAM.RAMRun();

		WindowsFactory  windowsFactory= new WindowsFactory();
		CPU windowsCPU = windowsFactory.createCPU();
		RAM windowsRAM = windowsFactory.createRAM();
		windowsCPU.CPURun();
		windowsRAM.RAMRun();
		
		AppleFactory appleFactory = new AppleFactory();
		CPU appleCPU = new AppleFactory().createCPU();
		RAM appleRAM = new AppleFactory().createRAM();
		appleCPU.CPURun();
		appleRAM.RAMRun();
	}
}

这只是其中一种方式，还可以创建Windows，Apple抽象类，创建CPU工厂和RAM工厂，CPU工厂生产Windows型和Apple型，RAM工厂同理。方式不唯一。

总结：工厂模式乃是一一对应的关系，一个工厂生产一种产品；抽象工厂模式乃是一个工厂生产多种产品。

PS：会写一篇简单工厂模式，工厂模式，抽象工厂模式的对比总结。