(1、2/23)工厂方法模式And抽象工厂模式

一、工厂方法模式

简单工厂模式的缺陷就是类的创建太过于依赖工厂，一旦需要进行程序扩展，就必须修改工厂类的代码

这违背了背包原则。

而工厂方法模式针对这一问题进行了改进。

public interface Sender {
	public void send();
}


public interface producer {
	public Sender produce();
}

public class MailFactory implements producer{

	public Sender produce() {
		return new Mail();
	}
}

public class Mail implements Sender{

	public void send() {
		System.out.println("mail is sending ");
	}
}

//测试类
public class FactoryPatten {
	public static void main(String[] args) {
		MailFactory mailFactory = new MailFactory();
		Sender sender =  mailFactory.produce();
		sender.send();
	}
}

工厂方法模式的好处就是，一旦进行功能扩展，只需要增加一个类实现Sender接口，再创建一个工厂类实现producer接口，即可
对于原有的工厂进行保留，这样就保证了再不违背闭包原则下，进而提高了拓展性。

二、抽象工厂模式

工厂方法模式和抽象工厂模式不好分清楚

工厂方法模式:

一个抽象产品类，可以派生出很多具体产品类
一个抽象工厂类，可以派生出很多具体工厂类
每一个具体工厂类只能创建一个具体产品的实例

抽象工厂模式:

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例，也就是创建的是一个产品线下的多个产品。

package day03;

interface ProduceComputer{}//抽象电脑产品
interface ProduceHouse{}//抽象家用,以下只用抽象电脑产品举例
interface Factory{}//抽象工厂
//A工厂的鼠标
class MouseA implements ProduceComputer{
	MouseA(){
		System.out.println("MouseA has created");
	}
	public void doSomething(){
		System.out.println("MouseA is running");
	}
}
//B工厂的鼠标
class MouseB implements ProduceComputer{
	MouseB(){
		System.out.println("MouseB has created");
	}
	public void doSomething(){
		System.out.println("MouseB is running");
	}
}
//A工厂的键盘
class keyBoardA implements ProduceComputer{
	keyBoardA(){
		System.out.println("keyBoardA has created");
	}
	public void doSomething(){
		System.out.println("keyBoardA is running");
	}
}
//B工厂的键盘
class keyBoardB implements ProduceComputer{
	keyBoardB(){
		System.out.println("keyBoardB has created");
	}
	public void doSomething(){
		System.out.println("keyBoardB is running");
	}
}
//A工厂，生产A工厂的产品
class FactoryA implements Factory{
	public MouseA produceMouseA(){
		return new MouseA();
	}
	public keyBoardA produceKeyBoardA(){
		return new keyBoardA();
	}
}

//B工厂，生产B工厂的产品
class FactoryB implements Factory{
	public MouseB produceMouseB(){
		return new MouseB();
	}
	public keyBoardB produceKeyBoardB(){
		return new keyBoardB();
	}
}
//测试类
public class AbstractFactory {
	
	public static void main(String[] args) {
		MouseA ma = new FactoryA().produceMouseA();
		ma.doSomething();
		keyBoardA ka = new FactoryA().produceKeyBoardA();
		ka.doSomething();
		
		MouseB mb = new FactoryB().produceMouseB();
		mb.doSomething();
		keyBoardB kb = new FactoryB().produceKeyBoardB();
		kb.doSomething();
	}
}

以下摘自它处：
区别：

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
工厂方法创建 "一种" 产品，他的着重点在于" 怎么创建"，也就是说如果你开发，你的大量代码很可能
围绕着这种产品的构造，初始化这些细节上面。也因为如此，类似的产品之间有很多可以复用的特征，
所以会和模版方法相随。

抽象工厂需要创建一些列产品，着重点在于" 创建哪些"产品上，也就是说，如果你开发，你的主要任务
是划分不同差异的产品线，并且尽量保持每条产品线接口一致，从而可以从同一个抽象工厂继承。
对于 java 来说，你能见到的大部分抽象工厂模式都是这样的：
---它的里面是一堆工厂方法，每个工厂方法返回某种类型的对象。
比如说工厂可以生产鼠标和键盘。那么抽象工厂的实现类（它的某个具体子类）的对象都可以生产鼠标
和键盘，但可能工厂 A 生产的是罗技的键盘和鼠标，工厂 B 是微软的。

这样 A 和 B 就是工厂，对应于抽象工厂；
每个工厂生产的鼠标和键盘就是产品，对应于工厂方法；

用了工厂方法模式，你替换生成键盘的工厂方法，就可以把键盘从罗技换到微软。但是用了抽象工厂模
式，你只要换家工厂，就可以同时替换鼠标和键盘一套。如果你要的产品有几十个，当然用抽象工厂模
式一次替换全部最方便（这个工厂会替你用相应的工厂方法）
所以说抽象工厂就像工厂，而工厂方法则像是工厂的一种产品生产线