读书笔记——面向对象的六大原则

最新推荐文章于 2024-08-03 23:19:11 发布
最新推荐文章于 2024-08-03 23:19:11 发布
阅读量330 收藏
点赞数
分类专栏： 读书笔记 文章标签： android 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dawN4get/article/details/70306392
版权

本文的大部分内容是基于《Android源码设计模式解析与实战》这本书。

1、单一职责原则

“就一个类而言，应该仅有一个引起它变化的原因。” 简单说来，两个完全不一样的功能就不应该放在一个类中。一个类中，应该是一组相关性很高的函数、数据的封装。工程师可以不断的审视自己的代码，根据具体业务、功能对类进行相对的拆分，这是程序员优化代码的第一步。

小明编写一个ImageLoader图片加载类，却把图片加载，图片缓存等功能都写在一起。那么这个ImageLoader的耦合性就非常高了，随着功能的增加，ImageLoader类会变得越来越庞大，代码也会变得越来越复杂，从而导致这个图片加载类变得脆弱。

当小明学习了单一职责原则后，对ImageLoader做了拆分：ImageLoader类只用来加载图片，并添加了一个ImageCache类用来处理图片缓存。这样ImageLoader的代码量变小了，职责也清晰了；当与缓存相关的逻辑要修改的时候，不修改ImageLoader类，二图片加载逻辑需要修改时，也不会影响到缓存处理逻辑。

2、开闭原则

“软件中的对象（类、模块、函数）应该对于扩展是开放的，但是对于修改是封闭的。”也就是说，当软件需要变化时，我们应该尽量通过扩展的方式来实现变化，而不是通过修改已有的代码。

小明发现了他的ImageLoader类出现了一个问题：由于他只做了内存缓存，当程序重新启动后，原来加载过的图片丢失了，又要重新从网络加载。这时候小明就对他的图片缓存逻辑进行修改 ——缓存优先使用内存缓存，如果内存缓存没有图片再使用SD卡缓存，如果SD卡中也没有图片最后才从网络获取。于是小明新增了一个DiskCache类用于SD卡缓存，新增一个DoubleCache类实现双缓存。相应的对ImageLoader类展示图片的逻辑进行了修改。

