简单工厂模式、工厂方法模式和抽象工厂模式

第四章面向对象程序设计方法
一.题目分析
1.简单工厂模式
使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。
People作为抽象类，它可以是一个接口，也可以是一个抽象类，其中包括了女娲造人方法makePeople()。Man、Women、Robat分别为抽象类People的子类，它是一种具体操作，实现了People接口中定义的方法makePeople()，只不过不同的对象在实现方法时有所不同。
2.工厂方法模式
海尔工厂(Haier)生产海尔空调(HaierAirCondition)，美的工厂(Midea)生产美的空调(MideaAirCondition) 。使用工厂方法模式描述该场景，绘制类图并编程实现。
Air是一个抽象类，作为抽象类，它可以是一个接口，也可以是一个抽象类，其中包括了业务方法work()。具体产品类为HaierAir和Midea，它是抽象产品Air接口的子类，是一种具体产品。AirFactory是抽象工厂类，它包含了抽象的工厂方法ProduceAir()，返回一个抽象产品Air类型的对象。HaierAirFactory和MideaAirFactory是具体工厂类，在工厂方法中创建并返回一个对象的具体产品。
3.抽象工程模式
电脑配件生产工厂生产内存、CPU等硬件设备，这些内存、CPU的品牌、型号并不一定相同，根据下面的“产品等级结构-产品族”示意图，使用抽象工厂模式实现电脑配件生产过程并绘制相应的类图，绘制类图并编程实现。
抽象工厂：abfactory。 抽象方法功能：创建一个工厂。具体工厂：Pcfactory，Macfactory。抽象产品：cpu,ram。具体产品：。（Pc牌）Pccpu,Pcram。（Mac牌）Maccpu,Macram。Pcfactory生产Pc牌，Macfactory生产Mac牌。即一个工厂生产一个产品族不同产品等级结构的产品。

二.类图设计
1.简单工厂模式

2.工厂方法模式

3.抽象工程模式

三.实现过程
1.简单工厂模式

    package make_people;
    public interface People {
    	public void makePeople();
    }
    public class Man implements People {
    	public void makePeople() {
    		// TODO Auto-generated method stub
    		System.out.println("出现男人");
    	}
    }
    public class Woman implements People {
    	public void makePeople() {
    		// TODO Auto-generated method stub
    		System.out.println("出现女人");
    	}
    }
    public class Robat implements People {
    	public void makePeople() {
    		// TODO Auto-generated method stub
    		System.out.println("出现机器人");
    	}
    }
    public class Nvwa {
    	public static People getPeople(String arg) {
    		People people=null;
    		if(arg.equalsIgnoreCase("M")) {
    			people=new Man();
    			System.out.println("女娲造男人");
    		}
    		else if(arg.equalsIgnoreCase("W"))
    		{
    			people=new Woman();
    			System.out.println("女娲造女人");
    		}
    		else if(arg.equalsIgnoreCase("R"))
    		{
    			people=new Robat();
    			System.out.println("女娲造机器人");
    		}
    		return people;
    	}
    }
    class Client { 
    	public static void main(String[] args) {
    		People p;
    		p=Nvwa.getPeople("R");
    		p.makePeople();
    	}
    }

2.工厂方法模式

package AirCondition;
public interface Air {
	public void work();
}
public interface AirFactory {
	Air ProduceAir();
}
public class HaierAir implements Air{
	public void work() {
		System.out.println("海尔工厂正在生产海尔空调！");
	}
}
public class HaierAirFactory implements AirFactory{
	public HaierAir ProduceAir() {
		System.out.println("生产了海尔空调！");
		return new HaierAir();
	}
}
public class MideaAir implements Air{
	public void work() {
		System.out.println("美的工厂正在生产美的空调！");
	}
}
public class MideaAirFactory implements AirFactory{
	public MideaAir ProduceAir() {
		System.out.println("生产了美的空调！");
		return new MideaAir();
	}
}
public class Test {
	public static void main(String[] args) {
		AirFactory airfactory=new HaierAirFactory();
		Air air=airfactory.ProduceAir();
		airfactory=new MideaAirFactory();
		air=airfactory.ProduceAir();
	}
}

3.抽象工厂模式

package abstrac_t;
public interface abfactory {
    public cpu productcpu();
    public ram productram();
}
public class Macfactory implements abfactory {
    //实例化一个Mac端CPU，返回，下面相同
    public cpu productcpu() {
        return new Maccpu();
    }
    public ram productram() {
        return new Macram();
    }
}
public class Pcfactory implements abfactory {
    public cpu productcpu() {
        return new Pccpu();
    }

    public ram productram() {
        return new Pcram();
    }
}
public interface cpu {
    public void productedcpu();
}
public class Pccpu implements cpu {
    public void productedcpu(){
        System.out.println("Pc端CPU已生产！");
    }
}
public class Maccpu implements cpu {
    public void productedcpu(){
        System.out.println("Mac端CPU已生产！");
    }
}
public interface ram {
    public void productedram();
}
public class Pcram implements ram {
    public void productedram(){
        System.out.println("Pc端内存已生产！");
    }
}
public class Macram implements ram {
    public void productedram(){
        System.out.println("Mac端内存已生产！");
    }
}
public class client {
    public static void main(String[] args){
        cpu cpu;
        ram ram;
        abfactory factory;
        //首先生产Pc端的产品族
        factory = new Macfactory();
        cpu = factory.productcpu();
        ram = factory.productram();
        cpu.productedcpu();
        ram.productedram();
    }
}

四.运行结果
1.简单工厂模式

存在Man类，传参M，则返回一个Man对象，程序运行结果如下：

存在Woman类，传参M，则返回一个Woman对象，程序运行结果如下：

当增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，程序运行结果如下：

2.工厂方法模式

3.抽象工程模式

五.归纳总结
1.简单工厂模式
简单工厂模式优点：工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责"消费"对象就可以了。而不必管这些对象究竟如何创建及如何组织的.明确了各自的职责和权利，有利于整个软件体系的优化。
简单工厂缺点：
（1）由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中;它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
（2）当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求.这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利;
（3）这些缺点在工厂方法模式中得到了一定的克服。
2.工厂方法模式
服了简单工厂违背开放-封闭原则的缺点，又保留了封装对象创建过程的优点,降低客户端和工厂的耦合性，所以说“工厂模式”是“简单工厂模式”的进一步抽象和推广。但是每增加一个产品，相应的也要增加一个子工厂，加大了额外的开发量。
3.抽象工程模式
抽象工厂模式优点：
（1）隔离了具体类的生成，使得客户端并不需要知道什么被创建。
（2）当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。
（3）增加新的产品族很方便，无须修改已有系统，符合开闭原则。
抽象工厂模式缺点：
（1）增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了开闭原则。