3种工厂模式

3种工厂模式

1. 问题描述
   简单工厂模式：模拟女娲造人，如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。
   工厂方法模式：海尔工厂生成海尔空调，美的工厂生产美的空调，描述该场景，绘制类图并编程实现
   抽象工程模式：电脑配件生产内存、CPU等硬件设备，这些内存、CPU的品牌、型号并不一定相同，根据“产品等级结构-产品族”示意图，实现电脑配件生产过程并绘制相应的类图，绘制类图并编程实现

2. 解题思路
   简单工厂模式，根据不同参数返回不同对象，可用接口实现。Man Woman Robot3个类实现一个Person类接口，重写接口中的方法。女娲类作为工厂，应当完成返回不同对象的任务。即定义一个带参方法，判断参数并返回相应对象。最后需要一个类，作为操作入口，调用女娲类中方法，传入实参，返回对象，根据向上转型用抽象的person来实现3个类得到结果。
   工厂方法模式：与上一个模式不同的是，该模式是一个抽象工厂下可以继承多个不同工厂，各工厂实现不同产品的生产。因此定义一个接口AirconditionFactory为抽象工厂，海尔工厂和美的工厂各自实现接口，重写生产空调的方法。再定义一个接口Aircondition，海尔空调和美的空调实现该接口方法。此外，定义与两个接口关联的类，和上面方法相同，通过返回具体工厂对象，调用相应工厂方法来实现题目要求
   抽象工厂方法，不改变产品等级的情况下对原有等级进行组装。几个工厂产品生产种类相同，数量相同。实现一个工厂和相应产品的对应即是一个产品族。

3. 算法构造
   
   简单工厂模式

工厂方法模式

抽象工程模式

4.实现代码

简单工厂模式：
package SimpleFactory;

// Person接口
public interface Person {
	public void makePeople();
}

// Man 类
public class Man implements Person {
	public void makePeople() {
		System.out.println("女娲制造一个男人");
	}
}

// Woman 类
public class Woman implements Person {
	public void makePeople() {
		System.out.println("女娲制造一个女人");
	}
}

// Robot类
public class Robot implements Person {
	public void makePeople() {
		System.out.println("女娲制造一个机器人");
	}
}

//Nvwa 类
public class Nvwa {
	public static Person make(String args) {
		if(args.equalsIgnoreCase("M")) {
			return new Man(); 
		}else if(args.equalsIgnoreCase("W")) {
			 return new Woman();
		}else if(args.equalsIgnoreCase("R")) {
			return new Robot();
		}else {
			return null;
			}
		}
	}
	
// NvwamakePeople类
public class NvwamakePeople {
	public static void main(String[] args) {
		Person person ;  //创建一个对象
		person=Nvwa.make("M");
		person.makePeople();
		  person=Nvwa.make("W");
		person.makePeople();
		 person=Nvwa.make("R");
		person.makePeople();
	}
}


工厂方法模式：
package FactoryMethod;

// AirconditionFactory接口
public interface AirconditionFactory {
	public static Aircondition produceAircondition(String args) {
  		  return null;
	 }
 }
 
//HaierconditonFactory 类
public class HaierconditonFactory  implements AirconditionFactory {
	public  static Aircondition produceAircondition(String args) {
		if(args.equalsIgnoreCase("Haier")) {
			System.out.println("海尔工厂生产海尔空调")
			 return new HaierAircondition();
 		}else {
 			System.out.println("海尔工厂不生产非海尔品牌空调");
 			return null;
 			}
 		}
 	}
 	
//MideaAirconditionFactory类
public class MideaAirconditionFactory implements AirconditionFactory {
	public static Aircondition produceAircondition(String args) {
		if(args.equalsIgnoreCase("Midea")) {
 			System.out.println("美的工厂生产美的空调");
			return new MideaAircondition();
		}else {
			System.out.println("美的工厂不生产非美的品牌空调");
			return null;
		}
	}
}

//Aircondition接口
public interface Aircondition {
	public static void play() {
	}
}

//HaierAircondition 类
public class HaierAircondition implements Aircondition {
	public static void play() {
		System.out.println("海尔空调正在运行中.....");
	}
}

//MideaAircondition类
public class MideaAircondition implements Aircondition{
	public static void play() {
		System.out.println("美的空调正在运行中.....");
	}
}

