GOF23设计模式之工厂模式

GOF23设计模式之工厂模式

 　　工厂模式实现了创建者和调用者的分离。

　　　分为：简单工厂、工厂方法、抽象工厂　

 面向对象设计的基本原则：

  OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改关闭。

  DIP（依赖倒转原则，Dependence Inversion Principle）：要针对接口编程，不要针对实现编程。

  LoD（迪米特法则，Law of Demeter）：只与你直接的朋友通信，而避免和陌生人通信。

 简单工厂模式

package cn.taosir.design.create.factory;

/**
 *     简单工厂模式
 * @author taosir
 *
 */
public class SimpleFactory {

    interface Car{
        void run();
    }
    
    static class AoDi implements Car{
        @Override
        public void run() {
            System.out.println("我是奥迪...");
        }
    }
    static class BenChi implements Car{
        @Override
        public void run() {
            System.out.println("我是奔驰...");
        }
    }
    
    static class CarFactory{
        static Car createCar(String type) {
            if("奥迪".equals(type)) {
                return new AoDi();
            }else if("奔驰".equals(type)) {
                return new BenChi();
            }else {
                return null;
            }
        }
    }
    
    public static void main(String[] args) {
        CarFactory.createCar("奥迪").run();
    }
}

工厂方法模式

package cn.taosir.design.create.factory;

/**
 *     工厂方法模式
 * @author Administrator
 *
 */
public class FactoryMethod {

    interface Car{
        void run();
    }
    
    static class AoDi implements Car{
        @Override
        public void run() {
            System.out.println("我是奥迪...");
        }
    }
    static class BenChi implements Car{
        @Override
        public void run() {
            System.out.println("我是奔驰...");
        }
    }
    
    interface CarFactory{
        Car createCar();
    }
    
    static class AoDiFactory implements CarFactory{
        @Override
        public Car createCar() {
            return new AoDi();
        }
    }
    
    static class BenChiFactory implements CarFactory{
        @Override
        public Car createCar() {
            return new BenChi();
        }
    }
    
    public static void main(String[] args) {
        new AoDiFactory().createCar().run();
    }
}

抽象工厂方法

package cn.taosir.design.create.factory;
/**
 * 抽象工厂模式
 * @author taosir
 *
 */
public class AbstractFactory {
    //造高端车
    LuxuryCarFactory luc=new LuxuryCarFactory();
    //低端车
    LowCarFactory low=new LowCarFactory();
}

/**
 * 引擎
 */
interface Engine{
   void run();
   void start();
}

/**
 * 高端
 */
class LuxuryEngine implements Engine{
    @Override
    public void run() {System.out.println("转得快...");}
    @Override
    public void start() {System.out.println("启动快！可以自动启停...");}
}

/**
 *    低端
 */
class LowEngine implements Engine{
    @Override
    public void run() {System.out.println("转得慢...");}
    @Override
    public void start() {System.out.println("启动慢...");}
}

interface Seat{    void message();}

class LuxurySeat implements Seat{
    @Override
    public void message() {System.out.println("可以自动按摩...");}
}

class LowSeat implements Seat{
    @Override
    public void message() {System.out.println("只能坐着...");}
}

interface CarFactory{
    Engine createEngine();
    Seat createSeat();
}

class LuxuryCarFactory implements CarFactory{
    @Override
    public Engine createEngine() {return new LuxuryEngine();}
    @Override
    public Seat createSeat() {return new LuxurySeat();}
}

class LowCarFactory implements CarFactory{
    @Override
    public Engine createEngine() {return new LowEngine();}
    @Override
    public Seat createSeat() {return new LowSeat();}
}

总结：

简单工厂模式（静态工厂模式）：虽然某种程度不符合设计原则，但实际使用最多

工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展。

抽象工厂模式：不可以增加产品，可以增加产品族

应用场景：

JDK 中 Calendar 的 getInstance 方法

JDBC 中 Connection 对象的获取

Hibernate 中 SessionFactory 创建 Session

Spring 中 IOC 容器创建管理 bean对象

XML 解析时的 DocumentBuilderFactory 创建解析器对象

反射中 Class 对象的 newInstance()