JAVA设计模式(工厂模式)

（一）简单工厂。它的缺点很明显，当需要再添加一个WhiteHuman类时，需要在工厂类中修改，则代码的耦合性很高。

//创建需要用工厂new的class
public interface Human {
}

public class BlackHuman implements Human {
public BlackHuman() {
System.out.println("BlackHuman.BlackHuman()");
}
}

public class YellowHuman implements Human{
public YellowHuman(){
System.out.println("YellowHuman.YellowHuman()");
}
}

//创建工厂
public class HumanFactory {

public Human create(Integer type) {

switch (type) {
case 1:
return new YellowHuman();
case 2:
return new BlackHuman();
default:
break;

}
return null;
}
}

//测试
public class SimplTest {

public static void main(String[] args) {
HumanFactory factory = new HumanFactory();
Human yellow = factory.create(1);
Human black = factory.create(2);
}
}

（二）工厂方法。所有的对象都是在同一个等级，即所有的对象的类都是实现同一个接口或者继承同一个类。然而，每个工厂只能生产一个类型的对象。那么，当需要同等级，不同类型的对象的时候，就需要创建不同的工厂类，来创建单一的对象。当需要再添加一个WhiteHuman的时候，只需要实现Human，并且新建一个工厂，实现HumanFactory，对以前的代码没任何修改，降低了代码之间的耦合度。

public interface HumanFactory {

public Human create();
}

public class BlackManFactory implements HumanFactory {

@Override
public Human create() {
return new BlackHuman();
}
}

public class YellowManFactory implements HumanFactory {

@Override
public Human create() {
return new YellowHuman();
}
}

public class MethodTest {
public static void main(String[] args) {
YelloManFactory yellowManFactory = new YellowManFactory();
BlackManFactory blackManFactory = new BlackManFactory();
Human yellow = yellowManFactory.create();
Human black = blackManFactory.create();
}
}

（三）抽象工厂。它主要是针对不同对象等级的工厂，当BlcakHuman，YellowHuman下还有男性和女性之分的时候，如果用工厂方法来创建，那么人类，工厂之间的逻辑关系就会比较混乱。仅仅创建一个女性的工厂，就需要一个黑种人，黄种人的工厂来创建，这样代码很臃肿，所以用抽象工厂方法来创建。一个抽象工厂可以可以创建多个对象。当需要添加一个WhiteHuman时，需要对所有的工厂类进行添加，代码间的耦合度增加了。所以在用抽象工厂之前，一定要确立需要创建的对象之间的关系，否则修改的时候会很麻烦。

//需要创建的对象之间的关系和类
public class BlackFemale extends BlackHuman{
public BlackFemale(){
System.out.println("BlackFemale.BlackFemale()");
}
}

public class BlackMale extends BlackHuman{
public BlackMale(){
System.out.println("BlackMale.BlackMale()");
}
}

public class YellowFemale extends YellowHuman {
public YellowFemale(){
System.out.println("YellowFemale.YellowFemale()");
}
}

public class YellowMale extends YellowHuman{
public YellowMale(){
System.out.println("YellowMale.YellowMale()");
}
}

//工厂
public interface HumanFactory {
public Human createYellow();

public Human createBlack();
}

public class FemaleFactory implements HumanFactory{
@Override
public Human createYellow() {
return new YellowFemale();
}

@Override
public Human createBlack() {
return new BlackFemale();
}
}

public class MaleFactory implements HumanFactory{
@Override
public Human createYellow() {

return new YellowManle();
}

@Override
public Human createBlack() {
return new BlackMale();
}
}

public class AbstractTest {
public static void main(String[] args) {
FemaleFactory femaleFactory = new FemaleFactory();
MaleFactory maleFactory = new MaleFactory();
femaleFactory.createBlack();
femaleFactory.createYellow();
maleFactory.createBlack();
}
}