面向对象的六大原则

时间  2019-12-08
标签 面向对象 六大 原则 栏目 软件设计 繁體版
原文   原文链接

《Android源码设计模式解析与实战》读书笔记(一)php

《Android源码设计模式解析与实战》PDF资料下载编程

1、单一职责原则

单一职责原则的英文名称是Single Responsibility Principle，缩写是SRP。SRP的定义是：就一个类而言，应该仅有一个引发它变化的缘由。设计模式

简单来讲，一个类中应该是一组相关性很高的函数、数据的封装。单一职责的划分界限并不老是那么清晰，不少时候都是须要靠我的经验来界定。缓存

1.一、示例代码

下面是一个图片加载器的项目代码。bash

/**
 * 图片加载类
 */
public class ImageLoader {
    //图片缓存
    LruCache<String, Bitmap> mImageCache;
    //线程池，线程数量为CPU的数量
    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    public ImageLoader() {
        initImageCache();
    }

    private void initImageCache() {
        //计算可以使用的最大内存
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        //取四分之一的可用内存做为缓存
        final int cacheSize = maxMemory / 4;
        mImageCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes() * value.getHeight() / 1024;
            }
        };
    }

    public void displayImage(final String url, final ImageView imageView) {
        imageView.setTag(url);
        mExecutorService.submit(new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = downloadImage(url);
                if (bitmap == null) {
                    return;
                }
                if (imageView.getTag().equals(url)) {
                    imageView.setImageBitmap(bitmap);
                }
                mImageCache.put(url, bitmap);
            }
        });
    }

    private Bitmap downloadImage(String imageUrl) {
        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            final HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            bitmap = BitmapFactory.decodeStream(conn.getInputStream());
            conn.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }

}
复制代码

将各个功能独立出来，知足单一职责原则的代码以下。微信

/**
 * 图片加载类
 */
public class ImageLoader {
    //图片缓存
    ImageCache mImageCache = new ImageCache();
    //线程池，线程数量为CPU的数量
    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    //加载图片
    public void displayImage(final String url, final ImageView imageView) {
        Bitmap bitmap=mImageCache.get(url);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
            return;
        }
        imageView.setTag(url);
        mExecutorService.submit(new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = downloadImage(url);
                if (bitmap == null) {
                    return;
                }
                if (imageView.getTag().equals(url)) {
                    imageView.setImageBitmap(bitmap);
                }
                mImageCache.put(url, bitmap);
            }
        });
    }

    private Bitmap downloadImage(String imageUrl) {
        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            final HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            bitmap = BitmapFactory.decodeStream(conn.getInputStream());
            conn.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }

}
复制代码
public class ImageCache {
    //图片LRU缓存
    LruCache<String,Bitmap> mImageCache;
    public ImageCache() {
        initImageCache();
    }

    private void initImageCache() {
        //计算可以使用的最大内存
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        //取四分之一的可用内存做为缓存
        final int cacheSize = maxMemory / 4;
        mImageCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes() * value.getHeight() / 1024;
            }
        };
    }

    public void put(String url,Bitmap bitmap){
        mImageCache.put(url, bitmap);
    }

    public Bitmap get(String url){
        return mImageCache.get(url);
    }
}
复制代码

将原来的代码一拆为二，ImageLoader只负责图片加载的逻辑，而ImageCache只负责处理图片缓存的逻辑，使得职责更清晰。网络

2、开闭原则

开闭原则的英文全称是Open Close Principle，缩写是OCP，它是Java世界里最基础的设计原则，它指导咱们如何创建一个稳定的、灵活的系统。ide

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

2.一、示例代码

上面重构以后的ImageLoader职责单1、结构清晰。经过内存缓存解决了每次从网络加载图片的问题，可是Android应用的内存有限，且具备易失性，就是当应用从新启动以后，原来已经加载过的图片将会丢失，这样重启以后就须要从新下载。优化

public class DiskCache {
    static String cacheDir="sdcard/cache/";

    //从缓存中获取图片
    public Bitmap get(String url){
        return BitmapFactory.decodeFile(cacheDir + url);
    }

