设计模式(二) 工厂模式

Hello

回顾: 面向对象设计的基本原则

1.OCP(开闭原则): 一个应用的实体对扩展开放,对修改关闭.(白话: 如今我有两个类构建一个功能,若是想要扩展新功能的话,根据原则是不要在原有的两个类上作修改,从新新建一个类来完成新加的功能)

2.DIP(依赖反转原则): 要针对接口编程,不要针对实现编程(白话: A实现类调用B实现类,具体关系,根据原则B类应当实现接口C类,而后A类与C类发生关系,将具体关系转为抽象依赖)

3.LoD(迪米特法则): 只与朋友通讯.(白话: 该法则的初衷在于下降对象之间的耦合,减小类和类的直接关系,功能的复用,模块独立化...更多信息[百度,gooale]查阅)

附加: 耦合类型,由高到低 ↓↓↓

• 内容耦合: 当一个模块直接修改或操做另外一个模块的数据时,或一个模块不经过正常入口而转入另外一个模块时,该耦合是最高程度的耦合,应该避免使用之
• 公共耦合: 两个及以上的模块共同引用一个全局数据项为公共耦合
• 外部耦合: 一组模块都访问同一全局简单变量而不是同一全局数据结构,并且不是经过参数表传递该全局变量的信息,为外部耦合
• 控制耦合: 一个模块经过接口向另外一个模块传递一个控制信号,接受信号的模块根据信号值而进行适当的动做,为控制耦合
• 标记耦合: 若一个模块A经过接口向两个模块B和C传递一个公共参数,那么称模块B和C之间存在一个标记耦合
• 数据耦合: 模块之间经过参数来传递数据,为数据耦合.数据耦合是最低的一种耦合形式,系统中都存在这种类型的耦合,由于为了完成一些有意义的功能,每每须要将某些模块的输出数据做为另外一些模块的输入数据
• 非直接耦合: 两个模块之间没有直接关系,它们之间的联系彻底是经过主模块的控制和调用来实现的

工厂模式

实现建立和调用的分离, 将选择实现类、建立对象统一管理和控制.

三种工厂模式:

简单工厂

建立同一结构类型的任何对象,对于新增的对象,须要修改已有代码

建立一个接口Dog

public interface Dog {
    void ability();
}

建立三种Dog,直接上真名了

public class 中华田园犬 implements Dog {
    @Override
    public void ability() {
        System.out.println("中华田园犬: 什么都能吃,听话,好养,能力强");
    }
}

public class 哈士奇 implements Dog {
    @Override
    public void ability() {
        System.out.println("哈士奇: 吃荤吃素还不知道,这种狗的能力你们都知道");
    }
}

public class 哈巴狗 implements Dog {
    @Override
    public void ability() {
        System.out.println("哈巴狗: 大眼憨厚,听话好使");
    }
}

建立工厂类

public class FactoryZone {
    //第一种方式
    public static Dog factoryForDog(String type){
        Dog dog=null;
        if (type.equals("中华田园犬")){
            dog=new 中华田园犬();
        }else if (type.equals("哈士奇")){
            dog=new 哈士奇();
        }else if (type.equals("哈巴狗")){
            dog=new 哈巴狗();
        }
        //新增的话,须要在此处追加.
        return dog;
    }

    //第二种方式
    public Dog get中华田园犬(){
        return new 中华田园犬();
    }
    public Dog get哈士奇(){
        return new 哈士奇();
    }
    public Dog get哈巴狗(){
        return new 哈巴狗();
    }
}

测试 FactoryMain

public class FactoryMain {
    public static void main(String[] args) {
        //无工厂模式,这种状况下FactoryMain依赖Dog接口以及中华田园犬类,哈士奇类,哈巴狗类
        Dog dog=new 中华田园犬();
        dog.ability();
        Dog dog1=new 哈士奇();
        dog1.ability();
        Dog dog2=new 哈巴狗();
        dog2.ability();

        //简单工厂模式,这种状况下FactoryMain依赖FactoryZone以及Dog接口
        //内部FactoryZone依赖Dog接口以及中华田园犬类,哈士奇类,哈巴狗类
        //总体关系复杂,调用者简单
        FactoryZone.factoryForDog("中华田园犬").ability();
        FactoryZone.factoryForDog("哈士奇").ability();
        FactoryZone.factoryForDog("哈巴狗").ability();
    }
}

工厂方法

建立同一结构类型的固定对象,能够新增任何对象

建立 DogFactory接口

public interface DogFactory {
    Dog getDog();
}

建立不一样的生产工厂

public class 中华田园犬Factory implements DogFactory {
    @Override
    public Dog getDog() {
        return new 中华田园犬();
    }
}

public class 哈士奇Factory implements DogFactory {
    @Override
    public Dog getDog() {
        return new 哈士奇();
    }
}

public class 哈巴狗Factory implements DogFactory {
    @Override
    public Dog getDog() {
        return new 哈巴狗();
    }
}
若是新增了其余的Dog的时候,须要新增另外的类xxFactory implements DogFactory
该设计符合开闭原则,若是不少Dog的话,就也要加不少的xxFactory类

public class FactoryMain {
    public static void main(String[] args) {
        //工厂方式模式,FactoryMain依赖DogFactory以及中华田园犬Factory(),哈士奇Factory(),哈巴狗Factory()
        //DogFactory依赖Dog接口以及中华田园犬类,哈士奇类,哈巴狗类
        DogFactory dogFactory = new 中华田园犬Factory();
        dogFactory.getDog().ability();
        DogFactory dogFactory1 = new 哈士奇Factory();
        dogFactory1.getDog().ability();
        DogFactory dogFactory2 = new 哈巴狗Factory();
        dogFactory2.getDog().ability();
    }
}

理论和实际老是相差些什么,正常状况下,仍是使用简单工厂会多点.

抽象工厂

建立不一样产品族的任何对象,不能够新增新单个对象,能够新增不一样产品族,用到这种模式说明项目体系比较大了,引用某大大的一张图作记录,该模式是工厂的工厂,根据下图创建理解思惟,代码省略:

 

-----------------------------------------------------------