但是，以后有新的缓存策略的话，还是要修改原来的代码，这样很可能引入bug，而且会使原来的代码逻辑变得越来越复杂。当小明学习了开闭原则后，将ImageLoader进行了一次重构，具体代码如下：

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

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

    public void displayImage(String imageUrl, ImageView imageView) {
        Bitmap bitmap = mImageCache.get(imageUrl);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
            return;
        }

        //图片没缓存，提交到线程池下载
        submitLoadRequest(imageUrl, imageView);

    }

    private void submitLoadRequest(final String url, final ImageView view) {
        view.setTag(url);
        mExecutorService.submit(new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = downloadImage(url);
                if (bitmap == null) {
                    return;
                }
                if (view.getTag().equals(url)) {
                    view.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 interface ImageCache {
    Bitmap get(String url);

    void put( String url,Bitmap map);
}
public class MemoryCache implements ImageCache {

    private LruCache<String,Bitmap> mMemoryCache;

    public MemoryCache(){
        //计算最大可用内存
        final int maxMemory=(int)(Runtime.getRuntime().maxMemory()/1024);
        //取1/4
        final int cacheSize=maxMemory/4;

        mMemoryCache=new LruCache<String, Bitmap>(cacheSize){
            //必须重写此方法，来测量Bitmap的大小
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                return bitmap.getRowBytes()*bitmap.getHeight()/1024;
            }
        };
    }


    @Override
    public Bitmap get(String url) {
        return mMemoryCache.get(url);
    }

    @Override
    public void put(String url,Bitmap map) {
        mMemoryCache.put(url,map);
    }
}
public class DiskCache implements ImageCache {
    @Override
    public Bitmap get(String url) {
        return null;//从本地文件中获取该图片
    }

    @Override
    public void put(String url, Bitmap map) {
        //Bitmap写入文件中
    }
}
public class DoubleCache implements ImageCache {
    ImageCache  mMemoryCache=new MemoryCache();
    ImageCache mDiskCache=new DiskCache();

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

    @Override
    public void put(String url, Bitmap map) {
        mMemoryCache.put(url,map);
        mDiskCache.put(url,map);
    }
}

细心的读者可能注意到了，ImageLoader类中添加了一个SetImageCache(ImageCache cache)函数，使用者可以通过该函数设置缓存，也就是通常说的依赖注入。下面看下简单的使用：

 ImageLoader  imageLoader=new ImageLoader();
 imageLoader.setImageCache(new MemoryCache());
 imageLoader.setImageCache(new DiskCache());
 imageLoader.setImageCache(new DoubleCache());
 //使用自定义的图片缓存
 imageLoader.setImageCache(new ImageCache() {
     @Override
     public Bitmap get(String url) {
         return null;
     }

     @Override
     public void put(String url, Bitmap map) {

     }
 });

开闭原则指导我们，当软件需要变化的时，应该尽量通过扩展的方式来实现变化，而不是通过修改原来的代码。
遵循开闭原则的重要手段是通过抽象。这里的“应该尽量”说明开闭原则并不是说绝对不能去修改原来的代码。当我们嗅到原来代码“腐朽的味道”时，应该尽早的重构。

3、里氏替换原则

所有引用基类的地方都能透明地使用其子类对象。通俗的讲，只要父类能出现的地方子类就可以出现，而且替换为子类也不会产生任何的错误或异常。

里氏替换原则的核心原理就是抽象，抽象又依赖于继承这个特性，在OOP当中，继承的优缺点都相当的明显。优点如下：
1. 代码重用，减少创建类的成本，每个子类都有父类的方法和属性。
2. 子类与父类基本相似，又与父类有所不同
3. 提高代码的可扩展性

继承的缺点：
1. 继承是入侵性的，只要继承就必须拥有父类的所有属性和方法
2. 可能造成代码冗余，灵活性降低，因为子类必须要有父类的方法和属性

在开闭原则的代码中很好的反应了里氏替换原则，即MemoryCache,DiskCache,DoubleCache都可以替换ImageCache工作，并且能保证行为的正确性。

开闭原则和里氏替换原则往往是生死相依的，通过里氏替换原则来达到对扩展开放，对修改关闭的效果。然而这两个原则都强调了OOP的重要特性——抽象，因此，在开发中运用抽象是走向代码优化的重要一步。

4、依赖倒置原则

模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的。

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

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

在Java中，抽象就是指接口或抽象类，两者都是不能直接被实例化的；细节就是实现类，实现接口或继承抽象类而产生的类就是细节。高层模块就是调用端，低层模块就是具体实现类。

如果类与类之间直接依赖于细节，那么它们之间有直接的耦合，当具体实现需要改变的时候也要同时修改依赖者的代码，这限制了系统的扩展性。

假如在ImageLoader中的图片缓存直接依赖于MemoryCache，这个MemoryCache是一个具体实现，不是一个接口或抽象类。这导致了ImageLoader直接依赖了具体的细节，当MemoryCache不能满足ImageLoader而需要被其他缓存实现替换时，此时就必须修改ImageLoader的代码，也违背了开闭原则了。例如：

    //内存缓存，直接依赖细节
    MemoryCache mMemoryCache=new MemoryCache();

    public void displayImage(String url,ImageView img){
        Bitmap bitmap=mMemoryCache.get(url);
        if(bitmap==null){
            downloadImage(url,img);
        }else{
            img.setImageBitmap(bitmap);
        }
    }

    public void setImageCache(MemoryCache  cache){
        mMemoryCache=cache;
    }
}

随着产品的升级，用户发现MemoryCache已经不能满足需求了，用户需要小明的ImageLoader可以将图片同事缓存在SD卡和内存中，或者让用户可以自定义缓存。此时，我们的MemoryCache这个类名不仅不能表达内存缓存和SD卡缓存的意义，也不能满足功能。另外，用户需要自定义缓存策略时还必须继承MemoryCache，而用户的缓存实现可不一定需要内存缓存。所以，需要重构！

ImageCache抽象类：

public interface ImageCache {
    Bitmap get(String url);

    void put( String url,Bitmap map);
}

内存缓存类：

public class MemoryCache implements ImageCache {

    private LruCache<String,Bitmap> mMemoryCache;

    public MemoryCache(){
        //计算最大可用内存
        final int maxMemory=(int)(Runtime.getRuntime().maxMemory()/1024);
        //取1/4
        final int cacheSize=maxMemory/4;

        mMemoryCache=new LruCache<String, Bitmap>(cacheSize){
            //必须重写此方法，来测量Bitmap的大小
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                return bitmap.getRowBytes()*bitmap.getHeight()/1024;
            }
        };
    }


    @Override
    public Bitmap get(String url) {
        return mMemoryCache.get(url);
    }

    @Override
    public void put(String url,Bitmap map) {
        mMemoryCache.put(url,map);
    }
}

