设计模式（一）简单工厂、工厂方法和抽象工厂

时间 2019-11-12

标签设计模式简单工厂方法抽象繁體版

原文原文链接

简单工厂模式

定义：

简单工厂模式属于类的建立型模式,又叫作静态工厂方法模式。经过专门定义一个类(Factory)来负责建立其余类的实例，被建立的实例一般都具备共同的父类(接口)。

简单工厂模式中的角色和职责：

工厂（Creator）：简单工厂模式的核心，它负责实现建立全部实例的内部逻辑。工厂类能够被外界直接调用，建立所需的产品对象。mysql
抽象（Product）：简单工厂模式所建立的全部对象的父类，它负责描述全部实例所共有的公共接口。sql
具体产品（Concrete Product）：简单工厂模式所建立的具体实例对象。数据库

示例：

抽象：oracle

public interface Fruit {

    /* 采集水果 */
    public void get();
}

工厂：app

public class FruitFactory {

    public static Fruit getFruit(String type) {
        try {
            if (type.equalsIgnoreCase("apple")) {
                return Apple.class.newInstance();

            } else if (type.equalsIgnoreCase("banana")) {
                return Banana.class.newInstance();
            } else {
                System.out.println("没有这个类");
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

    }
}

具体产品：框架

//实现1
public class Apple implements Fruit {

    public void get() {
        System.out.println("采集苹果");
    }
}

//实现2
public class Banana implements Fruit{

    public void get(){
        System.out.println("采集香蕉");
    }
}

测试类ide

public class MainClass {
    public static void main(String[] args) {

        Fruit apple = FruitFactory.getFruit("Apple");
        Fruit banana = FruitFactory.getFruit("banana");
        apple.get();
        banana.get();
    }
}

优缺点：

优势：用户在使用时能够直接根据工厂类去建立所需的实例，而无
需了解这些对象是如何建立以及如何组织的。有利于整个软件体系结构的优化。测试
缺点：
- 因为工厂类集中了全部实例的建立逻辑，因此“高内聚”方面作的并很差。另外，当系统中的具体产品类不断增多时，可能会出现要求工厂类也要作相应的修改，扩展性并不很好。优化
- 简单工厂模式适合拥有固定的实现类，当别人设计好以后，咱们只须要调用就好了，但违反了开放-封闭的原则，想要增长新的实现类，就必需要修改工厂方法。ui

应用：

在Dao层的实现上，如在MVC框架层上定义一个接口，其中有多个实现类，咱们不须要理解实现类是怎样实现的，只须要经过父类建立子类的对象便可。
如在链接数据库的时候，框架给咱们提供了一个管理数据库链接的工厂类，在实现类中可能有多个实现类(mysql , mssql , oracle等)，咱们只须要经过工厂类建立出实现类的对象便可。

工厂方法模式(多态工厂模式)

定义：

工厂方法模式的意义是定义一个建立产品对象的工厂接口(FruitFactory接口)，将实际建立工做推迟到子类当中(BananaFactory implements FruitFactory 等)。核心工厂类再也不负责产品的建立，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可使系统在不修改具体工厂角色的状况下引进新的产品。

工厂方法模式中的角色和职责：

抽象工厂（Creator）：工厂方法模式的核心，任何工厂类都必须实现这个接口。
具体工厂（ Concrete Creator）：具体工厂类是抽象工厂的一个实现，负责实例化产品对象。
抽象（Product）：工厂方法模式所建立的全部对象的父类，它负责描述全部实例所共有的公共接口。
具体产品（Concrete Product）：工厂方法模式所建立的具体实例对象。

示例：

核心工厂（抽象工厂）：负责管理工厂，不负责工厂的建立
```
public interface FruitFactory {

    public Fruit getFruit();
}
```

具体工厂：负责对各个实例的初始化

public class BananaFactory implements FruitFactory {

    @Override
    public Fruit getFruit() {

        return new Banana();
    }

}

public class AppleFactory implements FruitFactory {

    @Override
    public Fruit getFruit() {
        return new Apple();
    }

}

抽象：全部实例化对象都拥有的方法

public interface Fruit {

    /* 采集水果 */
    public void get();
}

具体产品

public class Apple implements Fruit {

    public void get() {
        System.out.println("采集苹果");
    }
}

public class Banana implements Fruit{

    public void get(){
        System.out.println("采集香蕉");
    }
}

测试建立类

public class MainClass {
    public static void main(String[] args) {

        FruitFactory appleFactory = new AppleFactory();
        Fruit apple = appleFactory.getFruit();
        apple.get();

        FruitFactory bananaFactory = new BananaFactory();
        Fruit banana = bananaFactory.getFruit();
        banana.get();

    }
}

好处

　　当系统扩展须要添加新的产品对象时，仅仅须要添加一个具体对象以及一个具体工厂对象，原有工厂对象不须要进行任何修改，也不须要修改客户端，很好的符合了“开放－封闭”原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性很差。

抽象工厂模式

定义：抽象工厂模式是全部形态的工厂模式中最为抽象和最其通常性的。抽象工厂模式能够向客户端提供一个接口，使得客户端在没必要指定产品的具体类型的状况下，可以建立多个产品族的产品对象。
抽象工厂中角色和职责
- 抽象工厂（Creator）：抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口。
- 具体工厂（ Concrete Creator）：具体工厂类是抽象工厂的一个实现，负责实例化某个产品族中的产品对象。
- 抽象（Product）：抽象模式所建立的全部对象的父类，它负责描述全部实例所共有的公共接口。具体工厂类是抽象工厂的一个实现，负责实例化某个产品族中的产品对象。
- 具体产品（Concrete Product）：抽象模式所建立的具体实例对象。
抽象工厂中方法对应产品结构，具体工厂对应产品族。

产品族和产品等级结构

举例

抽象工厂：

public interface FruitFactory {
    //实例化Apple
    public Fruit getApple();
    //实例化Banana
    public Fruit getBanana();
}

抽象：

public abstract class Banana implements Fruit{
    /*
     * 采集
     */
    public abstract void get();
}

public abstract class Apple implements Fruit {

    /*
     * 采集
     */
    public abstract void get(); 
}

具体工厂

public class NorthFruitFactory implements FruitFactory {

    public Fruit getApple() {
        return new NorthApple();
    }

    public Fruit getBanana() {
        return new NorthBanana();
    }

}

public class SouthFruitFactory implements FruitFactory {

    public Fruit getApple() {
        return new SouthApple();
    }

    public Fruit getBanana() {
        return new SouthBanana();
    }

}

具体产品：

public class NorthBanana extends Banana {

    public void get() {
        System.out.println("采集北方香蕉");
    }

}

public class NorthApple extends Apple {

    public void get() {
        System.out.println("采集北方苹果");
    }

}

public class SouthApple extends Apple {

    public void get() {
        System.out.println("采集南方苹果");
    }

}

public class SouthBanana extends Banana {

    public void get() {
        System.out.println("采集南方香蕉");
    }

}

测试类

public class MainClass {
    public static void main(String[] args) {
        FruitFactory ff = new NorthFruitFactory();
        Fruit apple = ff.getApple();
        apple.get();

        Fruit banana = ff.getBanana();
        banana.get();

        FruitFactory ff2 = new SouthFruitFactory();
        Fruit apple2 = ff2.getApple();
        apple2.get();

        Fruit banana2 = ff2.getBanana();
        banana2.get();

    }
}

对工厂方法的使用举例：

http://blog.csdn.net/dawanganban/article/details/9884681