Java设计模式之OO原则（程序员必备思想）

一个优秀的程序员，技术需要以OO为基础来开始。“OO”表示 “面向对象”。

特性

封装

顾名思义，封装就好比一个小黑屋，内部被隐藏，只有几个接口与外界相连。具体来说，所谓封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。封装是面向对象的特征之一，是对象和类概念的主要特性。 简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

class Man{
    //私有，被保护
    private String name;
    private int age;
    //公有，可被外部调用的接口
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
}

继承

继承是指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。继承概念的实现方式有二类：实现继承与接口继承。实现继承是指直接使用基类的属性和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力。

class Man{
    private String name;
    private int age;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
}

class SuperMan extends Man{
 
    public void power(){
       System.out.println("I'm superMan !!!");
    }

}

多态

所谓多态就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。

class Man{
    private String name;
    private int age;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
}
class SuperMan extends Man{
    public void power(){
       System.out.println("I'm Superman!!!");
    }
｝
class SaiyanMan extends Man{
    public void power(){
       System.out.println("I'm Saiyan!!!");
    }
｝
class HulkMan extends Man{
    public void power(){
       System.out.println("I'm Hulk!!!");
    }
｝

六大设计原则

单一职责SRP(Single Responsibility Principle)

最少知识原则 所谓单一职责，就是一个类只处理一个问题。分工明确，避免错乱。

错误示范，game的方法不应该出现在Eat的类中，吃是吃，玩是玩

//
class Eat{
    public void apple(){
       System.out.println("I'm eating an apple!!!");
    }
	public void game(){
       System.out.println("I'm playing a game!!!");
    }
｝

正确示范

//
class Eat{
    public void apple(){
       System.out.println("I'm eating an apple!!!");
    }
｝
class Play{
    public void game(){
       System.out.println("I'm playing a game!!!");
    }
｝

开放封闭原则OCP(Open－Close Principle)

找出程序中会变化的方面，然后将其和固定不变的方面相分离 扩展性开放，更改性封闭。简单来说，在不更改已有代码的情况下可扩展新功能。

错误示范，Eat类，有吃苹果，吃香蕉的方法。如果要想吃菠萝，就要新增一个吃菠萝的方法，还想吃其它东西，都需要新增方法

class Eat{
    public void apple(){
       System.out.println("I'm eating an apple!!!");
    }
	public void banana(){
       System.out.println("I'm eating an banana!!!");
    }
｝

正确示范 想吃什么水果传进来就行，一个方法搞定所有。这是一种艺术

class Eat{
    public void do(String fruit){
       System.out.println("I'm eating an "+variety+"!!!");
    }
｝

里氏替换原则LSP(Liskov Substitution Principle)

要依赖抽象，不要依赖具体类 即任何基类(父类，超类)可以出现的地方，子类（派生类）一定可以出现。譬如SuperMan IS-A Man，SuperMan 类可以完全实现Man类的所有方法。

class Man{
    private String name;
    private int age;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
}
class SuperMan extends Man{
    public void power(){
       System.out.println("I'm Superman!!!");
    }
｝

public static void main(String[] args) {
		SuperMan superMan =new SuperMan();
		superMan.setName("阿三"); 
		...
}

依赖倒置原则DIP(Dependency Inversion Principle)

针对接口编程，而不是针对实现编程 即是程序要依赖于抽象接口，不要依赖于具体实现。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

错误示范，Eat类，有吃苹果，吃香蕉的方法。针对吃苹果和吃香蕉都写了一套实现，这就是对实现编程。

class Eat{
    public void apple(){
       System.out.println("I'm eating an apple!!!");
    }
	public void banana(){
       System.out.println("I'm eating an banana!!!");
    }
｝

正确示范 想吃什么水果传进来就行，一个方法搞定所有。这是针对接口编程，降低松耦合。

class Eat{
    public void variety(String variety){
       System.out.println("I'm eating an "+variety+"!!!");
    }
｝

接口分离原则ISP(Interface Segregation Principle ISP)

多用组合，少用继承 是指在设计时采用多个与特定功能类有关的接口比采用一个通用的接口要好。即，一个类要给多个客户使用，那么可以为每个客户创建一个接口，然后这个类实现所有的接口；而不要只创建一个接口，其中包含所有客户类需要的方法，然后这个类实现这个接口。

错误示范，只创建了一个接口，打包苹果和吃苹果。

class Eat{
    public void do(){
       System.out.println("I basket apples!!!");
       System.out.println("I'm eating an apple!!!");
    }
｝

正确示范 接口拆分，打包是一个接口，吃是一个接口，可以分开调用。接耦合，提高复用

class Eat{
    public void basket(){
       System.out.println("I basket apples!!!");
    }
    public void eat(){
       System.out.println("I'm eating an apple!!!");
    }
｝

迪米特法则

为了交互对象之间的松耦合设计而努力 一个软件实体应当尽可能少地与其他实体发生相互作用。如果一个系统符合迪米特法则，那么当其中某一个模块发生修改时，就会尽量少地影响其他模块，扩展会相对容易，这是对软件实体之间通信的限制，迪米特法则要求限制软件实体之间通信的宽度和深度。迪米特法则可降低系统的耦合度，使类与类之间保持松散的耦合关系。