    //将图片缓存到内存中
    public void put(String url, Bitmap bmp) {
        FileOutputStream fileOutputStream = null;
        try {
            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 (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
复制代码

仅仅新增了一个DiskCache类和往ImageLoader类中加入少许代码就添加了SD卡缓存的功能，用户能够经过useDiskCache方法来对使用哪一种缓存进行设置。

缓存优先使用内存缓存，若是内存缓存没有图片再使用SD卡缓存，若是SD卡中也没有图片最后才从网络上获取，这才是最好的缓存策略。

public interface ImageCache {

    public void put(String url,Bitmap bitmap);

    public Bitmap get(String url);
}
复制代码
public class MemoryCache implements ImageCache {
    //图片LRU缓存
    LruCache<String, Bitmap> mMemeryCache;

    public MemoryCache() {
        //初始化LRU缓存
    }

    @Override
    public void put(String url, Bitmap bitmap) {
        mMemeryCache.put(url, bitmap);
    }

    @Override
    public Bitmap get(String url) {
        return mMemeryCache.get(url);
    }
}
复制代码
//SD卡缓存DiskCache类
public class DiskCache  implements ImageCache{
    static String cacheDir="sdcard/cache/";

    //从缓存中获取图片
    @Override
    public Bitmap get(String url){
        return BitmapFactory.decodeFile(cacheDir + url);
    }

    //将图片缓存到内存中
    @Override
    public void put(String url, Bitmap bmp) {
        FileOutputStream fileOutputStream = null;
        try {
            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 (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
复制代码
public class DoubleCache {
    ImageCache mMemoryCache=new MemoryCache();
    DiskCache mDiskCache=new DiskCache();

    //先从内存缓存中获取图片，若是没有，再从SD卡中获取
    public Bitmap get(String url){
        Bitmap bitmap = mMemoryCache.get(url);
        if (bitmap == null) {
            bitmap = mDiskCache.get(url);
        }
        return bitmap;
    }

    //将图片缓存到内存和SD卡中
    public void put(String url, Bitmap bmp) {
        mMemoryCache.put(url, bmp);
        mDiskCache.put(url, bmp);
    }
}
复制代码
/**
 * 图片加载类
 */
public class ImageLoader {
    //内存缓存
    private ImageCache mImageCache = new MemoryCache();
    //线程池，线程数量为CPU的数量
    private ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    //注入缓存实现
    public void setImageCache(ImageCache imageCache) {
        mImageCache = imageCache;
    }

    //加载图片
    public void displayImage(final String url, final ImageView imageView) {
        Bitmap bitmap =  mImageCache.get(url);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
            return;
        }
        //图片没缓存，提交到线程池中下载图片
        submitLoadRequest(url, imageView);
    }

    private void submitLoadRequest(final String url, final ImageView imageView) {
        imageView.setTag(url);
        mExecutorService.submit(new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = downloadImage(url);
                if (bitmap == null) {
                    return;
                }
                if (imageView.getTag().equals(url)) {
                    imageView.setImageBitmap(bitmap);
                }
                mImageCache.put(url, bitmap);
            }
        });
    }

    private Bitmap downloadImage(String imageUrl) {
        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            final HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            bitmap = BitmapFactory.decodeStream(conn.getInputStream());
            conn.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }

}
复制代码

3、里氏替换原则

里氏替换原则英文全称是Liskov Substitution Principle，缩写是LSP。LSP的第一种定义是：若是对每个类型为S的对象O1，都有类型为T的对象O2，使得以T定义的全部程序P在全部对象O1都代换成O2时，程序P的行为没有发生变化，那么类型S是类型T的子类型。

里氏替换原则第二种定义：全部引用基类的地方必须能透明地使用其子类的对象。

3.一、核心原理

里氏替换原则的核心原理是抽象，抽象又依赖于继承这个特性，在OOP中，继承的优缺点都至关明显。

  1. 优势：
  • 代码重用，减小建立类的成本，每一个子类都拥有父类的方法和属性；
  • 子类与父类基本类似，但又与父类有所区别；
  • 提升代码的可扩展性。
  1. 缺点：
  • 继承是侵入性的，只要继承就必须拥有父类的全部属性和方法；
  • 可能形成子类代码冗余、灵活性下降，由于子类必须拥有父类的属性和方法。

开闭原则和里氏替换原则一般是生死相依、不离不弃的，经过里氏替换原则来达到对扩展开放，对修改关闭的效果。这两个原则都强调了一个OOP的重要特性——抽象。

4、依赖倒置原则

依赖倒置原则英文全称是Dependence Inversion Principle，缩写是DIP。依赖倒置原则指代了一种特定的解耦形式，使得高层次的模块不依赖于低层次的模块的实现细节的目的，依赖模块被颠倒了。

依赖倒置原则有如下几个关键点：

  • 高层模块不该该依赖低层模块，二者都应该依赖其抽象；
  • 抽象不该该依赖细节；
  • 细节应该依赖抽象。

在Java中，抽象是指接口或抽象类，二者都不能直接被实例化；细节就是实现类，实现接口或继承抽象类而产生的类就是细节，能够直接被实例化。

高层模块就是调用端，低层模块就是具体实现类。

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

5、接口隔离原则

接口隔离原则英文全称是Interface Segregation Principles，缩写是ISP。ISP的定义是：客户端不该该依赖它不须要的接口。另外一种定义是：类间的依赖关系应该创建在最小的接口上。

接口隔离原则的目的是系统解开耦合，从而容易重构、更改和从新部署。

Robert C Martin在21世纪早期将单一职责、开闭原则、里氏替换、接口隔离以及依赖倒置5个原则定义为SOLID原则，做为面向对象编程的5个基本原则。

6、迪米特原则

迪米特原则英文全称为Law of Demeter，缩写是LOD，也称为最少知识原则（Least Knowledge Principle）。其定义是：一个对象应该对其余对象有最少的了解。

6.一、示例代码

以租房为例来讲一下迪米特原则的应用。

/**
 * 房间
 */
public class Room {
    public float area;
    public float price;

    public Room(float area, float price) {
        this.area = area;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Room{" +
                "area=" + area +
                ", price=" + price +
                '}';
    }
}
复制代码
/**
 * 中介
 */
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> getRooms() {
        return mRooms;
    }
}
复制代码
/**
 * 租户
 */
public class 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.getRooms();
        for (Room room :
                rooms) {
            if (isSuitable(room)) {
                System.out.println("租到房间了" + room);
                break;
            }
        }
    }

    private boolean isSuitable(Room room) {
        return Math.abs(room.price - roomPrice) < diffPrice
                && Math.abs(room.area - roomArea) < diffArea;
    }
}
复制代码

从上面的代码中能够看到，Tenant不只依赖了Mediator类，还须要频繁地与Room类打交道。优化代码以下：

/**
 * 中介
 */
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> getRooms() {
        return mRooms;
    }

    public Room rentOut(float area,float price){
        for (Room room : mRooms) {
            if (isSuitable(area,price,room)) {
                return room;
            }
        }
        return null;
    }

    private boolean isSuitable(float area,float price,Room room) {
        return Math.abs(room.price - price) < Tenant.diffPrice
                && Math.abs(room.area - area) < Tenant.diffArea;
    }
}
复制代码
/**
 * 租户
 */
public class 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));
    }
}
复制代码

学海无涯苦做舟

个人微信公众号
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程