Java设计模式之工厂模式(三种)

参考

• http://blog.csdn.net/superbeck/article/details/4446177
• http://blog.csdn.net/dlutbrucezhang/article/details/9413849

1. 简单工厂

理解

• 简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。
• 不修改代码的话，是无法扩展的。

例子

• 产品接口

//产品接口
public interface ProductI {
    public void productName();
}

• 产品实体类

public class ProductA implements ProductI {
    @Override
    public void productName() {
        System.out.println("product A");
    }
}

public class ProductB implements ProductI {
    @Override
    public void productName() {
        System.out.println("product B");
    }
}

• 工厂类

// 简单工厂模式
public class Factory {
    public ProductI create(String productName) {
        switch (productName) {
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            default:
                return null;
        }
    }
}

• 测试类

public class Client {
    public static void main(String[] args) {
        Factory factory = new Factory();
        ProductI productA = factory.create("A");
        productA.productName();
        //
        ProductI productB = factory.create("B");
        productB.productName();
    }
}

• 输出

product A
product B

<br />

2. 工厂方法

理解

• 工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。
• 在同一等级结构中，支持增加任意产品。

例子

• 产品接口和产品实体类和简单工厂都一样。

• 工厂接口

public interface FactoryI {
    // 工厂的目的是为了生产产品
    public ProductI create();
}

• 工厂实体类

public class FactoryA implements FactoryI {
    @Override
    public ProductI create() {
        return new ProductA();
    }
}

public class FactoryB implements FactoryI {
    @Override
    public ProductI create() {
        return new ProductB();
    }
}

• 测试类

// 工厂方法模式
public class Client {
    public static void main(String[] args) {
        FactoryI factoryA = new FactoryA();
        ProductI productA = factoryA.create();
        productA.productName();
        //
        FactoryI factoryB = new FactoryB();
        ProductI productB = factoryB.create();
        productB.productName();
    }
}

• 输出

product A
product B

3. 抽象工厂

理解

• 抽象工厂是应对产品族概念的。比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。
• 应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。
• 和工厂方法的区别是，抽象工厂往往有多种方法，可以生产多种产品，即产品簇。

例子

• 产品接口

//产品接口 --吃的
public interface ProductBI {
    public void productName();
}

//产品接口  -- 喝的
public interface ProductAI {
    public void productName();
}

• 产品实体类 --可乐

public class ProductA1 implements ProductAI {
    @Override  //
    public void productName() {
        System.out.println("可乐");
    }
}

• 产品实体类 --矿泉水

public class ProductA2 implements ProductAI {
    @Override  //
    public void productName() {
        System.out.println("矿泉水");
    }
}

• 产品实体类  --面条

public class ProductB1 implements ProductBI {
    @Override  //
    public void productName() {
        System.out.println("面条");
    }
}

• 产品实体类  -- 米饭

public class ProductB2 implements ProductBI {
    @Override  //
    public void productName() {
        System.out.println("米饭");
    }
}

• 抽象工厂类    --生产一种吃的一种喝的

// 抽像工厂模式
public interface AbstractFactory {
    public ProductAI createProductA();
    public ProductBI createProductB();
}

• 工厂实体类

public class Factory1 implements AbstractFactory {
    @Override // 可乐，面条
    public ProductAI createProductA() {
        return new ProductA1();
    }

    @Override
    public ProductBI createProductB() {
        return new ProductB1();
    }
}

public class Factory2 implements AbstractFactory {
    @Override  //米饭，矿泉水
    public ProductAI createProductA() {
        return new ProductA2();
    }

    @Override
    public ProductBI createProductB() {
        return new ProductB2();
    }
}