Java工厂模式（简单工厂、工厂方法、抽象工厂）

设计模式复习，代码是最好的说明。

简单工厂模式：

定义：简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例，属于创建型模式。

UML图：（图是用staruml画的，接口有些特别）

代码：

public class FactoryMode {

    public static void main(String[] args) {
        Factory factory=new Factory();
        factory.createProduct(ProductType.A).createMethod();

    }
    
}

enum ProductType{
    A,B
}

interface IProduct{

    void createMethod();

}

class ProductA implements IProduct{

    public void createMethod() {
        System.out.println("A");
    }

}

class ProductB implements IProduct{

    public void createMethod() {
        System.out.println("B");
    }
}

class Factory{

    public IProduct createProduct(ProductType productType){
        switch (productType){
            case A:
                return new ProductA();
            case B:
                return new ProductB();

        }
        return null;
    }
    
}

工厂方法模式：

定义：工厂方法模式定义一个创建对象的接口，让其子类自己去决定实例化哪一个工厂类，使其创建过程延迟到子类执行，属于创建型模式。

UML图：

代码：

public class FactoryMode {

    public static void main(String[] args) {
        IFactory factory = new FactoryA();
        factory.createProduct().createMethod();
        factory = new FactoryB();
        factory.createProduct().createMethod();

    }

}


interface IProduct{

    void createMethod();

}

class ProductA implements IProduct{

    public void createMethod() {
        System.out.println("A");
    }

}

class ProductB implements IProduct{

    public void createMethod() {
        System.out.println("B");
    }
}


interface IFactory{

    IProduct createProduct();

}

class FactoryA implements IFactory{

    public IProduct createProduct() {
        return new ProductA();
    }
}

class FactoryB implements IFactory{

    public IProduct createProduct() {
        return new ProductB();
    }
}

抽象工厂模式：

定义：抽象工厂模式提供一个创建一系列相关或互相依赖对象的接口，而不需指定它们具体的类，属于创建型模式。

UML图：

代码：

public class FactoryMode {

    public static void main(String[] args) {
        IFactory factory = new FactoryForLowCase();
        factory.createProductA().createMethodA();
        factory.createProductB().createMethodB();

        factory = new FactoryForUpCase();
        factory.createProductA().createMethodA();
        factory.createProductB().createMethodB();
    }

}


interface IProductA{

    void createMethodA();

}

interface IProductB{

    void createMethodB();

}

class ProductA implements IProductA{

    public void createMethodA() {
        System.out.println("A");
    }
}

class ProductAL implements IProductA{

    public void createMethodA() {
        System.out.println("a");
    }
}


class ProductB implements IProductB{

    public void createMethodB() {
        System.out.println("B");
    }
}

class ProductBL implements IProductB{

    public void createMethodB() {
        System.out.println("b");
    }
}


interface IFactory{

    IProductA createProductA();

    IProductB createProductB();

}

class FactoryForUpCase implements IFactory{

    public IProductA createProductA() {
        return new ProductA();
    }

    public IProductB createProductB() {
        return new ProductB();
    }
}

class FactoryForLowCase implements IFactory{

    public IProductA createProductA() {
        return new ProductAL();
    }

    public IProductB createProductB() {
        return new ProductBL();
    }
}

这里命名用的不太好，哈哈......

工厂模式的优点很多，在不在此赘述，掌握使用的时机和学会定制最重要。

参考链接：

http://www.runoob.com/design-pattern/factory-pattern.html

http://zyjustin9.iteye.com/blog/2094960

http://www.cnblogs.com/toutou/p/4899388.html

如有错误，欢迎纠正！