工厂模式

一、简单工厂模式

简单工厂模式就是为了避免直接new对象，不需要去关注怎么生成该对象，用户只需要传入对应的参数就可以

1、Iproduct:定义抽象产品类的公共方法
2、Product:定义具体的产品类，实现抽象类中的方法
3、Factory:工厂类根据传入参数来实例化对应的具体类

Demo

1、抽象产品类

public interface Computer {
	public void start() ;
}

2、具体产品类

class Lenovo implements Computer {

	@Override
	public void start() {
		System.out.println("联想电脑启动");
	}
	 
 }
 class HpComputer implements Computer {
	 
	 @Override
	 public void start() {
		 System.out.println("惠普电脑启动");
	 }
	 
 }

3、工厂类

public class Factory {
	public Computer getComputer(String name) {
		if(name=="lenovo") {
			return new Lenovo();
		}else if (name=="hp") {
			return new HpComputer();
		}else {
			throw new RuntimeException("输入正确的电脑类型");
		}
	}

}

4、test

public class Test {
	public static void main(String[] args) {
		Factory factory  = new Factory();
		Computer c = factory.getComputer("lenovo");
		c.start();
		Computer c1 = factory.getComputer("hp");
		c1.start();
		Computer c2 = factory.getComputer("other computer");
		
	}
}

联想电脑启动
惠普电脑启动
Exception in thread "main" java.lang.RuntimeException: 输入正确的电脑类型
	at simpleFactory.Factory.getComputer(Factory.java:10)
	at simpleFactory.Test.main(Test.java:10)

二、工厂方法模式

开闭原则：开闭原则中“开”，是指对于组件功能的扩展是开放的，是同意对其进行功能扩展的；开闭原则中“闭”，是指对于原有代码的改动是封闭的，即不应该改动原有的代码

1、工厂方法模式简介

如果按照简单工厂模式去创建商品类，每一次去新建商品都需要去修改工厂类中的代码，违反了开闭原则，因此选择将工厂定义为抽象工厂，而具体工厂来决定实际需要创建的商品类

优缺点：每次新增商品都需要添加商品类与具体工厂类（如果采用反射机制则不需要添加具体工厂类）

2、工厂方法模式结构

1、Iproduct：产品接口
2、ProductA:具体的产品类型
3、AbstractFactory:抽象工厂，定义创建继承自Iproduct的Prpduct类型的抽象方法
4、ConcreteFactory:通过子类确定具体想要创建的商品

2、Demo

1、Iproduct

public interface Computer {
	public void start() ;
}

2、ProductA

 class Lenovo implements Computer {

	@Override
	public void start() {
		System.out.println("联想电脑启动");
	}
	 
 }
 class HpComputer implements Computer {
	 
	 @Override
	 public void start() {
		 System.out.println("惠普电脑启动");
	 }
	 
 }

3、AbstractFactory:

public abstract class AbstractFactory {
	/**
	 * 泛型方法的基本介绍
	 * 
	 * @param cls 传入的泛型实参
	 * @return T 返回值为T类型 说明：
	 * 		   1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
	 *         2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
	 *         3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
	 *         4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
	 */
	public abstract <T extends Computer> T getComputer(Class<T> cls);

}

4、ConcreteFactory

public class ConcreteFactory extends AbstractFactory {

	@Override
	public <T extends Computer> T getComputer(Class<T> cls) {
		Computer computer = null;
		String classname = cls.getName();
		try {
			computer = (Computer)Class.forName(classname).newInstance();
		} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return (T) computer;
	}
	

}

5、Test

public class Test {
	public static void main(String[] args) {
		ConcreteFactory concrete = new ConcreteFactory();
		Lenovo l = concrete.getComputer(Lenovo.class);
		l.start();
		HpComputer hpComputer = concrete.getComputer(HpComputer.class);
		hpComputer.start();
	}

}

联想电脑启动
惠普电脑启动

三、抽象工厂模式

1、抽象工厂方法简介

主要针对情况，每一个产品的零件有不同的生产方式，而不同厂商又会生产各自的产品。比如汽车配件会有轮胎、玻璃等，而向BBS肯定会有各自生产轮胎玻璃的方式，又比如电脑会有台式与笔记本方式，而像联想、惠普又会有自己生产台式、笔记本的方法

2、抽象工厂方法结构

1、Iproduct定义出不同产品部件的抽象方法
2、Product定义出不同的产品部件
3、AbstractFactory:抽象产品，定义抽象产品的部件创造方法
4、ConcreteFactory:具体的产品，创建各自的产品部件

3、Demo

1、Iproduct

public abstract class DeskTopProducter {
	public abstract void start();
}
 abstract class NoteBookProducter {
	public abstract void start();
}

2、Product

class LenovoDeskComputer extends DeskTopProducter {

	@Override
	public void start() {
		System.out.println("台式联想电脑启动");
		
	}
	 
 }
 class LenovoNoteComputer extends NoteBookProducter {
	 
	 @Override
	 public void start() {
		 System.out.println("联想笔记本电脑启动");
		 
	 }
	 
 }
 
 class HpDeskComputer extends DeskTopProducter {
	 
	 @Override
	 public void start() {
		 System.out.println("台式惠普电脑启动");
		 
	 }
	 
 }
 class HpNoteComputer extends NoteBookProducter {
	 
	 @Override
	 public void start() {
		 System.out.println("惠普笔记本电脑启动");
		 
	 }
	 
 }

3、AbstractFactory

public abstract class abstractFactory {
	public abstract DeskTopProducter createDeskTop();
	public abstract NoteBookProducter createNoteBook();
}

4、ConcreteFactory

class LenovoFactory extends abstractFactory {

	@Override
	public DeskTopProducter createDeskTop() {
		return new LenovoDeskComputer();
	}

	@Override
	public NoteBookProducter createNoteBook() {
		// TODO Auto-generated method stub
		return new LenovoNoteComputer();
	}
	
} 
class HpFactory extends abstractFactory {
	
	@Override
	public DeskTopProducter createDeskTop() {
		// TODO Auto-generated method stub
		return new HpDeskComputer();
	}
	
	@Override
	public NoteBookProducter createNoteBook() {
		// TODO Auto-generated method stub
		return new HpNoteComputer();
	}
	
} 

5、Test

public class Test {
	public static void main(String[] args) {
		abstractFactory lfactory = new LenovoFactory();
		lfactory.createDeskTop().start();
		lfactory.createNoteBook().start();
		abstractFactory hpfactory = new HpFactory();
		hpfactory.createDeskTop().start();
		hpfactory.createNoteBook().start();
	}

}

台式联想电脑启动
联想笔记本电脑启动
台式惠普电脑启动
惠普笔记本电脑启动

四、引用

【1】demo实例引用：http://liuwangshu.cn/designpatterns/13-abstractfactory.html