简单工厂模式，工厂方法模式，抽象工厂方法的具体实现

1.题目分析
简单工厂模式：首先定义一个Nvwa的接口，里面定义一个show()的抽象方法。再定义Man、Woman和Robot三个类分别继承Nvwa这个接口，并重写show()方法。再定义一个creatfactory类，与Man、Woman、Robot类有关联。通过传入的参数，给相应的类产生了相应的对象并返回该对象
工厂方法模式：首先定义一个airConditioner的接口，定义一个Play的抽象方法，再定义HaierAirConditioner类和HMideaAirConditioner类分别继承上面那个接口，重写Play（）方法。再定义一个工厂类的接口，分别为Haier和HMidea定义俩个具体的工厂类，然后具体的工厂类和具体的产品类产生关联。
抽象工厂模式：先定义个内存和CPU的接口，内存接口中有个used()方法，CPU接口中有个work()方法。然后定义Pc内存类，Mac内存类，都继承内存这个接口。再定义PcCPU类和MacCPU类，都继承CPU接口。再定义一个工厂的接口，里面有 Memory和CPU方法，然后定义Pc工厂类和Mac工厂类，重写俩个方法，然后对应的和上边的具体产品类进行关联

2.类图设计：
简单工厂模式

工厂方法模式

抽象工厂模式

3.程序实现
简单工厂模式：
package moshi1;

import java.util.Scanner;

interface Nvwa {//抽象父类
public void show();
}

class Man implements Nvwa {//男人类继承父类
public void show() {//重写show（）方法
System.out.println(“返回一个Man的对象”);
}
}

class Woman implements Nvwa {//女人类继承父类
public void show() {
System.out.println(“返回一个Woman的对象”);
}
}

class Robot implements Nvwa {//机器人类继承父类
public void show() {
System.out.println(“返回一个Robot的对象”);
}
}

class creatfactory {
public Nvwa creat(String n) {
if (n.equals(“M”)) {
Nvwa m = new Man();//产生一个Man类的对象并返回
return m;
} else if (n.equals(“W”)) {
Nvwa w = new Woman();
return w;
} else if (n.equals(“R”)) {
Nvwa r = new Robot();
return r;
}
return null;
}
}

public class Moshi1 {
public static void main(String[] args) {
System.out.println(“请输入你要传的参数(M or W or R)”);
Scanner sc=new Scanner(System.in);
String s=sc.nextLine();
creatfactory c=new creatfactory();
c.creat(s).show();//通过返回的对象调用对应的show（）方法
}

}

工厂方法模式：

package moshi2;

import java.util.Scanner;

interface airConditioner {//空调接口
public void Play();
}

class HaierAirConditioner implements airConditioner {//海尔空调继承空调接口
public void Play() {//重写Play()方法
System.out.println(“海尔空调正在运行中”);
}
}

class MideaAirConditioner implements airConditioner {//美的空调继承空调接口
public void Play() {
System.out.println(“美的空调正在运行中”);
}
}

interface Factory2 {//工厂接口
public airConditioner producAirConditioner();//返回一个空调的对象
}

class HaierFactory2 implements Factory2 {//海尔工厂继承工厂接口
public airConditioner producAirConditioner() {
return new HaierAirConditioner();//返回一个海尔空调的对象
}
}

class MideaFactory2 implements Factory2 {//美的工厂继承工厂接口
public airConditioner producAirConditioner() {
return new MideaAirConditioner();//返回一个美的空调的对象
}
}
public class Moshi2 {
public static void main(String[] args) {
System.out.println(“请输入要运行空调的品牌（Haier or Mide）”);
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
if(str.equals(“Haier”)) {
new HaierFactory2().producAirConditioner().Play();
}else if(str.equals(“Mide”)) {
new MideaFactory2().producAirConditioner().Play();
}
}
}

抽象工厂模式：

package moshi3;

import java.util.Scanner;

interface computerMemory{//内存接口
public void used();
}

class PcComputerMemory implements computerMemory{//Pc电脑内存继承内存接口
public void used() {
System.out.println(“Pc电脑的内存正在被使用中”);
}
}

class MaccomputerMemory implements computerMemory{//Mac电脑内存继承内存接口
public void used() {
System.out.println(“Mac电脑的内存正在被使用中”);
}
}

interface computerCPU{//CPU接口
public void work();
}

class PcComputerCPU implements computerCPU{//Pc电脑CPU继承CPU接口
public void work() {
System.out.println(“Pc电脑CPU正在工作中”);
}
}

class MacComputerCPU implements computerCPU{//Mac电脑CPU继承CPU接口
public void work() {
System.out.println(“戴尔电脑CPU正在工作中”);
}
}

interface factory{//工厂接口
public computerMemory Memory();//内存方法
public computerCPU CPU();//CPU方法
}

class PcFactory implements factory{//Pc工厂继承工厂接口
public computerMemory Memory() {
return new PcComputerMemory();//返回相应的对象
}
public computerCPU CPU() {
return new PcComputerCPU();
}
}

class MacFactory implements factory{//Mac工厂继承工厂接口
public computerMemory Memory() {
return new MaccomputerMemory();
}
public computerCPU CPU() {
return new MacComputerCPU();
}
}
public class Moshi3 {
public static void main(String[] args) {
System.out.println(“请输入要生产的电脑（Pc or Mac）”);
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
if(str.equals(“Pc”)) {
factory hp=new PcFactory();
hp.Memory().used();
hp.CPU().work();
}
else if(str.equals(“Mac”)) {
factory dl=new MacFactory();
dl.Memory().used();
dl.CPU().work();

	}
}

}

4.调试、测试、及运行结果:
简单工厂模式的运行结果;

工厂方法模式的运行结果：

抽象工厂模式的运行结果：

5.经验归纳：
通过编写三种模式的代码，发现了各种模式的优缺点：
简单工厂的优点：实现了对象创建和使用的分离，无须知道具体产品类的类名，在不修改任何客户端代码的情况下跟新和增加新的具体产品类
缺点：工厂类的责任过重，系统扩展困难，造成工厂角色无法形成基于继承的等级结构
工厂方法模式优点：向客户端隐藏了那种具体产品类能被实例化这一细节。能够让工厂自主确定创建何种产品对象，完全符合开闭原则
缺点：类的个数将成对增加，增加了系统的抽象性和理解难度
抽象工厂模式优点：隔离了具体类的生成，能够保证客户端始终只使用一个产品族中的对象。增加新的产品族很方便，符合开闭原则
缺点：增加新的产品等级结构麻烦。