設計模式-工廠模式

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();