JAVA设计模式：六大设计原则

JAVA设计模式

首先作为程序届的一位小学生，不断的学习是我们应该有的初衷。在JAVA的学习道路上，《JAVA设计模式》,《JAVA编程思想》等都是我们需要去慢慢学习和消化的东西。在这里非常感谢由 刘径舟，张玉华 老师编著的《设计模式起始很简单》一书。下面也是分享自己学习设计模式的心得。同时也借助书中的简单例子来更好的说明设计模式的艺术。

• 初谈设计模式

• 设计模式原则

  那么什么是设计模式呢？设计模式是一套面向对象的代码设计经验总结。简单来说是很多人都知道且反复使用和分类整理的代码设计方法。使用设计模式是为了让人更容易被他人理解，保证代码的重用性和可靠性。
  设计模式是一种思想，也是一种技术，一种设计模式就是一种解决方案，也就是我们常用的设计模式框架。

• 原则
  1、单一原则
  2、里氏代换原则
  3、开放-封闭原则
  4、依赖原则
  5、合成/聚合复用原则
  6、迪米特法则

单一原则
那么什么是单一原则呢？咱们先从一个简单的例子去理解。假设整个世界就是一个大程序，程序员就是里面的复仇者联盟，专门去创造一些变态的英雄，例如什么钢铁侠啦、蝙蝠侠啦、超人啦等。就假如以程序员创造蜘蛛侠为例，程序员创造了蜘蛛侠，为了维护世界的和平，便在赋予蜘蛛侠非常多的功能，甚至大大小小的事情他都能完成。但是，这就出现问题了，如果蜘蛛侠在执行其中一个任务的时候，突然收到另一边正在抢劫银行，蜘蛛侠就会变得非常的被动。如果当天出现更多的突发情况，那么蜘蛛侠估计都已经累死了。
单一原则：对于一个类，应该只有一个引起它变化的原因
如果我们在开发的时候，设计的类增加了各种各样的功能，那么类就会变得臃肿，后期维护起来也非常的麻烦，外界改变它的因素太多。

public class 蜘蛛侠{
    ......
    public void 打击犯罪分子(){
        //蜘蛛侠打击犯罪分子
    }
    ......
}

蜘蛛侠在打击犯罪分子的时候就不会受到外界因素的影响了。

里氏代换原则
里氏代换原则，反应的是子类和父类之间的关系。继承使类的功能多元化了。那么，什么是里氏代换原则呢？我们来看一个问题：
鱼，是一种很抽象的说法，但是区别鱼和其他物种的方式是鱼能够在水里用腮呼吸，同时繁衍方式是卵生的方式。那么，鲨鱼是不是鱼呢？我们来看看鲨鱼的属性，鲨鱼也是使用腮呼吸，他们具有卵生的同时还具备胎生的方式，那么按照继承的思想，鲨鱼也是鱼。

里氏代换原则：子类型必须能够替换掉它们的父类型

用一个简单例子来说明：一个村里有一个老木匠，做的椅子非常的好看，同时也收了一个徒弟，并且把自己的手艺交给了他，徒弟在继承老师傅的手艺的同时，自己也琢磨学会了装饰椅子的技术。有一天老木匠年纪大了做不动椅子了，便交给了他的徒弟去完成。在外人看来，从他们店铺做出来的椅子都非常的好看，根本不知道是老木匠做的还是他的徒弟做的。等到更长久的未来，徒弟便接管木匠的店铺。

public class 老木匠{
    ...
    public void 做椅子(){
    //老木匠做的椅子
    }
    ...
}

public class 徒弟 extends 老木匠{
    ...
    public void 做椅子(){
    //徒弟继承手艺
    }
    ...
    //自己学会装饰椅子
    ...
    public void 装饰椅子(){
    //装饰椅子
    }
    ...
}

这种原则也使得父类在不修改功能的情况下，子类继承并且可以使得功能的到拓展。

开放-封闭原则
也是设计原则中的核心。在面向对象编程过程中，往往要添加新功能，添加一个新类要比修改现有的类更加方便和安全。因为软件在设计的时候就是追求封装变化，降低耦合。通过里氏变换原则来实现最佳的继承层次。就可以不违反开放封闭原则。

开放-封闭原则：程序的实体对象（模块、类、函数等），应该可以进行拓展，但不是应该可以修改
特征：1、对于拓展是开放的。2、对于修改时封闭的
为实现开放-封闭原则的例子：

