工厂相关模式-优快云博客

本文链接：https://blog.youkuaiyun.com/zhou199211/article/details/70332190

工厂创建方法

简单工厂方法

所谓简单工厂指的是某一单一工厂生成指定一类具有同样性质的实例
简单工厂示例图

代码如下


/**这是所有食物类的父接口*/
public interface Food {

/**
 * 描述自己
 */
    void introduce();
}

/**苹果具体实现类*/
public class Apple implements Food {

    @Override
    public void introduce() {
        System.out.println("我是一个苹果");
    }
}

/**香蕉具体实现类*/
public class Banana implements Food {

    @Override
    public void introduce() {
        System.out.println("我是一个香蕉");
    }
}

/**简单工厂类*/
public class Factory {

    /**
     * 生产Food方法
     * @param foodType
     */
    public static Food createFood(String foodType) {
        if (foodType == null || foodType.trim().equals("")) {
            throw new RuntimeException("参数错误");
        }   
        if (foodType.equals("苹果")) {
            return new Apple();
        } else if (foodType.equals("香蕉")) {
            return new Banana();
        } else {
            throw new RuntimeException("没有找打指定的类型");
        }
    }
}

/**这是一个测试类*/
public class Test {

    public static void main(String[] args) {
        Food apple = Factory.createFood("苹果");
        Food banana = Factory.createFood("香蕉");
        apple.introduce();
        banana.introduce();
        if (apple instanceof Apple) {
            System.out.println("这是一个苹果");
        }

        if (banana instanceof Banana) {
            System.out.println("这是一个香蕉");
        }
    }
}

工厂方法模式

工厂方法模式是类的创建模式，又叫做虚拟构造子(VirtualConstructor)模式或者多态性工厂（PolymorphicFactory）模式。工厂方法模式的用意是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。 –《Java与模式》

简单讲讲工厂方法模式在使用时的场景：由于简单工厂中的工厂功能复杂化，所谓复杂化就是越来越来的不同种类的食物需要工厂来生成，但是而每一类不同的食物在所具有的功能上有具体的不同。

工厂方法示例图

代码如下


/**食物类*/
public interface Food {

    /**
     * 描述自己
     */
    void introduce();
}

/**大米类*/
public class Rice implements Food {

    @Override
    public void introduce() {
        System.out.println("我是大米");
    }

}

/**面条类*/
public class Noodle implements Food {

    @Override
    public void introduce() {
        System.out.println("我是面条");
    }

}

/**苹果类*/
public class Apple implements Food {

    @Override
    public void introduce() {
        System.out.println("我是一个苹果");
    }

}

/**香蕉类*/
public class Banana implements Food {

    @Override
    public void introduce() {
        System.out.println("我是一个香蕉");
    }

}

/**工厂接口*/
public interface Factory {

    /**
     * 生产Food方法
     * @param foodType
     */
    public Food createFood(String foodType);
}

/**水果工厂*/
public class FruitFactory implements Factory {

    @Override
    public Food createFood(String foodType) {
        if ("苹果".equals(foodType)) {
            return new Apple();
        } else if ("香蕉".equals(foodType)) {
            return new Banana();
        } else {
            throw new RuntimeException("没有找到指定的类型");
        }
    }

}

/**主食工厂类*/
public class StapleFoodFactory implements Factory {

    @Override
    public Food createFood(String foodType) {
        if ("大米".equals(foodType)) {
            return new Rice();
        } else if ("面条".equals(foodType)) {
            return new Noodle();
        } else {
            throw new RuntimeException("没有找到指定的类型");
        }
    }

}

/**测试类*/
public class Test {

    public static void main(String[] args) {
        Factory fruitFactory = new FruitFactory();
        Factory stapleFoodFactory = new StapleFoodFactory();
        Food apple = fruitFactory.createFood("苹果");
        Food banana = fruitFactory.createFood("香蕉");
        Food rice = stapleFoodFactory.createFood("大米");
        Food noodle = stapleFoodFactory.createFood("面条");
        apple.introduce();
        banana.introduce();
        rice.introduce();
        noodle.introduce();
    }
}

抽象工厂方法

抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。在抽象工厂模式中，有一个产品族的概念：所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品就组成一个产品族；而工厂方法提供的一系列产品称为一个等级结构。我们依然拿生产汽车的例子来说明他们之间的区别
——23种设计模式（3）：抽象工厂模式

抽象工厂示例图

这里可以对工厂方法进行简单修改


/**抽象工厂类*/
public interface AbstractFactory {

    /**创建食物类*/
    Food createFood(String foodType);

    /**创建食物工具*/
    FoodTool createFoodTool(String foodType);
}

/**抽象工厂实现类*/
public class AbstractFactoryImpl implements AbstractFactory {

    @Override
    public Food createFood(String foodType) {
        if ("大米".equals(foodType)) {
            return new Rice();
        } else {
            throw new RuntimeException("参数错误");
        }
    }

    @Override
    public FoodTool createFoodTool(String foodType) {
        if ("刀".equals(foodType)) {
            return new Knife();
        } else {
            throw new RuntimeException("参数错误");
        }
    }
}

/**抽象工厂具体实现类1*/
public class AbstractFactoryImpl1 implements AbstractFactory {

    @Override
    public Food createFood(String foodType) {
        if ("苹果".equals(foodType)) {
            return new Apple();
        } else {
            throw new RuntimeException();
        }
    }

    @Override
    public FoodTool createFoodTool(String foodType) {
        if ("叉子".equals(foodType)) {
            return new Fork();
        } else {
            throw new RuntimeException();
        }
    }
}


/**食物类接口*/
public interface Food {

    /**
     * 描述自己
     */
    void introduce();
}

/**食物工具接口*/
public interface FoodTool {

    void eat();
}

/**大米具体食物实现类*/
public class Rice implements Food {

    @Override
    public void introduce() {
        System.out.println("我是大米");
    }
}

/**苹果具体食物实现类*/
public class Apple implements Food {

    @Override
    public void introduce() {
        System.out.println("我是一个苹果");
    }
}

/**刀具体食物工具实现类*/
public class Knife implements FoodTool {

    @Override
    public void eat() {
        System.out.println("吃---------------");
    }
}

/**叉子具体食物工具实现类*/
public class Fork implements FoodTool {

    @Override
    public void eat() {
        System.out.println("叉子");
    }
}

/**测试类*/
public class Test {

    public static void main(String[] args) {

        AbstractFactory abstractFactory = new AbstractFactoryImpl();
        abstractFactory.createFood("大米").introduce();
        abstractFactory.createFoodTool("刀").eat();
        AbstractFactory abstractFactory1 = new AbstractFactoryImpl1();
        abstractFactory1.createFood("苹果").introduce();
        abstractFactory1.createFoodTool("叉子").eat();
    }
}