三种工厂模式

参考：https://www.cnblogs.com/luofay/p/6099034.html
https://blog.csdn.net/qq_33220449/article/details/54602840
https://www.imooc.com/article/19600
1.题目分析
(1)、 简单工厂模式
使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。
(2)、 工厂方法模式
海尔工厂(Haier)生产海尔空调(HaierAirCondition)，美的工厂(Midea)生产美的空调(MideaAirCondition) 。使用工厂方法模式描述该场景，绘制类图并编程实现。
(3)、 抽象工程模式
电脑配件生产工厂生产内存、CPU等硬件设备，这些内存、CPU的品牌、型号并不一定相同，根据下面的“产品等级结构-产品族”示意图，使用抽象工厂模式实现电脑配件生产过程并绘制相应的类图，绘制类图并编程实现。
2.类图设计
简单工厂模式：
工厂方法模式：

抽象工程模式：
3.程序实现
简单工厂模式：

package nvwa;
public class nvwa {
	public static Person getPerson(String people) {
		Person person=null;
		if(people.equalsIgnoreCase("M")) {
			person=new Man();
		}else if(people.equalsIgnoreCase("W")) {
			person=new Woman();
		}else if(people.equalsIgnoreCase("R")) {
			person=new Robot();
		}
		return person;
	}
}
package nvwa;
public class Man extends Person{
	public void eat() {
		System.out.println("男人吃东西......");
		super.eat();
	}
	public void run() {
		System.out.println("男人跑步......");
		super.run();
	}	
}
package nvwa;
public class Woman extends Person{
	public void eat() {
		System.out.println("女人吃东西.......");
		super.eat();
	}
	public void run() {
		System.out.println("女人跑步......");
		super.run();
	}
}
package nvwa;
public class Robot extends Person{
	public void eat() {
		System.out.println("机器人吃东西......");
		super.eat();
	}
	public void run() {
		System.out.println("机器人跑步......");
	}
}
package nvwa;
public abstract class Person {
		public void run() {}
		public void eat() {}
}
package nvwa;
public class MakePerson {
	public static void main(String[] args) {
		Person person;
		person=nvwa.getPerson("M");
		person.eat();
		person=nvwa.getPerson("W");
		person.eat();
		person=nvwa.getPerson("R");
		person.eat();
	}
}

工厂方法模式：

package Air;
public interface Air {
    void work();
}
package Air;
public interface AirFactory {
	Air produceAir();
}
package Air;
public class HaierAir implements Air{
	public void work() {
		System.out.println("这是海尔空调......");
	}
}
package Air;
public class HaierAirFactory implements AirFactory{
	public HaierAir produceAir() {
		System.out.println("海尔空调在工作......");
		return new HaierAir();
	}
}
package Air;
public class MideaAir implements Air{
	@Override
	public void work() {
		// TODO Auto-generated method stub
		System.out.println("这是美的空调......");
	}
}
package Air;
public class MideaAirFactory implements AirFactory{
	public MideaAir produceAir() {
		System.out.println("美的空调在工作......");
		return new MideaAir();
	}
}
package Air;
public class Test {
	public static void main(String[] args) {
		AirFactory Airfactory=new HaierAirFactory();
		Air air=Airfactory.produceAir();
		Airfactory=new MideaAirFactory();
		air=Airfactory.produceAir();
	}
}

抽象工厂模式：

package Computer;
public interface ComputerAccessoriesFactory {
	CPU produceCPU();
	RAM produceRAM();
}
package Computer;
public interface CPU {
	void describe();
}
package Computer;
public abstract class MACCPU implements CPU{
	public void discribe() {
		System.out.println("这是MAC的CPU......");
	}
}
package Computer;
public class MACFactory implements ComputerAccessoriesFactory{
	@Override
	public MACCPU produceCPU() {
		// TODO Auto-generated method stub
		System.out.println("MAC的CPU被创造啦......");
		return new MACCPU();
	}
	@Override
	public MACRAM produceRAM() {
		// TODO Auto-generated method stub
		System.out.println("MAC的RAM被创造啦......");
		return new MACRAM();
	}
}
package Computer;
public class MACRAM implements RAM{
	@Override
	public void describe() {
		// TODO Auto-generated method stub
		System.out.println("这是MAC的RAM......");
	}
}
package Computer;
public class PCCPU implements CPU{
	public void describe() {
		System.out.println("这是PC的CPU......");
	}
}
package Computer;
public class PCFactory implements ComputerAccessoriesFactory{
	public PCCPU produceCPU() {
		System.out.println("PC的CPU被创造啦......");
		return new PCCPU();
	}
	public PCRAM produceRAM() {
		System.out.println("PC的RAM被创造啦......");
		return new PCRAM();
	}
}
package Computer;
public abstract class PCRAM implements RAM{
	public void descibe() {
		System.out.println("PCRAM");
	}
}
package Computer;
public interface RAM {
	void describe();
}
package Computer;
public class Test {
	public static void main(String[] args) {
		ComputerAccessoriesFactory a=new PCFactory();
		ComputerAccessoriesFactory b=new MACFactory();
		CPU cpu=a.produceCPU();
		RAM ram=b.produceRAM();
		cpu.describe();
		ram.describe();
	}
}

4.调试、测试及运行结果
测试：
简单工厂模式：
工厂方法模式：
抽象工厂模式：
运行结果：
简单工厂模式：
工厂方法模式：
抽象工程模式：

5.经验归纳：
简单工厂模式：
优点：在于实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类负责。
缺点：在于工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法代码将会非常复杂。
工厂方法模式：
简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责产品类被实例化这种细节，这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。
抽象工厂模式：
对工厂方法模式的进一步扩展。在工厂方法模式中，一个具体的工厂负责生产一类具体的产品，即一对一的关系，但是，如果需要一个具体的工厂生产多种产品对象，那么就需要用到抽象工厂模式了。