SD卡缓存类：

public class DiskCache implements ImageCache {
    @Override
    public Bitmap get(String url) {
        return null;//从本地文件中获取该图片
    }

    @Override
    public void put(String url, Bitmap map) {
        //Bitmap写入文件中
    }
}

内存缓存+SD卡缓存

public class DoubleCache implements ImageCache {
    ImageCache  mMemoryCache=new MemoryCache();
    ImageCache mDiskCache=new DiskCache();

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

    @Override
    public void put(String url, Bitmap map) {
        mMemoryCache.put(url,map);
        mDiskCache.put(url,map);
    }
}

ImageLoader类：

public class ImageLoader{
    //图片缓存类，依赖于抽象，并且有一个默认实现
    ImageCache mCache=new MemoryCache();

    public void displayImage(String url,ImageView img){
        Bitmap bitmap=mMemoryCache.get(url);
        if(bitmap==null){
            downloadImage(url,img);
        }else{
            img.setImageBitmap(bitmap);
        }
    }

    public void setImageCache(MemoryCache  cache){
        mMemoryCache=cache;
    }
}
5、接口隔离原则

类间的依赖关系应该建立在最小的接口上。接口隔离原则将非常庞大的、臃肿的借口拆分为更小的和更具体的接口，这样客户将会只需要知道他们感兴趣的方法

在Java6以及之前的JDK版本中，有一个非常讨厌的问题，那就是使用了OutputStream或者其他可关闭的对象后，我们必须保证他们最终被关闭了，例如如下代码：

