设计模式-工厂模式

1、工厂模式-接口

抽象接口，添加实现类需要执行的方法。

public interface Human {
    public void getColor();
    public void talk();
}

public class BlackHuman implements Human {
    @Override
    public void getColor() {
        System.out.println("黑人");
    }

    @Override
    public void talk() {
        System.out.println("黑人说话");
    }
}

public class WhiteHuman implements Human {
    @Override
    public void getColor() {
        System.out.println("白人");

    }

    @Override
    public void talk() {
        System.out.println("白人说话");
    }
}

抽象工厂，子类继承

public abstract class AbstractHumanFactory {
    public abstract <T extends Human> T create(Class<T> C);
}

public class HumanFactory extends AbstractHumanFactory {
    @Override
    public <T extends Human> T create(Class<T> C) {
        Human human = null;
        try {
            human = (Human)Class.forName(C.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("人种生成错误！");
        }
        return (T)human;
    }
}

使用方法：

//工厂模式-接口
AbstractHumanFactory factory = new HumanFactory();
YellowHuman yellowHuman = factory.create(YellowHuman.class);
yellowHuman.talk();

延迟加载工厂：

1、一个对象被消费完毕后，并不立刻释放，工厂类
保持其初始状态，等待再次被使用。延迟初始化是工厂方法模式的一个扩展应用
2、代码还比较简单，通过定义一个Map容器，容纳所有产生的对象，如果在Map容器中已 经有的对象，则直接取出返回；如果没有，则根据需要的类型产生一个对象并放入到Map容器中，以方便下次调用
3、延迟加载框架是可以扩展的，例如限制某一个产品类的最大实例化数量，可以通过判断 Map中已有的对象数量来实现，这样的处理是非常有意义的，例如JDBC连接数据库，都会 要求设置一个MaxConnections最大连接数量，该数量就是内存中最大实例化的数量
4、延迟加载还可以用在对象初始化比较复杂的情况下，例如硬件访问，涉及多方面的交互，则可以通过延迟加载降低对象的产生和销毁带来的复杂性。

public class HumanFactory2 {
    private static final HashMap<String, Human> huMap = new HashMap<>();

    public static synchronized <T extends Human> T createHuman(Class<T> C) {
        Human human = null;
        String type = C.getSimpleName().toString();
        if (huMap.containsKey(type)) {
            human = (T) huMap.get(type);
        } else {
            if (type.equals(YellowHuman.class.getSimpleName().toString())) {
                human = (T) new YellowHuman();
            } else if (type.equals(WhiteHuman.class.getSimpleName().toString())) {
                human = (T) new WhiteHuman();
            } else {
                human = (T) new BlackHuman();
            }
            huMap.put(type, human);
        }
        return (T) human;
    }
}

使用：

//延迟工厂模式
BlackHuman human = HumanFactory2.createHuman(BlackHuman.class);
human.getColor();

2、工厂模式-抽象类

使用抽象类，你可以在父类中写子类都会执行的方法，有好处，不多说。子类只负责写特有的逻辑。

public abstract class Human {
    //子类都会执行的共同方法
    public void eat() {

    }
    public abstract void study();
}

public class WhiteHuman extends Human {
    @Override
    public void study() {
        System.out.println("白人学习");
    }
}

public class YellowHuman extends Human {
    @Override
    public void study() {
        System.out.println("黄人学习");
    }
}

public class BlackHuman extends Human {
    @Override
    public void study() {
        System.out.println("黑人学习");
    }
}

抽象工厂&继承类：

public abstract class AbsHumanFactory {
    /**
     * 创建一个产品对象，其输入参数类型可以自行设置
     * 通常为String、Enum、Class等，当然也可以为空
     **/
    public abstract <T extends Human> T createHuman(Class<T> c);
}

public class ConcreteCreator extends AbsHumanFactory {
    @Override
    public <T extends Human> T createHuman(Class<T> c) {
        Human human = null;
        try {
            human = (Human) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            // TODO: 2018/4/20 异常处理
        }
        return (T) human;
    }
}

使用：

//工厂模式-抽象类
AbsHumanFactory absHumanFactory = new ConcreteCreator();
WhiteHuman whiteHuman = absHumanFactory.createHuman(WhiteHuman.class);
whiteHuman.study();

3、抽象工厂模式。一个接口，多个抽象类，然后是N个实现类

public interface Human {
    public void getColor();

    public void talk();

    public void getSex();
}

public abstract class AbsBlackHuman implements Human {
    @Override
    public void getColor() {
        System.out.println("黑人");
    }

    @Override
    public void talk() {
        System.out.println("黑人讲话");
    }
    
}

public abstract class AbsWhiteHuman implements Human {
    @Override
    public void getColor() {
        System.out.println("白人");
    }

    @Override
    public void talk() {
        System.out.println("白人讲话");
    }
}

public abstract class AbsYellowHuman implements Human {
    @Override
    public void getColor() {
        System.out.println("黄人");
    }

    @Override
    public void talk() {
        System.out.println("黄人讲话");
    }
}

public class FemaleBlackHuman extends AbsBlackHuman {
    @Override
    public void getSex() {
        System.out.println("黑色女人");
    }
}

public class FemaleWhiteHuman extends AbsWhiteHuman {
    @Override
    public void getSex() {
        System.out.println("白色女人");
    }
}

public class FemaleYellowHuman extends AbsYellowHuman {
    @Override
    public void getSex() {
        System.out.println("黄色女人");
    }
}

public class MaleBlackHuman extends AbsBlackHuman {
    @Override
    public void getSex() {
        System.out.println("黑色男人");
    }
}

public class MaleWhiteHuman extends AbsWhiteHuman {
    @Override
    public void getSex() {
        System.out.println("白色男人");
    }
}

public class MaleYellowHuman extends AbsYellowHuman {
    @Override
    public void getSex() {
        System.out.println("黄色男人");
    }
}

工厂：

public interface IHumanFactory {
    public Human createBlackHuman();

    public Human createWhiteHuman();

    public Human createYellowHuman();
}

public class FemaleFactoryI implements IHumanFactory {
    @Override
    public Human createBlackHuman() {
        return new FemaleBlackHuman();
    }

    @Override
    public Human createWhiteHuman() {
        return new FemaleWhiteHuman();
    }

    @Override
    public Human createYellowHuman() {
        return new FemaleYellowHuman();
    }
}

public class MaleFactoryI implements IHumanFactory {
    @Override
    public Human createBlackHuman() {
        return new MaleBlackHuman();
    }

    @Override
    public Human createWhiteHuman() {
        return new MaleWhiteHuman();
    }

    @Override
    public Human createYellowHuman() {
        return new MaleYellowHuman();
    }
}

使用： 

//抽象工厂模式
IHumanFactory iHumanFactory = new FemaleFactoryI();//女性
Human iHumanFactoryBlackHuman = iHumanFactory.createBlackHuman();//黑色
iHumanFactoryBlackHuman.getColor();
iHumanFactoryBlackHuman.getSex();