设计模式 抽象工厂

01.人类接口

public interface Human { 
//首先定义什么是人类
 //人是愉快的，会笑的，本来是想用smile表示，想了一下laugh更合适，好长时间没有大笑了；
public void laugh(); 
 
//人类还会哭，代表痛苦
public void cry(); 
 
//人类会说话
public void talk(); 
 
//定义性别
public void sex(); 
} 

02.接口的实现类（这里是抽象类）

因为抽象类的子类还可以扩展

AbstractYellowHuman ：

public abstract class AbstractYellowHuman implements Human { 
 
	public void cry() { 
	 System.out.println("黄色人类会哭");
	 } 
	 
	 public void laugh() { 
	 System.out.println("黄色人类会大笑，幸福呀！"); 
	 } 
	 
	public void talk() { 
	 System.out.println("黄色人类会说话，一般说的都是双字节"); 
	 } 
 
} 

AbstractWhiteHuman ：

public abstract class AbstractWhiteHuman implements Human { 

	public void cry() { 
	 System.out.println("白色人类会哭"); 
	 } 
	 
	public void laugh() { 
	 System.out.println("白色人类会大笑，侵略的笑声"); 
	 }
	 
	 public void talk() { 
	 System.out.println("白色人类会说话，一般都是但是单字节！"); 
	 } 
	 
} 

AbstractBlackHuman ：

public abstract class AbstractBlackHuman implements Human { 

	public void cry() { 
	 System.out.println("黑人会哭"); 
	 } 
	 
	public void laugh() { 
	 System.out.println("黑人会笑"); 
	 } 
	 
	public void talk() { 
	 System.out.println("黑人可以说话，一般人听不懂"); 
	 } 
	 
} 

抽象类都实现完毕了，然后就是些抽象类的实现类了。其实，你说抽象类放这里有什么意义吗？

就是不允许你 new 出来一个抽象的对象呗

03.实现类

女性黄种人的实现类：

public class YellowFemaleHuman extends AbstractYellowHuman { 
	public void sex() { 
	 System.out.println("该黄种人的性别为女..."); 
	 } 
} 

男性黄种人的实现类：

public class YellowMaleHuman extends AbstractYellowHuman { 
	public void sex() { 
	 System.out.println("该黄种人的性别为男...."); 
	 } 
} 

女性白种人的实现类：

public class WhiteFemaleHuman extends AbstractWhiteHuman { 
	public void sex() {
	System.out.println("该白种人的性别为女...."); 
	 } 
} 

男性白种人的实现类：

public class WhiteMaleHuman extends AbstractWhiteHuman { 
	public void sex() { 
	 System.out.println("该白种人的性别为男...."); 
	 } 
} 

女性黑种人的实现类：

public class BlackFemaleHuman extends AbstractBlackHuman { 
	public void sex() { 
	 System.out.println("该黑种人的性别为女..."); 
	 } 
} 

男性黑种人的实现类：

public class BlackMaleHuman extends AbstractBlackHuman { 
	public void sex() { 
	 System.out.println("该黑种人的性别为男..."); 
	 } 
} 

04.枚举类（有实现类的class信息）

public enum HumanEnum { 
	//把世界上所有人类型都定义出来
	YelloMaleHuman("com.cbf4life.yellowHuman.YellowMaleHuman"), 
	 
	YelloFemaleHuman("com.cbf4life.yellowHuman.YellowFemaleHuman"), 
	 
	WhiteFemaleHuman("com.cbf4life.whiteHuman.WhiteFemaleHuman"), 
	 
	WhiteMaleHuman("com.cbf4life.whiteHuman.WhiteMaleHuman"), 
	 
	BlackFemaleHuman("com.cbf4life.blackHuman.BlackFemaleHuman"), 
	 
	BlackMaleHuman("com.cbf4life.blackHuman.BlackMaleHuman"); 
	 
	private String value = ""; 
	//定义构造函数，目的是Data(value)类型的相匹配
	private HumanEnum(String value){ 
		 this.value = value; 
	 } 
	 
	public String getValue(){ 
		 return this.value; 
	 } 
	 	 
	/*
	 * java enum类型尽量简单使用，尽量不要使用多态、继承等方法
	 * 毕竟用Clas完全可以代替enum
	 */
}

注解：

枚举类的成员变量、方法和构造器

