设计模式——简单工厂，工厂，抽象工厂的简单应用

题目内容：
(1)、简单工厂模式
使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。
(2)、工厂方法模式
海尔工厂(Haier)生产海尔空调(HaierAirCondition)，美的工厂(Midea)生产美的空调(MideaAirCondition) 。使用工厂方法模式描述该场景，绘制类图并编程实现。
（1）创建抽象工厂：Airfactory 抽象方法：productAir()暗指工厂实现类功能为生产空调。
（2）创建抽象产品：Air（空调）抽象方法：producted ()
（3）创建具体产品：HaierAir（海尔空调）和MideaAir （美的空调）实现抽象方法producted()：这里可以输出一个信息，提示空调已生产或者正在使用，在后期控制台可以看。
（4）创建具体工厂：Haierfactory（海尔工厂）和Mideafactory（美的工厂）用来生产各自的空调；
实现抽象方法：productAir() 返回类型是 Air(空调)，各自工厂，返回的Air也不同。美的工厂返回MideaAir,海尔工厂返回HaierAir.

(3)、抽象工程模式
电脑配件生产工厂生产内存、CPU等硬件设备，这些内存、CPU的品牌、型号并不一定相同，根据下面的“产品等级结构-产品族”示意图，使用抽象工厂模式实现电脑配件生产过程并绘制相应的类图，绘制类图并编程实现。
创建实现接口CPU的类pcCPU，MacCPU，并重写函数discribe（）
创建实现接口RAM的类pcRAM，MacRAM，并重写函数discribe（）
创建实现接口FACTORY的类pcFACTORY，MacFACTORY，并重写函数produce（）

二:具体实现
1。简单工厂

设计模式——简单工厂，工厂，抽象工厂的简单应用
接口：

package 设计模式2;

public interface SingleFactory {
public void make();	
}

男性类

package 设计模式2;

public class MAN implements SingleFactory {
	public void make() {
		System.out.println("make a man");
	
	}

}

女性类

package 设计模式2;

public class WOMAN implements SingleFactory{
	public void make() {
		System.out.println("make a woman");
	}

}

机器人类
英语打错了，参考时注意

package 设计模式2;

public class roobt implements SingleFactory {
	public void make()
	{
	System.out.println("make a robot");

}
	}

女娲类

package 设计模式2;

public class Nvwa {
	public static SingleFactory getPeople(String arg) {
	SingleFactory people=null;
		if(arg.equalsIgnoreCase("M")) {
			people=new MAN();
			System.err.println("女娲要制造男人了");
		}
		else if(arg.equalsIgnoreCase("W"))
		{
			people=new WOMAN();
			System.err.println("女娲要制造女人了");
		}
		else if(arg.equalsIgnoreCase("R")) {
		people= new roobt();	
				System.err.println("制造机器人");	
		}
		
		return people;



}
}

客户端类

package 设计模式2;

public class client {
public static void main(String[] args) {
		
		SingleFactory p;
		p=Nvwa.getPeople("M");
		p.make();

}
}

2。工厂

设计模式——简单工厂，工厂，抽象工厂的简单应用

package 空调;
public interface Air {
	public void producted();
}


package 空调;
public interface Airfactory {
	public Air productAir();




package 空调;
public class HaierAir implements Air{
	public void producted() {
        System.out.println("海尔空调已生产！");
}
}


package 空调;
public class HaierFactory implements Airfactory{
	public Air productAir(){
        return new HaierAir();
}
}


package 空调;
public class MeadeAir implements Air{
	public void producted() {
        System.out.println("美的空调已生产！");
}
}


package 空调;
public class MeadeFactory implements Airfactory{
	public Air productAir() {
        return new MeadeAir();
    }

}


package 空调;
public class client {
	public static void main(String[] args){
        //产生一个抽象空调
        Air a;
        Airfactory factory = new HaierFactory();
        a = factory.productAir();
        a.producted();
    }
}
}

3.抽象工厂

设计模式——简单工厂，工厂，抽象工厂的简单应用

package Computer;

public interface CPU {
	   void discribe();
}



package Computer;

public interface RAM {
	   void discribe();
}


package Computer;

public interface Factory {
	CPU produceCPU();
    RAM produceRAM();
}


package Computer;

public class pcCPU implements CPU{
	public void discribe()

    {
           System.out.println("This is produce the PC_CPU");
          }
}


package Computer;

public class pcRAM implements RAM{
	public void discribe()

    {
           System.out.println("this is produce PcRAM");
    }
}

package Computer;

public class pcFactory implements Factory {
	 public pcCPU produceCPU() {

         System.out.println("PC_CPU produced!");

         return new pcCPU();

}
	 public pcRAM produceRAM() {

         System.out.println("PC_RAM produced! >_<");

         return new pcRAM();


}
}


package Computer;

public class MacCPU implements CPU{
	
	public void discribe()

    {

           System.out.println("This is produce the Mac_CPU");

    }
}


package Computer;

public class MacRAM implements RAM{
	public void discribe()

    {

           System.out.println("This is produce the MacRAM");

    }

}


package Computer;

public class MacFactory implements Factory{
	public MacCPU produceCPU() {

        System.out.println("MacCPU produced!");

        return new MacCPU();

 }



 public MacRAM produceRAM() {

        System.out.println("MacARM produced!");

        return new MacRAM();

 }

}



package Computer;

public class client {
	public static void main(String[] args) {

        // TODO Auto-generated method stub

     Factory a = new pcFactory();

        Factory b = new MacFactory();

  CPU cpu = a.produceCPU();

  RAM ram = b.produceRAM();

  cpu.discribe();

  ram.discribe();

 }
}

设计模式——简单工厂，工厂，抽象工厂的简单应用

相关推荐