设计模式--工厂

1. 简单工厂

1.1 核心工厂类

public class FoodFactory {
    public static Food getFood(String foodType) {
        switch (foodType) {
            case "apple":
                return new AppleFood();
            case "banana":
                return new BananaFood();
            // 新增菠萝
            case "pineapple":
                return new PineappleFood();
        }
        return null;
    }
}

1.2 核心接口

public interface Food {

    void eat(String personName);

    void remark(String personName, String feel);
}

1.3 待创建对象的类

public class AppleFood implements Food {
    @Override
    public void eat(String personName) {
        System.out.println(personName + "吃了一个苹果");
    }

    @Override
    public void remark(String personName, String feel) {
        System.out.println(personName + "评价苹果:" + feel);
    }
}


public class BananaFood implements Food {
    @Override
    public void eat(String personName) {
        System.out.println(personName + "吃了一个香蕉");
    }

    @Override
    public void remark(String personName, String feel) {
        System.out.println(personName + "评价香蕉:" + feel);
    }
}

public class PineappleFood implements Food {
    @Override
    public void eat(String personName) {
        System.out.println(personName + "吃了一个菠萝");
    }

    @Override
    public void remark(String personName, String feel) {
        System.out.println(personName + "评价菠萝:" + feel);
    }
}

1.4 使用

public class EatTest {
    public static void main(String[] args) {
        // 调用方法
        String eatType = "banana";

        String personName = "张三";
        Food food = FoodFactory.getFood(eatType);
        food.eat(personName);
        food.remark(personName,"还不错");


        // 增加一个类型的修改: 新增一个菠萝类继承food接口,并在FoodFactory中的判断中添加菠萝的类型
        // 简单工厂的优势:创建简单,  (解耦,对象创建和使用分开)
        // 缺点:新增一个类型时需要修改if判断,违背了设计模式的开闭原则(对新增开放,对修改关闭的原则)
        // 一个工厂集合了全部对象的创建,如果工厂不能用了,所有对象都收到影响
    }
}

2. 工厂方法模式

2.1 抽象工厂类

public abstract class AbstractFactory {
    public abstract Food getFood();
}

2.2 核心工厂类

public class AppleFactory extends AbstractFactory {
    @Override
    public Food getFood() {
        return new AppleFood();
    }
}

public class BananaFactory extends AbstractFactory {
    @Override
    public Food getFood() {
        return new BananaFood();
    }
}

public class PineappleFactory extends AbstractFactory {
    @Override
    public Food getFood() {
        return new PineappleFood();
    }
}

2.3 核心接口

public interface Food {

    void eat(String personName);

    void remark(String personName, String feel);
}

2.4 待创建对象的类

public class AppleFood implements Food {
    @Override
    public void eat(String personName) {
        System.out.println(personName + "吃了一个苹果");
    }

    @Override
    public void remark(String personName, String feel) {
        System.out.println(personName + "评价苹果:" + feel);
    }
}


public class BananaFood implements Food {
    @Override
    public void eat(String personName) {
        System.out.println(personName + "吃了一个香蕉");
    }

    @Override
    public void remark(String personName, String feel) {
        System.out.println(personName + "评价香蕉:" + feel);
    }
}

public class PineappleFood implements Food {
    @Override
    public void eat(String personName) {
        System.out.println(personName + "吃了一个菠萝");
    }

    @Override
    public void remark(String personName, String feel) {
        System.out.println(personName + "评价菠萝:" + feel);
    }
}

2.5 使用

public class EatTest {
    public static void main(String[] args) {
        // 调用方法
        String eatType = "banana";

        String personName = "张三";
        BananaFactory bananaFactory = new BananaFactory();
        Food food = bananaFactory.getFood();
        food.eat(personName);
        food.remark(personName,"还不错");

        // 优点:满足了开合原则，

        // 缺点: 没新增一个类型需要同步增加一个工厂类,类太多了,系统维护和类加载都会有影响
    }
}

3. 抽象工厂模式

3.1 抽象工厂类

public abstract class AbstractFactory {
    public abstract Food getFood();

    public abstract Color getColor();
}

3.1 核心工厂类

public class AppleFactory extends AbstractFactory {
    @Override
    public Food getFood() {
        return new AppleFood();
    }

    @Override
    public Color getColor() {
        return new AppleColor();
    }
}

public class BananaFactory extends AbstractFactory {
    @Override
    public Food getFood() {
        return new BananaFood();
    }

    @Override
    public Color getColor() {
        return new BananaColor();
    }
}

public class PineappleFactory extends AbstractFactory {
    @Override
    public Food getFood() {
        return new PineappleFood();
    }

    @Override
    public Color getColor() {
        return new PineappleColor();
    }
}

3.2 核心接口

public interface Food {

    void eat(String personName);

    void remark(String personName, String feel);
}

public interface Color {
    void getThisColor();
}

3.3 待创建对象的类

public class AppleFood implements Food {
    @Override
    public void eat(String personName) {
        System.out.println(personName + "吃了一个苹果");
    }

    @Override
    public void remark(String personName, String feel) {
        System.out.println(personName + "评价苹果:" + feel);
    }
}

public class AppleColor implements Color {
    @Override
    public void getThisColor() {
        System.out.println("红红的苹果");
    }
}


public class BananaFood implements Food {
    @Override
    public void eat(String personName) {
        System.out.println(personName + "吃了一个香蕉");
    }

    @Override
    public void remark(String personName, String feel) {
        System.out.println(personName + "评价香蕉:" + feel);
    }
}

public class BananaColor implements Color {
    @Override
    public void getThisColor() {
        System.out.println("金黄的香蕉");
    }
}

// 菠萝省略...

3.4 使用

public class EatTest {
    public static void main(String[] args) {
        // 调用方法
        String eatType = "banana";

        String personName = "张三";
//        Food food = FoodFactory.getFood(eatType);
//        food.eat(personName);
//        food.remark(personName,"还不错");
        BananaFactory bananaFactory = new BananaFactory();
        Food food = bananaFactory.getFood();
        food.eat(personName);
        food.remark(personName,"还不错");

        bananaFactory.getColor().getThisColor();

        // 和工厂相比增增加了产品族,也就是一个产品有多个属性,工厂中一个工厂类只会创建一种对象,而在抽象工厂中,有不同的方法创建对应的对象

        // 优点:满足了开合原则，对于不同产品族的需求可以方便的增加产品,扩展性更强了,满足单一职责原则,每个工厂类负责创建对应的产品

        // 缺点: 如果需要添加新产品需要在抽象接口中添加,这样每个实现了接口的产品都需要修改,违反了开闭原则 ;可读性不高

    }
}

参考资料:
本文将着眼于工厂模式，从简单工厂模式、工厂方法模式和抽象工厂模式出发
设计模式之—工厂模式、建造者模式