面向对象六大原则

     1、单一职责原则

        缩写：SRP(Single Respinsibility Principle)

        定义：就一个类而言，应该只有一个引起它变化的原因

        简而言之，完全不同的功能不应该放在一个类中实现，一个类中应该是相关性很高的函数（或者数据）的封装

        举例：

        一个图片加载类，里面既有内存缓存（注意和sd卡存取是有区别的），也有图片的下载，显示功能。根据单一职责原则，可以另外定义一个类实现内存缓存，而不是放在图片加载类里面。这样图片的加载逻辑和缓存的处理逻辑互不影响，任何一方修改都不会影响到对方

        2、开闭原则

        缩写：OCP(Open Close Principle)

        定义：软件中的对象（类、模块或者函数等）应该对于扩展是开放的，对于修改是封闭的

        简而言之， 就是当需要实现新的功能的时候，采用继承、接口的方式来实现，不是修改原来的代码（不是绝对不能修改）来实现。当我们程序需要升级或者维护的时候，如果修改原来的代码，可能会引发其它问题，那解决办法就是尽量少动原来的代码，除非发现原来的代码有错误才需要修改某个类的实现，否则如果是些新加的或者改变的功能的话可以新建某个类来继承原类的代码，然后新类通过重写父类的方法来实现新功能。所以对扩展开放，对修改封闭的意思就是建议采用扩展，不建议采用修改，而扩展就是指继承、接口。

        举例：

        上一个例子，如果这时候我添加了sd卡的缓存方式，所以新建了一个sd卡缓存类，这样在图片加载类里面就得判断现在是哪种缓存方法，从而进行不同的存取；接着我再定义n个缓存方式呢，图片加载类里面就得再加代码，再判断，这样代码就很冗余，扩展性很差。这时可以定义某个接口，让sd卡缓存类、内存缓存类...实现这个接口，图片加载类里面仅调用接口的引用的方法，采用回调的方式即可实现千变万化的缓存策略

     

          3、里氏替换原则

        缩写：LSP(Liskov Substitution Principle)

        定义：所有引用基类的地方必须能透明地使用其子类的对象

        简而言之，只要父类能出现的地方子类就可以出现，而且替换为子类也不会产生任何错误或者异常，反之就不一定行，子类能出现的地方，父类不一定适应。所以可以用抽象来搞，比如接口或者抽象类。接口的可以参考上一个例子，下面是运用抽象类实现里氏替换原则

        举例：

package com.example.javaproject;

public class FilmCompany  {
    public static void main(String [] args){
        TextView textView=new TextView();
        ImageView imageView=new ImageView();
        Window window=new Window();
        window.show(textView);
        window.show(imageView);
    }
}

abstract class View{
    public  abstract void  onDraw() ;

    public void onMesure() {

    }
}

class TextView extends View {
    @Override
    public void onDraw() {
        System.out.println("textview");
    }
}

class ImageView extends View {
    @Override
    public void onDraw() {
        System.out.println("ImageView");
    }
}


//把View的子类TextView或者ImageView对象传进来替换View都不会报错，而且还会调用子类相应的onDraw方法
class Window {
    public void show(View view) {
        view.onDraw();
    }
}

     

 

        4、依赖倒置原则

        缩写：DIP(Dependence Inversion Principle)

        定义：三层含义：高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象

        简而言之，

        高层模块：就是调用端

        低层模块：就是具体的实现类

        抽象：就是抽象类或者接口        

        细节：就是具体的实现类，实现了接口或者继承抽象类的类

        本来调用端是依赖实现类的，现在你让它不直接依赖了（因为把实现类写在调用端里面，耦合就严重了，参考前面单一职责原则的例子），所以依赖倒置了。那么怎么搞才能不直接依赖？使用抽象来做，而抽象就是接口或者抽象类，也就是说实现接口或者继承抽象类来做

        举例：

        早期的电脑所有硬件整合在一起，一个模块坏全部坏。现在的电脑都依赖于插槽（接口、规范），更换cpu、内存等很方便

        PS:依赖倒置原则是实现开闭原则的主要手段；不实现依赖倒置原则就不能实现开闭原则

        5、接口隔离原则

        缩写：ISP(Interface Segregation Principle)

        定义一：客户端不应该强行依赖它不需要的接口

        定义二：类间的依赖关系应该建立在最小的接口上

        简而言之，就是要将接口划分出多份，别一套接口供很多人用，因为里面很多方法可能用不上，所以没必要都实现；另外，根据实际需要创建接口，用不到的方法别往接口里面放

        举例：

       

注：前五个原则又统称为SOLID原则

     

          6、迪米特法则

        缩写：LOD(Law Of Demeter)

        定义：只与直接的朋友通信

        简而言之，如果两个类之间不必彼此直接通信，那么这两个类之间就不应当发生相互作用，如果其中一个类需要调用另一个类的方法的话，可以通过第三者转发这个调用

 

        举例：

           比如我们买房，只要把想要的房子价格大小告诉中介，他帮我们搞定就行，至于他怎么和卖房的打交道我们不用管，跟我们扯不上关系