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("哈巴狗: 大眼憨厚,听话好使");
    }
}

创建工厂类

扫描二维码关注公众号，回复： 870912 查看本文章

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();
    }
}

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

抽象工厂

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

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

设计模式(二) 工厂模式

Hello

工厂模式

简单工厂

工厂方法

抽象工厂

猜你喜欢