//client类
public class client {
	public static void main(String[] args) {	
		Aircondition aircondition; //创建一个对象
		aircondition = HaierconditonFactory.produceAircondition("Haier");
		HaierAircondition.play();
		aircondition = MideaAirconditionFactory.produceAircondition("Midea");
		MideaAircondition.play();
	}
}

抽象工程模式：
package abstractProject;

// Factory 接口
public interface Factory {
	public static RAM produceRAM(String args) {
		return null;
	}
	public static CPU produceCPU(String args) {
		return null;
	}
}

// MacFactor类
public class MacFactory implements Factory {
	public static RAM produceRAM(String args) {
		if(args.equalsIgnoreCase("Mac")) {
			System.out.println("Mac工厂生产MacRAM ");
			return new MacRAM();
		}else {
			System.out.println("Mac工厂不生产非Mac牌RAM ");
			return null;
		}
	}	
	public static CPU produceCPU(String args) {
		if(args.equalsIgnoreCase("Mac")) {
			System.out.println("Mac工厂生产MaCPU ");
   			return new MacCPU();
   		}else {
			System.out.println("Mac工厂不生产非MacC牌CPU ");
			return null;
			}
		}
	}
	
//PCFactory 类
public class PCFactory implements Factory {
	public static RAM produceRAM(String args) {
 		 if(args.equalsIgnoreCase(PC")) {
   			System.out.println("PC工厂生产PCRAM ");
   			return new PCRAM();
   		}else {
   			System.out.println("PC工厂不生产非PC牌RAM ");
   			return null;
   			}
   		}
   	public static CPU produceCPU(String args) {
   		if(args.equalsIgnoreCase("PC")) {
   			System.out.println("PC工厂生产PCCPU ");
   			return new PCCPU();
   		}else {
   			System.out.println("PC工厂不生产非PC牌CPU ");
   			return null;
   			}
   		}
   	}

// CPU接口
public interface CPU {
 	public static void play() {}
 }
 
// MacCPU类
public class MacCPU implements CPU {
	public static void play() {
		System.out.println("MacCPU正在运行中....");
	}
}

// PCCPU 类
public class PCCPU implements CPU {
	public static void play() {
		System.out.println("PCCPU正在运行中....");
	}
}

// RAM 接口
public interface RAM {
	public static void save() {}
}

// MacRAM 类
public class MacRAM implements RAM {
	public static void save() {
		System.out.println("MacRAM正在存储中....");
	}
}

// PCRAM 类
public class PCRAM implements RAM {
	public static void save() {
		System.out.println("PCRAM正在存储中....");
	}
}

//client 类
public class client {
	public static void main(String[] args) {
		CPU cpu;
		RAM ram;
		ram = PCFactory.produceRAM("PC");
		PCRAM.save();
		cpu = PCFactory.produceCPU("PC");
		PCCPU.play();
		ram = MacFactory.produceRAM("Mac");
		MacRAM.save();
		cpu = PCFactory.produceCPU("PC");
		MacCPU.play();
	}
}

5. 调试
   简单工厂模式：
   
   调用Nvwa的make方法
   

返回了man对象后继续调用man对象的makePeople方法

界面跳转到man对象中

控制台输出makePeple方法的语句

工厂方法模式：

调用海尔工厂生产海尔空调的方法

界面跳转到海尔工厂，经过判断，输出语句并返回海尔空调对象

在变量界面可以看到返回的HaierAircondition对象

调用海尔对象方法输出语句，显示最终结果

6. 测试及结果
   
   简单工厂模式
   
   工厂方法模式
   
   抽象工厂模式

7. 经验归纳
   这次对三种模式的编程实现很大程度上依靠了老师的课件。在简单工厂模式编码实现后其他两种模式在其基础上增加类和接口等，思想上也有不同。简单工厂模式重在返回的是对象，通过向上转型，虽然调用的是抽象类（即接口）的方法，实际上是返回的具体对象，因此返回的也是相应的方法中所写语句。工厂方法不同的在于不是一个工厂生产所有需要的产品，各种工厂继承抽象工厂的方法，生产相应的产品。因此，需要两个具体的类实现一个接口AirconditionFactory，另两个类实现一个接口Airconditio。此过程中我总是会不知道哪个方法写在哪个类里。这个应该通过绘制类图来确定，只要确定在最终的client类中调用的方法，弄清思路还是可以解决的。最后一个是抽象工厂模式，总体思路与上一个一样，只是每个工厂生产的产品不再是1个，各工厂生产的产品种类相同。这几种模式还需要几次练习，才可以熟练掌握。