前面说过，枚举类是一种特殊的类，它一样可以有自己的成员变量、方法，可以实现一个或多个接口，也可以有自己的构造器。

同时，枚举类的每个实例的成员变量的值（即对应的含义）应该是不能改变的；所以，建议将枚举类的成员变量都使用 pirvate final 修饰。

那么问题又来了，所有成员变量都使用 final 修饰，则必须使用下面三种方法为成员变量指定初始值：

    （1）在构造器里为这些成员变量指定初始值。

    （2）在定义成员变量时指定默认值。

    （3）在初始化块中指定初始值。

实际上，后面两种方式并不常用。所以，应该为枚举类显示定义带参数的构造器。一旦为枚举类显示定义了带参数的构造器，列举枚举值时就必须对应的传入参数。

public enum Gender{
    MALE("男"),FEMALE("女");
    private final String name;
    private Gender(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
}

在第一行列出所有枚举值（实例）时，实际上就是调用了构造器创建枚举类对象；只是这里不需要使用 new 关键字，也无需显示调用构造器罢了。

在前面定义 SeasonEnum 时，没有传入参数，甚至没使用括号；是因为 SeasonEnum 里包含的是默认的无参构造器。

05.工厂类
接口：

public interface HumanFactory { 
	 
	//制造黄色人类
	public Human createYellowHuman(); 
	 
	//制造一个白色人类
	public Human createWhiteHuman(); 
	 
	//制造一个黑色人类
	public Human createBlackHuman(); 
	
}

抽象类：

public abstract class AbstractHumanFactory implements HumanFactory { 
	/*
	 * 给定一个性别人类，创建一个人类出来 专业术语是产生产品等级
	 */
	protected Human createHuman(HumanEnum humanEnum) { 
		 Human human = null; 
	 
	 //如果传递进来不是一个Enum中具体的一个Element的话，则不处理
	 if (!humanEnum.getValue().equals("")) { 
		 try { 
		 //直接产生一个实例
			 human = (Human) 
			 Class.forName(humanEnum.getValue()).newInstance(); 
		 } catch (Exception e) { 
		 //因为使用了enum，这个种异常情况不会产生了，除非你的enum有问题；
			 e.printStackTrace(); 
		 } 
	 }
	  
	 return human; 
	 
	 } 
} 

这个抽象类的目的就是减少下边实现类的代码量，我们看实现类：

实现类：

public class MaleHumanFactory extends AbstractHumanFactory { 
	
	//创建一个男性黑种人
	public Human createBlackHuman() { 
		 return super.createHuman(HumanEnum.BlackMaleHuman); 
	 } 
	
	//创建一个男性白种人
	public Human createWhiteHuman() { 
		 return super.createHuman(HumanEnum.WhiteMaleHuman); 
	 } 
	
	//创建一个男性黄种人
	public Human createYellowHuman() { 
		 return super.createHuman(HumanEnum.YelloMaleHuman); 
	 } 
} 

public class FemaleHumanFactory extends AbstractHumanFactory {
 
	//创建一个女性黑种人
	public Human createBlackHuman() { 
		 return super.createHuman(HumanEnum.BlackFemaleHuman); 
	 } 
	 
	//创建一个女性白种人
	public Human createWhiteHuman() { 
		 return super.createHuman(HumanEnum.WhiteFemaleHuman); 
	 } 
	 
	//创建一个女性黄种人
	public Human createYellowHuman() { 
		 return super.createHuman(HumanEnum.YelloFemaleHuman); 
	 } 
} 

06.运行

public class NvWa { 
 
public static void main(String[] args) { 
 
	 //第一条生产线，男性生产线
	 HumanFactory maleHumanFactory = new MaleHumanFactory(); 
	 
	 //第二条生产线，女性生产线
	 HumanFactory femaleHumanFactory = new FemaleHumanFactory(); 
	 
	 //生产线建立完毕，开始生产人了:
	 Human maleYellowHuman = maleHumanFactory.createYellowHuman(); 
	 
	 Human femaleYellowHuman = femaleHumanFactory.createYellowHuman(); 
	 
	 maleYellowHuman.cry(); 
	 maleYellowHuman.laugh(); 
	 femaleYellowHuman.sex(); 
 /*
 * .....
 * 后面你可以续了
 */
 } 
}