java设计模式之工厂模式

概念

工厂模式的种类：

1.简单工厂模式（Simple Factory） 
2.工厂方法模式（Factory Method） 
3.抽象工厂模式（Abstract Factory） 

按照产品系划分可以分为：
单个产品系：简单工厂模式，工厂方法模式
多个产品系：抽象工厂模式

简单工厂模式：

简单工厂模式只对产品类进行抽象
包括：
一个抽象产品类（或者接口）
多个具体产品类
一个具体工厂类（可以使用静态或者动态Create方法）

工厂方法模式：

工厂方法类对产品和工厂都进行抽象
包括：
一个抽象产品类（或者接口）
多个具体产品类
一个抽象工厂类（可以使用静态或者动态Create方法）
多个具体工厂类但是每个工厂只能生产一种产品

抽象工厂模式：

包括：
多个抽象产品类（或者接口）每个都可以派生出多个产品
多个具体产品类
一个抽象工厂类（可以使用静态或者动态Create方法）
多个具体工厂类，每个工厂类都可以生产多种产品

具体实现

简单工厂模式

abstract class Product{
    public Product(){
    }
}

class ProductA extends Product{
    public ProductA(){
            System.out.println("ProductA");
        }
}
class ProductB extends Product{
    public ProductB(){
        System.out.println("ProductB");
        }

}
class FactorySingle{

    public Product CreateProduct(char ch) {
        Product product;
        switch(ch) {
        case 'A':
            product= new ProductA();
            break;
        case 'B':
            product= new ProductB();
            break;
        default:
            product=new ProductA();
            break;
        }
        return product;
    }
}

public class SingleFactoryMethod {

    public static void main(String[] args) {
        FactorySingle fact=new FactorySingle();
        fact.CreateProduct('A');
        fact.CreateProduct('B');
    }

}

运行结果：

ProductA
ProductB

工厂方法模式

具体实现

abstract class Product{
    }
class ProductA extends Product{
    public ProductA() {
        System.out.println("ProductA");
    }
}
class ProductB extends Product{
    public ProductB() {
    System.out.println("ProductB");
    }
}
abstract class Factory{

    public abstract Product CreateProduct();
}
class FactoryA extends Factory{

    @Override
    public Product CreateProduct() {
        return new ProductA();
    }

}
class FactoryB extends Factory{

    @Override
    public Product CreateProduct() {
        return new ProductB();
    }

}
public class FactoryMethod {

    public static void main(String[] args) {
       Factory factoryA=new FactoryA();
       factoryA.CreateProduct();
       Factory factoryB=new FactoryB();
       factoryB.CreateProduct();
    }

}

输出结果:

ProductA
ProductB

抽象工厂模式：

具体实现：

abstract class ProductAB{
    public ProductAB() {
        System.out.print("ProductAB___");
    }
}
class ProductA extends ProductAB{
    public ProductA() {
        System.out.println("ProductA");
    }
}
class ProductB extends ProductAB{
    public ProductB() {
        System.out.println("ProductB");
    }
}
abstract class ProductCD{
    public ProductCD() {
        System.out.print("ProductCD___");
    }
}
class ProductC extends ProductCD{
    public ProductC() {
        System.out.println("ProductC");
    }
}
class ProductD extends ProductCD{
    public ProductD() {
        System.out.println("ProductD");
    }
}
abstract class Factory{

    public abstract ProductAB CreateProductA();
    public abstract ProductAB CreateProductB();
    public abstract ProductCD CreateProductC();
    public abstract ProductCD CreateProductD();
}
class FactoryALL1 extends Factory{


    public FactoryALL1() {

        System.out.println("From FactoryALL1");
    }
    @Override
    public ProductAB CreateProductA() {
        return new ProductA();
    }

    @Override
    public ProductAB CreateProductB() {
        return new ProductB();
    }

    @Override
    public ProductCD CreateProductC() {
        return new ProductC();
    }

    @Override
    public ProductCD CreateProductD() {
        return new ProductD();
    }

}
class FactoryALL2 extends Factory{

     public FactoryALL2() {

            System.out.println("From FactoryALL2");
        }

    @Override
    public ProductAB CreateProductA() {
        return new ProductA();
    }

    @Override
    public ProductAB CreateProductB() {
        return new ProductB();
    }

    @Override
    public ProductCD CreateProductC() {
        return new ProductC();
    }

    @Override
    public ProductCD CreateProductD() {
        return new ProductD();
    }

}

public class AbstractFactory {

    public static void main(String[] args) {
        Factory fa1=new FactoryALL1();
        fa1.CreateProductA();
        fa1.CreateProductB();
        fa1.CreateProductC();
        fa1.CreateProductD();
        System.out.println("______________________________");
        Factory fa2=new FactoryALL2();
        fa2.CreateProductA();
        fa2.CreateProductB();
        fa2.CreateProductC();
        fa2.CreateProductD();
    }

}

运行结果：

From FactoryALL1
ProductAB___ProductA
ProductAB___ProductB
ProductCD___ProductC
ProductCD___ProductD
______________________________
From FactoryALL2
ProductAB___ProductA
ProductAB___ProductB
ProductCD___ProductC
ProductCD___ProductD