public class Bank{
    public void saveMoney(){
    //存款
    }
    public void drowMoney(){
    //取款
    }
    ...
}

当银行需要增加新的功能的时候，就必须要修改类，如果功能过多过于庞大，那么维护起来相当的困难。使用开放-封闭原则的修改后效果怎么样呢？

public interface Bank{
    public void bankOperate();
}
public class SaveMoney implements Bank{
    public void bankOperate(){
    //存款
    }   
}
public class DrowMoney implements Bank{
    public void bankOperate(){
    //取款
    }   
}
...

修改代码后发现，只要银行要增加新功能，就可以添加一个新的类去实现银行操作接口，这样不仅没有修改接口的代码，还向拓展了新功能。使用该原则拓展软件系统已有的新功能，以满足软件新的需求，使软件更具有灵活性。

依赖倒转原则：程序的高层模块不应该依赖于程序的低层模块，但是两者都依赖于抽象；抽象不依赖于具体的细节，而细节更依赖于抽象
依赖原则的本质是通过抽象（接口或者抽象类）使各个类或模块的实现彼此独立，不互相影响，从而之间的松散耦合。

• 每个类尽量都继承自接口或者抽象类，或者是抽象类和借口两者都具备
• 变量显示尽量是接口或者是抽象类
• 类要尽量从具体类派生
• 尽量不要去覆盖基类的方法。如果基类是抽象类，而且方法已经实现了，那么子类就尽量不要去复写。

例子：

//抽象或者接口
public interface Work{
    public void doWork();
}
//一班工作人
class WorkMan  implements Work{
    public void doWork(){
    //一般工作量
    }
}
//当要增加超级工作狂的时候，实现接口就行了
class SuperWork implements Work{
    public void doWork(){
    //大量的工作
    }
}

从复用的角度来说，高层的模块是应当被复用的，而且是复用的重点，因为它包含着应用系统最重要的宏观逻辑，并且较为稳定。

//播放器应该有的就是播放音频
    public abstract class Play{
        public void playMusic(){
        //播放音频
        }
        //可以增加的功能
        public abstract void operate();
    }
    class MP4 extends Play{
        //不复写父类的方法
        public void playMusic(){
            super.playMusic();
        }
        public void operate(){
        //增加播放视频功能
        }
    }

合用/聚合复用原则 ： 尽量不适用类继承，而是尽量使用合成/聚合
那么什么是聚合，合成呢，聚合它是表示一种比较“弱”的拥有关系，具体表现为甲对象中包含乙对象，但是乙对象不是甲对象的一部分；合成是一种“强”的拥有关系体现的是整体与部分的关系。例如手臂和人体就是部分和整体的关系。
用一个例子来体会一下合用/聚合的关系。在中国古代，大将军拥有着掌控士兵的权利，例如夏侯惇，但是能掌控他的他的上司，曹操，他不仅仅拥有掌控夏侯惇的权利，同时也拥有大量的兵权。

    public interface Dajiangjun
    {
        public void Do();
    }
    public interface Shibing
    {
        public void Do();
    }


    class xiahoudun implements Dajiangjun{
        //我掌握的士兵
        Shibing[] shib;
        public void Do(){
        //我是大将军
        }
    }
     class shibingjia implements Shibing{

        public void Do(){
        //我是士兵
        }
    }
    class huangshang{
        //我掌握的大将军
        Dajiangjun[] dajiangjun;
    }

合成和聚合都是对象建模中关联关系的一种。聚合表示的是整体与部分的关系。表示“含有”，整体由部分组成，部分也可以脱离整体作为一个独立的个体而存在。合成更强调的是一种更强的关系，部分组成整体。并且不可分割。同时不能脱离整体单独存在。

迪米特法则

也被称作最少知识原则，也就是说一个对象尽可能少的了解其他对象。
如果两个类之间不必世界通信，则这两个类不应该发生直接的相互作用。如果其中的一个类需要调用另一个类的某个方法，可以通过第三方来转发这个调用
迪米特法则强调的是类的结构设计上，每个类都要尽量降低成员的访问权限，不需要让其他类知道字段或者行为就不要公开。不希望类之间建立直接的接触。
一个类公开的属性或者方法越多，修改所涉及的面也就越大。