面向对象的六大基本原则

一．单一职责原则（Single Responsibility Principle）缩写SRP

就一个类而言，应该仅有一个引起它的变化原因（换句话说，也就是一个类最好制作一件事（这个一件事的定义比较难定义，看个人））

 

例子：imageLoader

 

最开始的imageLoader里面有 图片加载逻辑 和  处理图片缓存的逻辑 ，这在我们看来就不符合SRP原则，所以要分开，分成图片加载逻辑（ImageLoader）,和缓存部分（ImageCache）

 

二．开闭原则（Open Close Principle）缩写是OCP

开闭原则定义是：软件中的对象（类，模块，函数等）应该对于扩展是开放的，但是对于修改是封闭的。（换句话说，让软件需要变化时，我们应该尽量通过扩展的方式来实现变化，而不是通过修改已有的代码来实现）

 

例子：ImageLoader 需要加个缓存机制（本地或者网络）

 

问题：怎么让缓存机制变得可扩展，可以让用户随便改

public class ImageLoader {    //图片缓存    ImageCache mImageCache = new MemoryCache();    .....//一些代码    //注入缓存实现    public void setmImageCache(ImageCache cache){        mImageCache = cache;    }    public void display(String imageUrl,ImageView imageView){        //如果图片不是null就设置图片        //如果图片是null就去获取 //提交到线程池去下载        submitLoadRequest(imageUrl,imageView);    }    public void submitLoadRequest(final String imageUrl ,final ImageView imageView){        ....//一些代码        @Override        public void run () {            ...//一些代码            mImageCache.put(imageUrl, imageView);        }    }}

上面是最终代码，可以看出解决了问题，用什么缓存机制由我们自己说了算通过setImageCache（这里默认用了Memory）

public interface ImageCache{    public Bitmap get(String url);    public void put(String url,Bitmap bmp);}

然后不管是内存缓存还是本地缓存，或者两者都有都继承这个就行，然后用户自己定制就可以了

比如

MemoryCache,DiskCache,DoubleCache都是实现接口ImageCache，所以可以这么干

imageloader.setImageCache(new MemoryCache())

imageloader.setImageCache(new DiskCache())

imageloader.setImageCache(new DoubleCache())

三．里氏替换原则（Liskov subsitution Princile）简称LSP

所有引用基类的地方必须能透明地使用其子类的对象。（说白了就是只要父类能出现的地方子类就能出现，而且替换为子类也不会产生任何错误或异常，使用者可能根本就不需要知道是父类还是子类，但是反过来就不行，有子类的地方，父类未必就能适应，最后其实就是抽象）

 

MemoryCache,DiskCache,DoubleCache都是实现接口ImageCache，所以可以这么干

imageloader.setImageCache(new MemoryCache())

imageloader.setImageCache(new DiskCache())

imageloader.setImageCache(new DoubleCache())

 

这个就是用到了里氏替换原则。

四．依赖倒置原则（Dependence Inversion Principle）

依赖倒置原则有以下几个关键点。

（1）高层模块（调用端）不应该依赖低层模块（具体实现类），两者都应该依赖抽象

（2）抽象（接口或者抽象类）不应该依赖细节

（3）细节（实现接口或继承抽象类而产生的类就是细节）应该依赖抽象

在Java语言中的表现就是：模块间的依赖通过抽象发生，实现类之间不发生直接依赖关系，其依赖关系是通过接口或抽象类产生的。

 

例如上面的例子：

public class ImageLoader {    //图片缓存    ImageCache mImageCache = new MemoryCache();.....}

可以看出ImageLoader依赖的是接口ImageCache,这个就是对的

如果是下面这样那就是依赖细节了

public class ImageLoader {    //图片缓存    MemoryCache memoryCache = new MemoryCache();.....//}

这样就不行，不方便扩展

ImageCache mImageCache = new MemoryCache();

这样写的话，如果有需求要改的话只需要实现ImageCache类或者继承其他已有的ImageCache子类完成相应的缓存功能。这样就保证了高扩展性！！！

五．接口隔离原则（Interface Segregation Principles）简称ISP

其实就是客户端不应该依赖他不需要的接口（也可以理解为：类间的依赖关系应该建立在最小的接口上）

public void put(String url,Bitmap bmp){    try{        FileOutputStream fileOutputStream = null;        fileOutputStream = new FileOutputStream(cacheDir + url);        bmp.compress(Bitmap.CompressFormat.PNG, 100 , fileOutputStream);    }catch (FileNotFoundException e){        e.printStackTrace();    }finally {        if(fileOutputStream != null){            try{                fileOutputStream.close();            }catch{                e.printStackTrace();            }        }    }} 

Try catch各种嵌套，这样看起来很不好看影响代码阅读性

<span style="font-family: Arial, Helvetica, sans-serif;">public final class CloseUtils{</span>

    private CloseUtils(){}    /**     * 关闭Closeable对象     * @param closeable     * */    public static void closeQuitely(Closeable closeable){        if(null != closeable){            try{                closeable.close();            }catch (IOException e){                e.printStackTrace();            }        }    }}public void put(String url ,Bitmap bmp){    FileOutputStream fileOutputStream = null;    try{        FileOutputStream fileOutputStream = null;        fileOutputStream = new FileOutputStream(cacheDir + url);        bmp.compress(Bitmap.CompressFormat.PNG, 100 , fileOutputStream);    }catch (FileNotFoundException e){        e.printStackTrace();    }finally {        CloseUtils.closeQuitely(fileOutputStream);    }}

这个方法的基本原理就是依赖于Closeable抽象而不是具体实现，并且建立在最小化依赖原则的基础上，他只需要知道这个对象是否可关闭，其他的一概不关心

 

六．迪米特原则（Law of Demeter）缩写LOD

一个对象应该对其他对象有最少的了解

例子：在北京租房

/** * 房间 * */public class Room{    public  Room(float area ,float price){        this.area = area;        this.price = price;    }    @Override    public void toString(){        return "Roomasdsad"    }}/** * 中介 * */public class Mediator{    List<Room> mRooms = new ArrayList<>(Room)();    public Mediator(){        for(int i =0;i<5;i++){            mRooms.add(new Room(14+i,(14+i)*150));        }    }    public List<Room> getAllRooms(){        return mRooms;    }}    /**     * 租户     * */public void Tenant{        public float roomArea;        public float roomPrice;        public static final float diffPrice = 100.0001f        public static final float diffArea = 0.00001f;        public void rentRoom(Mediator mediator){        List<Room> rooms = mediator.getAllRooms();            for(Room room : rooms){                 if(isSuitable(room)){                      System.out.println("租到房间啦 ！" +room);                      break;                 }            }        }    }

可以看出Tenant不仅依赖Mediator类，还需要频繁地与Room类打交道

，租户类的要求只是通过中介找到一间适合自己的房间罢了，如果把这些检测条件都放在Tenant类中,那么中介类的功能就被弱化了，而导致Tenant与Room的耦合较高

（会导致当Room变化时Tenant也必须跟着变化，Tenant又与Mediator耦合）

/** * 房间 * */public class Room{    public  Room(float area ,float price){        this.area = area;        this.price = price;    }    @Override    public void toString(){        return "Roomasdsad"    }}/** * 中介 * */public class Mediator{    List<Room> mRooms = new ArrayList<>(Room)();    public Mediator(){        for(int i =0;i<5;i++){            mRooms.add(new Room(14+i,(14+i)*150));        }    }    public void rentOut(float area,float price){        for(Room room : rooms){            if(isSuitable(area ,price ,room)){                System.out.println("租到房间啦 ！" +room);                break;            }        }        private boolean isSuitable(float area , float price,Room room){        return Math.abs(room.price - price )<Tenant.diffPrice &&Math.abs(room.area -area ) - Tenant.diffprice;    }    }}    /**     * 租户     * */public void Tenant{    public float roomArea;    public float roomPrice;    public static final float diffPrice=100.0001f    public static final float diffArea=0.00001f;    public void rentRoom(Mediator mediator){                System.out.println("租到房了"+mediator.rentOut(roomArea,roomPrice))            }  }

这里只是将对于room的判定操作转移到了Mediator类中，这本应该是Mediator的职责