设计模式---工厂模式

　　本篇来整理工厂模式，工厂模式属于创建模式，工厂模式中又分为简单工厂模式、工厂方法模式、抽象工厂模式。

一、简单工厂模式

1、定义

　　定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。

2、UML

　　

 

 3、案例

 　　新建Product接口

public interface Product {
}

　　具体的实现类ConcreteProductA、ConcreteProductB

public class ConcreteProductA implements Product {
    public ConcreteProductA() {
        System.out.println("ConcreteProductA被创建");
    }
}

public class ConcreteProductB implements Product {
    public ConcreteProductB() {
        System.out.println("ConcreteProductB被创建");
    }
}

　　工厂类Factory

public class Factory {

    public static Product factoryMethod(String type){
        Product product = null;
        if ("A".equals(type)){
            product = new ConcreteProductA();
        }else if ("B".equals(type)){
            product = new ConcreteProductB();
        }
        return product;
    }
}

　　使用Client类测试下效果

public class Client {
    public static void main(String[] args) {
        Product productA = Factory.factoryMethod("A");
        Product productB = Factory.factoryMethod("B");
    }
}

 

 　　以上就是简单工厂模式，但是如果我们要新增产品C就要去改Factory类，非常的不方便，那么接下来的工厂方法模式就能解决这个问题。

 

二、工厂方法模式

1、定义

　　工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

2、UML

 

 3、案例

　　相比简单工厂模式，上图中的Product是一样的，变的是工厂类，新增工厂类Factory接口

public interface Factory {
    Product factoryMethod();
}

　　创建产品A的具体工厂类

public class ConcreteFactoryA implements Factory {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

　　创建产品B的具体工厂类

public class ConcreteFactoryB implements Factory {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}

　　使用测试类Client测试下效果

public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactoryA();
        factory.factoryMethod();
    }
}

 　　可能你会说，创建一个对象这么麻烦，有什么好处呢？下面给个实际案例体会。

4、实践

　　在jdbc连接数据库时，就用到了工厂方法模式

 

 　　Driver接口中要创建Connection对象，所以MysqlDriver负责创建MysqlConnection，OracleDriver负责创建OracleConnection，通过工厂方法模式互不影响。

 

三、抽象工厂模式

1、定义

　　抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确具体类。

2、UML

 

3、案例

　　创建产品类A

public interface ProductA {
}

public class ConcreteProductA1 implements ProductA {
    public ConcreteProductA1() {
        System.out.println("ConcreteProductA1被创建");
    }
}

public class ConcreteProductA2 implements ProductA {
    public ConcreteProductA2() {
        System.out.println("ConcreteProductA2被创建");
    }
}

　　创建产品类B

public interface ProductB {
}

public class ConcreteProductB1 implements ProductB {
    public ConcreteProductB1() {
        System.out.println("ConcreteProductB1被创建");
    }
}

public class ConcreteProductB2 implements ProductB {
    public ConcreteProductB2() {
        System.out.println("ConcreteProductB2被创建");
    }
}

　　创建工厂类

public interface Factory {
    ProductA factoryMethodA();
    ProductB factoryMethodB();
}

public class ConcreteFactory1 implements Factory {
    @Override
    public ProductA factoryMethodA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB factoryMethodB() {
        return new ConcreteProductB1();
    }
}

public class ConcreteFactory2 implements Factory {
    @Override
    public ProductA factoryMethodA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB factoryMethodB() {
        return new ConcreteProductB2();
    }
}

　　使用测试类Client看看效果

public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory1();
        factory.factoryMethodA();
        factory.factoryMethodB();
    }
}

 

 　　以上就是抽象工厂模式，工厂方法模式的出现是为了解决简单工厂模式中代码修改，那样侵入性太强，违背了开闭原则；抽象工厂模式的出现是为了解决工厂方法只能创建一个系列的产品。