Java设计模式之工厂模式

工厂模式（简单工厂模式）

• 定义：简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。
• 实例：有披萨，汉堡包，鸡腿三种食物，将创建的具体食物对象封装到一个工厂类中，由这个类来封装实例化对象。
• 类图
  
• 代码

/**
* 抽象产品(食物)
*/
interface Food {
    /**
* 吃食物的方法
*/
    void eat();
}

/**
* 具体产品:汉堡包
*/
class Hambuger implements Food {
    @Override
    public void eat() {
        System.out.println("Eating Hambuger...");
    }
}

/**
* 具体产品:炸薯条
*/
class FrenchFries implements Food {
    @Override
    public void eat() {
        System.out.println("Eating FrenchFries...");
    }
}

/**
* 具体产品:鸡腿
*/
class Drumstick implements Food {
    @Override
    public void eat() {
        System.out.println("Eating Drumstick...");
    }
}

/**
* 食物工厂
*/
class FoodFactory {
    /**
* 根据需求制造食品
*
* @param n
* @return
*/
    public static Food getFood(int n) {
        Food food = null;
        switch (n) {
            case 1:
                food = new Hambuger();
                break;
            case 2:
                food = new FrenchFries();
                break;
            case 3:
                food = new Drumstick();
                break;
        }

/**
* 测试简单工厂
*/
public class TestSimpleFactory {
    public static void main(String[] args) {
        Food f = FoodFactory.getFood(2);
        f.eat();
        f = FoodFactory.getFood(1);
        f.eat();
    }
}

工厂模式（工厂方法模式）

• 定义：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。
• 和简单工厂模式对比：和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂。
• 类图：
  
• 代码：

/**
* 抽象产品(食物)
*/
public interface Food {
    /**
* 吃食物的方法
*/
    void eat();
}

/**
* 具体产品:炸薯条
*/
class FrenchFries implements Food {
    @Override
    public void eat() {
        System.out.println("Eating FrenchFries...");
    }
}

/**
* 具体产品:汉堡包
*/
public class Hambuger implements Food {
    @Override
    public void eat() {
        System.out.println("Eating Hambuger...");
    }
}

/**
* 具体产品:鸡腿
*/
class Drumstick implements Food {
    @Override
    public void eat() {
        System.out.println("Eating Drumstick...");
    }
}

/**
* 抽象食物工厂
*/
public interface FoodFactory {
    Food getFood();
}

/**
* 生产薯条的工厂
*/
public class FrenchFriesFactory implements FoodFactory {
    @Override
    public Food getFood() {
        return new FrenchFries();
    }
}

/**
* 生产汉堡包的工厂
*/
public class HambugerFactory implements FoodFactory {
    @Override
    public Food getFood() {
        return new Hambuger();
    }
}

/**
* 生产鸡腿的工厂
*/
public class DrumstickFactory implements FoodFactory {
    @Override
    public Food getFood() {
        return new Drumstick();
    }
}

/**
* 测试工厂方法模式
*/
public class TestFactoryMethod {
    public static void main(String[] args) {
        FoodFactory foodFactory = new HambugerFactory();
        foodFactory.getFood().eat();
        foodFactory = new DrumstickFactory();
        foodFactory.getFood().eat();
    }
}

抽象工厂模式

• 定义：抽象工厂模式通过在AbstarctFactory中增加创建产品的接口，并在具体子工厂中实现新加产品的创建。
• 类图：
  
• 代码：

/**
* 食物接口
*/
public interface Food {
    void eat();
}

/**
* 具体食物类：炸薯条
*/
public class FrenchFries implements Food {
    @Override
    public void eat() {
        System.out.println("Eating FrenchFries...");
    }
}

/**
* 具体食物类：汉堡包
*/
public class Hambuger implements Food {
    @Override
    public void eat() {
        System.out.println("Eating Hambuger...");
    }
}

/**
* 饮料接口
*/
public interface Drink {
    void drink();
}

/**
* 具体饮料类：咖啡
*/
public class Coffee implements Drink {
    @Override
    public void drink() {
        System.out.println("Drinking Coffee...");
    }
}

/**
* 具体饮料类：可乐
*/
public class Coke implements Drink {
    @Override
    public void drink() {
        System.out.println("Drinking Coke...");
    }
}

/**
* 抽象工厂
*/
public interface Factory {

    Food getFood();

    Drink getDrink();
}

/**
* 具体工厂:金拱门
*/
public class GoldenArchFactory implements Factory {
    @Override
    public Food getFood() {
        System.out.println("金拱门店制作...");
        return new Hambuger();
    }
    @Override
    public Drink getDrink() {
        System.out.println("金拱门店制作...");
        return new Coffee();
    }
}

/**
* 具体工厂：KFC
*/
public class KFCFactory implements Factory {

    @Override
    public Food getFood() {
        System.out.println("KFC店制作...");
        return new Hambuger();
    }

    @Override
    public Drink getDrink() {
        System.out.println("KFC店制作...");
        return new Coffee();
    }
}

/**
* 测试抽象工厂
*/
class TestAbstractFactory {
    public static void main(String[] args) {
        Factory factory = new KFCFactory();
        factory.getFood().eat();
        factory.getDrink().drink();
        factory = new GoldenArchFactory();
        factory.getFood().eat();
        factory.getDrink().drink();
    }
}