工厂模式

简单工厂模式、工厂方法模式、抽象工厂模式

简单工厂模式

简单工厂模式不是一种设计模式，而更像一种编程习惯。

简单工厂包含如下角色：

1. 具体工厂
2. 抽象产品
3. 具体产品

//抽象产品
abstract class Coffee {
    abstract String getName();
}

//具体产品1
class AmericanCoffee extends Coffee {
    String getName(){
        System.out.println("AmericanCoffee");
        return "AmericanCoffee";
    }
}
//具体产品2
class LatteCoffee extends Coffee {
    String getName(){
        System.out.println("LatteCoffee");
        return "LatteCoffee";
    }
}
//具体工厂
class SimpleCoffeeFactory{
    public Coffee createCoffee(String type){
        Coffee coffee = null;
        if(type.equals("american")) coffee = new AmericanCoffee();
        else if(type.equals("latte")) coffee = new LatteCoffee();
        return coffee;
    }
}

SimpleCoffeeFactory负责生产咖啡，只需要告知他需要的种类即可，由工厂自动生产相应的咖啡。但如果后期新增加咖啡种类，仍然需要修改工厂类，违反开闭原则。

工厂方法模式

定义一个用于创建对象的接口（抽象工厂），让子类决定实例化哪个产品类对象。使得一个产品类的实例化延迟到其工厂的子类。

工厂方法模式包含以下角色：

1. 抽象工厂
2. 具体工厂
3. 抽象产品
4. 具体产品

abstract class Coffee {
    abstract String getName();
}

class AmericanCoffee extends Coffee {
    String getName(){
        System.out.println("AmericanCoffee");
        return "AmericanCoffee";
    }
}

class LatteCoffee extends Coffee {
    String getName(){
        System.out.println("LatteCoffee");
        return "LatteCoffee";
    }
}

interface CoffeeFactory{
    Coffee createCoffee();
}
class AmericanCoffeeFactory implements CoffeeFactory{
    public Coffee createCoffee(){
        return new AmericanCoffee();
    }
}

class LatteCoffeeFactory implements CoffeeFactory{
    public Coffee createCoffee(){
        return new LatteCoffee();
    }
}

public class FactoryMethod {
    public static void main(String[] args) {
        CoffeeFactory cofferFactory = new AmericanCoffeeFactory();
        cofferFactory.createCoffee();
    }
}

1. 只需要知道工厂名就可以得到产品，无须关心具体生产过程。
2. 系统新增加产品时仅需要增加具体的产品类和具体工厂类即可。（但这也增加了系统的复杂度）

抽象工厂模式

抽象工厂是工厂方法模式的升级，一个工厂可以生产多个等级的产品。

public class abstractFactory {

}
abstract class Coffee {
    abstract String getCoffeeName();
}
class AmericanCoffee extends Coffee {
    String getCoffeeName(){
        System.out.println("AmericanCoffee");
        return "AmericanCoffee";
    }
}

class LatteCoffee extends Coffee {
    String getCoffeeName(){
        System.out.println("LatteCoffee");
        return "LatteCoffee";
    }
}
abstract class Dessert{
    abstract String getDessertName();
}

class AmericanDessert extends Dessert{
    @Override
    String getDessertName() {
        return "AmericanDessert";
    }
}

class LatteDessert extends Dessert{

    @Override
    String getDessertName() {
        return "LatteDessert";
    }
}

interface DessertFactory{
    Coffee createCoffee();
    Dessert createDessert();
}

class AmericanDessertFactory implements DessertFactory{

    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }

    @Override
    public Dessert createDessert() {
        return new AmericanDessert();
    }
}

class LatteDessertFactory implements DessertFactory{
    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
    @Override
    public Dessert createDessert() {
        return new LatteDessert();
    }
}