学习笔记——JAVA设计模式<2>工厂模式

工厂模式
实现了创建者和调用者的分离
详细分类
简单工厂模式
工厂方法模式
抽象工厂模式
面向对象设计的基本原则
OCP（开闭原则 Open-Closed Principle）:一个软件的实体应当对扩展开放，对修改关闭
DIP（依赖倒转原则 Dependence Inversion Principle）:要针对接口编程，不要针对实现编程
LoD（迪米特法则 Law of Demeter）:只与你直接的朋友通信，而避免和陌生人通信

核心本质
实例化对象，用工厂方法代替new操作
将实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦

工厂模式
简单工厂模式
用来生产同一等级结构中的任意产品（对于增加的产品，需要修改已有代码）
工厂方法模式
用来生产同一等级结构的固定产品（支持增加任意产品）
抽象工厂模式
用来生产不同产品族的全部产品（对于增加的新产品，无能为力，支持增加产品族）

简单工厂运用最多
简单工厂模式也叫静态工厂模式，就是工厂类一般使用是静态方法，通过接收的参数的不同来返回不同的对象实例
对于增加新的产品，不修改代码，是无法拓展的

package studyGFO;
/**
 * 简单工厂
 * @author http://blog.csdn.net/thewaiting
 *
 */
public class Fatory {
    //1
    public static FactoryDome01 createMethon(String type) {
        if ("FactoryDome02".equals(type)) {
            return new FactoryDome02();
        }else if("FactoryDome03".equals(type)){
            return new FactoryDome03();
        }
        return null;
    }
    //2
    public FactoryDome02 cteateFactoryDome02() {
        return new FactoryDome02();
    }
    public FactoryDome03 cteateFactoryDome03() {
        return new FactoryDome03();
    }

}

package studyGFO;
/**
 * 简单工厂模式使用
 * @author http://blog.csdn.net/thewaiting
 *
 */
public class Client {//调用者

    public static void main(String[] args) {
        FactoryDome01 f2 = Fatory.createMethon("FactoryDome02");
        FactoryDome01 f3 = Fatory.createMethon("FactoryDome03");

        f2.run();

    }

}

package studyGFO;

public interface FactoryDome01 {
    void run();
}

package studyGFO;

public class FactoryDome02 implements FactoryDome01{

    @Override
    public void run() {
        System.out.println("这里是FactoryDome02");
    }

}

package studyGFO;

public class FactoryDome03 implements FactoryDome01{

    @Override
    public void run() {
        System.out.println("这里是FactoryDome03");

    }



}

工厂方法模式
为了避免简单工厂的缺点，不完全满足OCP（开闭原则）
工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立的模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类
增加新的类 类多了

修改代码

package studyGFO;
/**
 * 工厂方法模式  符合开闭原则
 * @author http://blog.csdn.net/thewaiting
 *
 */
public class Client {//调用者

    public static void main(String[] args) {
        FactoryDome01 f2 = new FD2Factory().createFactory();
        FactoryDome01 f3 = new FD3Factory().createFactory();
        f2.run();
        f3.run();
    }

}

package studyGFO;
/**
 * 工厂方法模式
 * @author http://blog.csdn.net/thewaiting
 *
 */
public interface Factory {
    FactoryDome01 createFactory();
}

package studyGFO;
/**
 * 想增加新的产品就new一个这样新的类不用修改原有的代码

 * @author http://blog.csdn.net/thewaiting
 *
 */
public class FD2Factory implements Factory{

    @Override
    public FactoryDome01 createFactory() {
        return new FactoryDome02();
    }

}

package studyGFO;

public class FD3Factory implements Factory{

    @Override
    public FactoryDome01 createFactory() {  
        return new FactoryDome03();
    }

}

抽象工厂模式
用来生产不同产品族的全部产品（对于新增的产品，无能为力；支持增加产品族）
抽象工厂模式是工厂模式的升级版本，在有多个业务品种，业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式

package studyGFO;

public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
    Tyre createTyre();
}

package studyGFO;

public class LowCarFactory implements CarFactory{

    @Override
    public Engine createEngine() {

        return new LowEngine();
    }

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }

    @Override
    public Tyre createTyre() {

        return new LowTyre();
    }

}

package studyGFO;

public class LuxuryCarFactory implements CarFactory{

    @Override
    public Engine createEngine() {

        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {

        return new LuxurySeat();        
    }

    @Override
    public Tyre createTyre() {

        return new LuxuryTyre();
    }

}

package studyGFO;

public 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("启动慢");
    }

}

package studyGFO;

public interface Seat {

    void massage();
}
class LuxurySeat implements Seat{

    @Override
    public void massage() {
        System.out.println("能按摩");

    }
}
class LowSeat implements Seat{

    @Override
    public void massage() {
        System.out.println("不能按摩");

    }
}

package studyGFO;

public interface Tyre {
    void revolve();

}

class LuxuryTyre implements Tyre{

    @Override
    public void revolve() {
        System.out.println("磨损轻微");
    }

}

class LowTyre implements Tyre{

    @Override
    public void revolve() {
        System.out.println("磨损严重");
    }

}

package studyGFO;

public class Client {

    public static void main(String[] args) {
        CarFactory factory = new LuxuryCarFactory();
        Engine engine = factory.createEngine();
        engine.run();
    }

}

工厂模式要点
简单工厂模式（静态工厂模式）
虽然某种程度上不符合设计原则，但实际使用最多
工厂方法模式
不修改已有类的前提下，通过新增的工厂类实现扩展
抽象工厂模式
不可以增加产品，可以增加产品族

应用场景
JDK中Calendar的getInstance方法
JDBC中Connection对象的获取
Hibernate中SessionFactory创建Session
Spring中IOC容器创建管理bean对象
XML解析时的DocunentBuilderFactory创建解析器对象
反射中Class对象的呢我Instance()