设计模式——工厂模式

简单工厂模式

将对象的创建交给专门的工厂类负责，实现了对象的创建和对象的使用分离。

/*
 * 工厂返回创建对象，main中根据需要具体调用方法
 * 缺点：工厂类不够灵活，增加新的具体产品需要修改工厂类增加一个 if 判断分支才能支持。
 * 		而且当产品类型较多时，简单工厂的 if 判断将会非常多，不容易维护。
 * 
 * **/
public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HumanFactory hf = new HumanFactory();
		//只能实例化接口类（Human），不能实例化（BlackHuman）
		Human bm = hf.CreateHuman("blackhuman");
		//工厂返回创建对象，main中根据需要具体调用方法
		bm.talk();
		Human ym = hf.CreateHuman("yellowhuman");
		Human wm = hf.CreateHuman("whitehuman");
		wm.talk();	
	}

}

public class HumanFactory {
	//此时要返回Human，这样创造出人的具体方法，在Test中根据需求调用
	//此工厂只建造返回人，不进行调用方法
//	public void createHuman(String Human) {  
//		if(Human.equals(Constant.BLACK)) {
//			BlackHuman b = new BlackHuman();
//			b.talk();
//		}else if(Human.equals(Constant.WHITE)){
//			WhiteHuman w = new WhiteHuman();
//			w.talk();
//		}
//		else if(Human.equals(Constant.YELLOW)){
//			YellowHuman y = new YellowHuman();
//			y.talk();
//		}
//		else {
//			System.out.println("不能创造这种肤色");
//		}
//	}
	
	public Human CreateHuman(String Human) {
		if(Human.equals(Constant.BLACK)) {
			return new BlackHuman();
		}else if(Human.equals(Constant.YELLOW)){
			return new YellowHuman();
		}else if(Human.equals(Constant.WHITE)){
			return new WhiteHuman();
		}else {
			return null;
		}
	}

}

public class BlackHuman implements Human {

	@Override
	public void talk() {
		// TODO Auto-generated method stub
		System.out.println("I'm BlackHuman");
	}

}

public interface Human {
	void talk();
}

public class Constant {
	public static final String BLACK= "blackhuman";
	public static final String WHITE= "whitehuman";
	public static final String YELLOW= "yellowhuman";

}

工厂方法模式

定义一个用于创建对象的接口或抽象类，让子类决定实例化哪一个类。

/*
 * 定义抽象类，抽象创造人的方法
 * 不同肤色人创建各自的工厂，工厂中返回创建对象，具体调用方法在此根据需求调用
 * 各自工厂实例化各自人
 * 有其他类型人，只要添加创造工厂类就可以，不用写if区分人的类型
 * **/
public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		AbstractHumanFactory hf;
		//建造工厂，根据工厂创建人类
		hf = new BlackHumanFactory();
		//需要强制转型，
		BlackHuman bh = (BlackHuman) hf.CreateHuman();
		bh.talk();
		
		hf = new WhiteHumanFactory();
		WhiteHuman wh = (WhiteHuman) hf.CreateHuman();
		wh.talk();
	}

}

public class WhiteHumanFactory extends AbstractHumanFactory {
	@Override
	public Human CreateHuman() {
		return new WhiteHuman();
	}
}

public class WhiteHuman implements Human {

	@Override
	public void talk() {
		// TODO Auto-generated method stub
		System.out.println("I'm WhiteHuman");
	}

}

public interface Human {
	void talk();
}

public abstract class AbstractHumanFactory {
	public abstract Human CreateHuman();
}

抽象工厂模式

如果需要一个具体的工厂生产多种产品对象，比如，生产不同肤色的男人和女人，那么就需要用到抽象工厂模式了。

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		AbstractHumanFactory bf ;
		bf = new BlackFactory();
		BlackMan bm = (BlackMan)bf.CreateMan();
		bm.talk();
		
		bf = new BlackFactory();
		BlackWoman bw = (BlackWoman)bf.CreateWoman();
		bw.talk();
		
	}

}

public class BlackFactory extends AbstractHumanFactory{

	@Override
	public Human CreateMan() {
		// TODO Auto-generated method stub
		return new BlackMan();
	}

	@Override
	public Human CreateWoman() {
		// TODO Auto-generated method stub
		return new BlackWoman();
	}
	
}

public class BlackMan extends Man{
	@Override
	public void talk() {
		// TODO Auto-generated method stub
		System.out.println("I'm blackman");
	}
}

public class BlackWoman extends Man {
	@Override
	public void talk() {
		// TODO Auto-generated method stub
		System.out.println("I'm blackwoman");
	}

}

public abstract class Man implements Human {

	@Override
	public void talk() {
		// TODO Auto-generated method stub

	}

}

public abstract class Woman implements Human {

	@Override
	public void talk() {
		// TODO Auto-generated method stub

	}

}

public interface Human {
	void talk();
}

public abstract class AbstractHumanFactory {
	public abstract Human CreateMan();
	public abstract Human CreateWoman();
}