public void put(String url){
    FileOutputStream fileOutputStream=null;
    try{
        fileOutputStream=new FileOutputStream(cacheDir+url);
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        if(fileOutputStream != null){
            try{
                fileOutputStream.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }

 }

上面的代码可读性很差，各种try..catch嵌套都是写简单的代码，但是会严重的影响代码的可读性，并且多层级的大括号很容易将代码写到错误的层级中。

我们都知道java中有一个Closeable接口，该接口标识了一个可关闭的对象，它只有一个close方法。FileOutputStream就实现了这个接口，其他的还有100多类实现了Closeable接口,这意味着，在关闭这100多个对象时，都要写出像put方法中finally代码段那样的代码。下面的工具类就是用来统一关闭实现了Closeable接口的对象。

public final class CloseUtils{
    private CloseUtils(){}

    public static void closeQuietly(Closeable closeable){
        if(null!=closeable){
            try{
                closeable.close();
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }
}

我们再看看把这段代码用到上述的put方法中:

public void put(String url){
    FileOutputStream fileOutputStream=null;
    try{
        fileOutputStream=new FileOutputStream(cacheDir+url);
    }catch(Exception e){
        e.printStackTrace();
    }finally{
       CloseUtils.closeQuietly(fileOutputStream);
    }

 }

CloseUtils的closeQuietly()方法原理就是依赖于Closeable抽象而不是具体的实现，并且建立在最小依赖原则的基础上，它只需要知道这个对象时可以关闭的，其他的一概不管，也就是这里说的接口隔离原则。

6、迪米特原则

一个类应该对自己要耦合或调用的类知道得最少，类的内部如何实现与调用者或依赖者无关，调用者或依赖者只需要知道它需要的方法即可，其他的可以一概不管。

就拿SD卡缓存来说吧，ImageLoader调用ImageCache，而SD卡缓存内部却是使用jake wharton的DiskLruCache实现，用户根本不知道DiskLruCache的存在，他们只知道ImageCache而已。

dawN4get
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式（三）——面向对象设计原则
冯Jungle的个人博客
10-16 1万+
设计模式需要遵循基本的软件设计原则。可维护性（Maintainability）和可复用性（Reusability）是衡量软件质量的重要的两个属性： 可维护性：软件能够被理解、改正、适应及扩展的难易程度 可复用性：软件能够被复用的难易程度 面向对象设计的原则是支持可维护性复用，一方面需要实现设计方案或代码的复用，另一方面要保证系统易于扩展和修改，具有良好的可维护性。面向对象设计原则蕴含在各个设计...
php课程笔记——韩顺平.rar
06-19
七、面向对象 1. 类与对象：讲解类的定义、属性和方法，对象的创建与销毁。 2. 继承、封装与多态：理解OOP的三大特性及其在PHP中的实现。 3. 接口与抽象类：接口的定义与实现，抽象类的使用场景。 八、错误与异常...
Java学习笔记 —— 面向对象六大原则之里氏替换原则实战
Marinda_Speed的博客
12-17 499
谈到面向对象，你要是只知道基础的话，你可能会说，不就是封装、继承、多态吗？但是你仔细学习面向对象中你就会发现，面向对象也需要遵循类似MySQL的四要性。废话不多说，我们今天来看看面向对象中的六大原则之一 ——里氏替换原则。
[笔记] 面向对象六大原则
wandryoung的博客
12-18 166
面向对象的六大原则 优化代码的第一步——单一职责原则 英文全称为 Single Responsibility Principle，缩写是SRP。 定义：就一个类而言，应该仅有一个引起它变化的原因，简单来说，一个类中应该是一组相关性很高的函数、数据的封装。 让程序更稳定、更灵活——开闭原则 英文全称为 Open Close Principle，开闭原则，缩写OCP。 定义：软件中的对象（类、...
C#.Net学习笔记——设计模式六大原则
weixin_46711336的博客
01-08 1244
C# .Net 六大设计模式
灵活软件之路——面向对象的六大原则
李斯维的博客空间
01-09 437
1、单一职责原则 Single Responsibility Principle， SRP的定义是：就一个类而言，应该仅有一个引起它变化的原因。简单来说，一个类中应该是一组相关性很高的数据的封装。 2、开闭原则 Open Close Principle，OCP，Java中最基础的设计原则，其定义是：软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是对于修改是封闭的。因此，当软件需
《Android源码设计模式解析与实战》读书笔记（一）——面向对象的六大原则
禽兽先生不禽兽
05-01 733
写代码很容易，但是写出简单易懂好修改的代码实在。如何优化代码，设计模式是关键，所以最近开始啃书，在这里记录一下读书笔记，大部分是摘录，也有自己的总结和心得，写给自己。 第一章、面向对象的六大原则 1.单一职责原则 Single Responsibility Principle，SRP，其定义是：就一个类而言，应该仅有一个引起它变化的原因。 两个完全不一样的功能不应该放在一个类中，比如一个带
面向对象六大原则（四）：依赖倒置原则
Loften_93663469的博客
12-13 877
面向对象程序设计（OOP）的六大原则是我对《Android源码设计模式解析与实战》的读后笔记。要设计出灵活又便于维护的软件，必须要求我们的设计能力与代码质量高，也就是我们所谓的编程思想。因此，我们需以面向对象的六大原则为基础、各大设计模式的运用自如、更高的应用架构思想（如MVC,MVP,MVVM）来使得我们开发的应用真正实现高内聚、低耦合的应用架构。
【Python入门自学笔记专辑】——面向对象编程
被一个OIER遗弃的一堆烂代码
03-26 9991
文章目录前言面向对象：举个最简单点的例子来区分 面向过程和面向对象：面向过程：面向对象的三大特性：类和对象定义类创建和使用对象构造方法 【Python入门自学笔记专辑】——面向对象编程 前言 ​ 面相对象是Python的重要特性，继承了C++的类风格，在Python中的一切数据类型都是面向对象的。本章主要介绍Python的面向对象编程。 面向对象： ​ 什么是OOP（面向对象），Object ...
设计模式 | 面向对象设计原则——学习笔记
大虎牙的博客
10-31 219
C++面向对象设计原则 变化是复用的天敌！ 面向对象设计最大的优势在于：抵御变化！ 一. 重新认识面向对象 理解隔离变化 从宏观层面来看，面向对象的构建方式更能适应软件的变化，能将变化所带来的影响减为最小。 各司其职 从微观层面来看，面向对象的方式更强调各个类的“责任” 由于需求变化导致的新增类型不应该影响原来类型的实现——是所谓的各负其责 对象是什么？ 从语言实现层面来看，对象封装了...
狂神说Java——面向对象基础笔记
qq_45568450的博客
02-11 397
温故而知新，回顾Java面向对象的笔记
Java编程思想读书笔记.pdf
12-13
首先，对象导论阐述了面向对象编程（OOP）的优势，相比过程性语言，OOP使得程序更简洁、易懂和可重用。书中提到，即使在《C++编程思想》中也有类似的章节，作为引导读者入门的起点。如果你对OOP不熟悉，这个部分不容...
JAVA面向对象基础总结笔记
06-13
面向对象编程（Object-Oriented Programming, OOP）是一种程序设计范式，它将数据和处理这些数据的方法组织在一起，形成一个整体——对象（Object）。Java作为一种典型的面向对象语言，其核心特性包括：封装、继承、...
【达内】听课笔记之二——JAVA
12-02
Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现为Oracle公司）于1995年发布。它以其“一次编写，到处运行”的特性而闻名，因为Java代码可以跨平台运行，只需一个Java虚拟机（JVM）支持。本节的...
Android 制作系统签名
最新发布
shi450561200的博客
08-03 129
注意：基于AOSP源码制作的test key文件，一般无法使用在真实环境中（例如：手机），车载项目则较为复杂，有的项目在开发阶段，就会使用较为严格的签名校验，那么AOSP的签名文件也是无法使用的。将系统签名引入android studio后，app工程就可以直接在Android模拟器中调用系统API，同时也可以获取更高等级的权限了。制作完成后，会在当前目录下载生成一个platform.jks的签名文件，将它导入到android studio中即可对应用进行签名。
常见的CMS漏洞
C233333235的博客
08-03 336
通过⽇志⽂件拿Shell 利⽤mysql⽇志⽂件写shell，这个⽇志可以在mysql⾥改变它的存放位置，登录phpmyadmin可以修改 这个存放位置，并且可以修改它的后缀名。查到数据库位置后，就可以大概猜测一下网站的根目录，一般www目录在phpstudt_pro下，是Extensions的同级目录。以确认我们的修改生效了，修改成功后，日志文件的后缀就被修改成了php，那么其中的php语句就会被运行。这样日志文件中就会有这个一句话木马的字样，我们去访问日志文件后，就可以进行连接获取shell。
php类与对象
2302_79590880的博客
08-03 198
php类与对象快速入门(直接上简介语法)
Android 实现屏幕录制
wolf0706的专栏
07-30 566
创建屏幕录制的 Service。
面向对象编程：Java学习笔记——类与对象设计原则
Java学习笔记主要聚焦于面向对象编程这一核心概念。面向对象编程（Object-Oriented Programming, OOP）是Java编程中的重要理论基础，它将现实世界中的事物抽象为对象，强调了对象的属性（属性描述了对象的状态）和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值