面向对象的六大原则之 —— 迪米特原则

最新推荐文章于 2023-10-19 16:33:49 发布
最新推荐文章于 2023-10-19 16:33:49 发布
阅读量4k 收藏 4
点赞数 1
分类专栏： android 设计模式 面向对象 文章标签： 面向对象 设计模式 android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asd2603934/article/details/50777488
版权

学习了何红辉、关爱民写的《Android设计模式》，对于面向对象的六大原则有进一步的理解，特此根据自己的理解记录总结一下

什么是迪米特原则

也称为最少知识原则，意思就是一个对象应该对其他对象有最少的了解，其实就是解耦合，两个类之间的关系分离的越细越好，比如面向对象的六大原则之 —— 单一原则中讲的，Imageloader类，它需要缓存，然而缓存ImageCache的具体实现，ImageLoader是不知道的。

我们打个比方，你卖肾跟iphone代理商买了一台 Iphone100 ，结果用了几天，泥马坏了，你是不是应该把手机给回代理商去保修，然而你是不需要知道，人家是怎么保修的，你只需要把手机给回代理商，让人家去保修，其他的你一概不管，保修不好就还肾，就这么简单。

实际运用一下，我们原本的ImageLoader类是直接跟内存缓存打交道的

import android.graphics.Bitmap;  
import android.graphics.BitmapFactory;  
import android.util.LruCache;  
import android.widget.ImageView;  
  
import java.io.IOException;  
import java.net.HttpURLConnection;  
import java.net.MalformedURLException;  
import java.net.URL;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
/** 
 * Created by Administrator on 2016/3/1. 
 */  
public class ImageLoader {  
  
    public ImageLoader() {  
    }  
  
    //图片缓存类  
    ImageCache imageCache=new ImageCache();  
    //线程池，线城数量为cpu的数量  
    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());  
  
    /** 
     * 显示图片 
     * @param url 图片的url 
     * @param imageView 要显示的view 
     */  
    public void displayImage(final String url, final ImageView imageView) {  
        Bitmap bitmap=imageCache.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);  
                }  
                imageCache.put(url, bitmap);  
            }  
        });  
    }  
    /** 
     * 下載圖片 
     * @param imageUrl 网络图片地址 
     * @return 返回bitmap对象 
     */  
    public Bitmap downloadImage(String imageUrl) {  
        Bitmap bitmap = null;  
        try {  
            URL url = new URL(imageUrl);  
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
            bitmap = BitmapFactory.decodeStream(conn.getInputStream());  
            conn.disconnect();  
        } catch (MalformedURLException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        return bitmap;  
    }  
}


ImageCache类 

import android.graphics.Bitmap;  
import android.util.LruCache;  
  
/** 
 * Created by Administrator on 2016/3/1. 
 */  
public class ImageCache {  
  
    public ImageCache() {  
        //初始化图片缓存  
        initImageCache();  
    }  
  
    //图片缓存类  
    LruCache<String, Bitmap> imageCache;  
  
    /** 
     * 初始化缓存 
     */  
    private void initImageCache() {  
        //计算可使用的最大内存  
        int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);  
        //只用最大内存的四分之一作为缓存大小  
        int cacheSize = maxMemory / 4;  
        imageCache = new LruCache<String, Bitmap>(cacheSize) {  
            @Override  
            protected int sizeOf(String key, Bitmap value) {  
                return value.getRowBytes() * value.getHeight() / 1024;  
            }  
        };  
    }  
  
    /** 
     * 添加缓存 
     * 
     * @param url    缓存的图片url作为缓存的key 
     * @param bitmap 缓存的bitmap 
     */  
    public void put(String url, Bitmap bitmap) {  
        imageCache.put(url, bitmap);  
    }  
  
    /** 
     * 获取缓存的图片 
     * 
     * @param url 
     * @return 
     */  
    public Bitmap get(String url) {  
        Bitmap bitmap = null;  
        bitmap = imageCache.get(url);  
        return bitmap;  
    }  
}

你会发现，我们的Imageloader在实现缓存的时候，就需要直接跟缓存类ImageCache打交道。

我们想一下，给个代理商的类

这个代理商类，我们就直接命名为ImageCache，所以，ImageCache现在的内容如下

import android.graphics.Bitmap;  
  
/** 
 * Created by Administrator on 2016/3/1. 
 */  
public interface ImageCache {  
    /** 
     * 添加缓存 
     * @param url    缓存的图片url作为缓存的key 
     * @param bitmap 缓存的bitmap 
     */  
    public void put(String url, Bitmap bitmap);  
  
    /** 
     * 获取缓存的图片 
     * @param url 
     * @return 
     */  
    public Bitmap get(String url);  
}

ImageCache只需要作为你的iphone手机跟厂商的桥梁，而现在的厂商是ImageLoader，它直接跟代理商ImageCache打交道 

import android.graphics.Bitmap;  
import android.graphics.BitmapFactory;  
import android.widget.ImageView;  
  
import java.io.IOException;  
import java.net.HttpURLConnection;  
import java.net.MalformedURLException;  
import java.net.URL;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
/** 
 * Created by Administrator on 2016/3/1. 
 */  
public class ImageLoader {  
  
    public ImageLoader() {  
    }  
  
    //默认使用内存缓存  
    ImageCache imageCache=new MemoryCache();  
  
    //线程池，线城数量为cpu的数量  
    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());  
  
    /** 
     * 设置要使用哪种缓存 
     * @param imageCache 缓存类 
     */  
    public void setImageCache(ImageCache imageCache) {  
        this.imageCache = imageCache;  
    }  
  
    /** 
     * 显示图片 
     * @param url 图片的url 
     * @param imageView 要显示的view 
     */  
    public void displayImage(final String url, final ImageView imageView) {  
        Bitmap bitmap=imageCache.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);  
                }  
                //添加到缓存  
                imageCache.put(url, bitmap);  
            }  
        });  
    }  
  
    /** 
     * 下載圖片 
     * @param imageUrl 网络图片地址 
     * @return 返回bitmap对象 
     */  
    public Bitmap downloadImage(String imageUrl) {  
        Bitmap bitmap = null;  
        try {  
            URL url = new URL(imageUrl);  
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
            bitmap = BitmapFactory.decodeStream(conn.getInputStream());  
            conn.disconnect();  
        } catch (MalformedURLException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        return bitmap;  
    }  
}

这个时候，我们只需要建立一个实现了ImageCache接口的实现类，也就是买了iphone100的你自己 

import android.graphics.Bitmap;  
import android.util.LruCache;  
  
/** 
 * Created by Administrator on 2016/3/1. 
 */  
public class MemoryCache implements ImageCache{  
  
    public MemoryCache() {  
        //初始化图片缓存  
        initImageCache();  
    }  
  
    //图片缓存类  
    LruCache<String, Bitmap> memoryCache;  
  
    /** 
     * 初始化缓存 
     */  
    private void initImageCache() {  
        //计算可使用的最大内存  
        int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);  
        //只用最大内存的四分之一作为缓存大小  
        int cacheSize = maxMemory / 4;  
        memoryCache = new LruCache<String, Bitmap>(cacheSize) {  
            @Override  
            protected int sizeOf(String key, Bitmap value) {  
                return value.getRowBytes() * value.getHeight() / 1024;  
            }  
        };  
    }  
  
    /** 
     * 添加缓存 
     * 
     * @param url    缓存的图片url作为缓存的key 
     * @param bitmap 缓存的bitmap 
     */  
    public void put(String url, Bitmap bitmap) {  
        memoryCache.put(url, bitmap);  
    }  
  
    /** 
     * 获取缓存的图片 
     * 
     * @param url 
     * @return 
     */  
    public Bitmap get(String url) {  
        Bitmap bitmap = null;  
        bitmap = memoryCache.get(url);  
        return bitmap;  
    }  
}

这样，我们就实现了迪米特原则，一个对象应该对其他对象有最少的了解，即两个类之间没有直接关系，也就降低了耦合度，在需要添加一个卖肾买iphone的人的时候，只需要实现ImageCache接口，就能实现保修。

对于上面的解释你可能会比较迷糊，我专业点解释一下，其实就是，我们这个ImageLoader图片加载器原先在实现缓存的时候，是直接跟缓存类ImageCache打交道的，也就说明了，一但我们需要添加新的缓存方式，我们就需要更改ImageLoader里面的代码，这样明显的说明了，两个类之间是有直接关系的，而迪米特原则就是，不要有直接关系，或者说，关系越小越好，所以，我们拆开来，搞了一个中间的接口ImageCache，而真正的实现缓存的MemoryCache内存缓存类，实现了ImageCache接口，在ImageLoader中，我们只需要使用ImageCache接口就行，这样，用户在使用哪一种缓存的时候，只要实现ImageCache接口就能实现自己想要的缓存方式，而且还不需要修改ImageLoader类里面的代码，只需要通过调用ImageLoader里面的

  1. /** 
  2.      * 设置要使用哪种缓存 
  3.      * @param imageCache 缓存类 
  4.      */  
  5.     public void setImageCache(ImageCache imageCache) {  
  6.         this.imageCache = imageCache;  
  7.     }  
这个方法就能通过依赖注入的方式，选择自己想要使用的缓存方式。

上一篇：《面向对象的六大原则之 —— 接口隔离原则》         


穿着内裤的外星人
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
7大设计原则（迪米特法则）
高哥哥的专栏
03-22 381
迪米特法则迪米特法则产生背景迪米特法则的定义迪米特法则的作用正确使用迪米特法则的优点过度使用迪米特法则的缺点迪米特法则的实现方法 迪米特法则产生背景 迪米特法则（Law of Demeter，LoD）又叫作最少知识原则（Least Knowledge Principle，LKP)，产生于 1987 年美国东北大学（Northeastern University）的一个名为迪米特（Demeter）...
设计模式七大原则——迪米特原则
胜天半子祁同伟
02-06 8771
设计模式七大原则——迪米特原则
设计原则之【迪米特法则】，非礼勿近
秃了也弱了
05-08 2417
迪米特原则（Law of Demeter LoD）是指一个对象应该对其他对象保持最少的了解，又叫最少知道原则（Least Knowledge Principle,LKP），尽量降低类与类之间的耦合。迪米特原则主要强调只和朋友交流，不和陌生人说话。出现在成员变量、方法的输入、输出参数中的类都可以称之为成员朋友类，而出现在方法体内部的类不属于朋友类。其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。
六大设计原则之迪米特原则
hfreeman2008的专栏
08-27 4018
迪米特原则的定义迪米特原则(Law of Demeter,LoD)，也叫最少知识原则(Low knowledge Principle,LKP):一个对象应该对其他对象有最少的了解。通俗的讲：一个类对自己需要耦合或调用的类知道的最少，你(被耦合或调用的类)的内部是如何复杂和我没有关系，我就知道你提供的public方法，我只调用这些方法，其它的我不关心。迪米特原则的具体要求迪米特原则对类的低耦合提出了明
软件设计原则-迪米特原则讲解以及代码示例
最新发布
小电玩
10-19 119
迪米特原则（Law of Demeter，简称LoD）也被称为最少知识原则（Least Knowledge Principle，LKP），是面向对象设计的一种重要原则。迪米特原则的核心思想是尽量减少对象之间的交互，使得系统中的模块能够相对独立地变化。
设计原则——迪米特原则
FatPuffer
10-21 371
设计原则之迪米特原则
面向对象六大原则demo
03-17
面向对象六大原则是软件开发中面向对象编程的重要理论基础，它们分别是单一职责原则（Single Responsibility Principle, SRP）、开闭原则（Open/Closed Principle, OCP）、里氏替换原则（Liskov Substitution ...
JavaScript面向对象之七大基本原则实例详解
10-15
主要介绍了JavaScript面向对象之七大基本原则,结合实例形式详细分析了JavaScript面向对象七大基本原则,包括单一职责、开闭原则、里氏替换、依赖倒置、接口隔离、迪米特法则及组合/聚合复用原则,需要的朋友可以参考下
C#面向对象设计的七大原则
09-02
本文将详细介绍C#面向对象设计的七大原则，这些原则是指导我们编写可维护、可扩展的高质量代码的关键。 1. **开闭原则**：开闭原则主张软件实体（如类、模块、函数等）应该对扩展开放，对修改关闭。这意味着在不...
六大设计原则.docx
07-28
【六大设计原则】是软件开发中的核心指导原则，它们包括单一职责原则（Single Responsibility Principle，SRP）、开闭原则（Open Closed Principle，OCP）、里氏替换原则（Liskov Substitution Principle，LSP）、...
迪米特法则
qq_57756904的博客
01-09 1547
一、迪米特法则的定义 迪米特法则(Law of Demeter, LoD)也称为最少知识原则(Least Knowledge Principle, LKP)，它们的意思为：一个对象应该对其他对象有最少的了解。通俗的讲，一个类对自己需要耦合或调用的类知道得最少，你（调用的类的）的内部是多么复杂都和我没有关系，那是你的事情，我只关心你提供的public方法，你提供我就调用，其他一概不关心。 二、我的知识你知道的越少越好 1、只和朋友交流 迪米特法则还有一个英文解释：Only talk to yo..
设计原则之迪米特原则
Black&White的专栏
05-17 187
迪米特原则 Law of Demeter, LOD 迪米特原则定义 迪米特原则也叫最小知识原则（The Least Knowledge Principle）。即，每个模块只应该了解那些与它关系密切的模块的有限知识，或者说，每个模块只和自己的朋友”说话“，不和陌生人”说话“。 这里的模块可以是微服务、框架、组件、类库、模块、类、甚至是函数，以下的描述主要以“类”作为迪米特原则的描述对象。 什么是朋友和陌生人 对类来说，出现在成员变量以及方法对输入输出参数中对类是朋友类，出现在方法体内部的类不是朋友类，是陌生人
软件设计七大原则：（五）迪米特原则
Evan's Blog ٩(๑❛ᴗ❛๑)۶
06-07 421
一、迪米特原则简介 定义：一个对象应该对其他对象保持最少的了解。又叫最少知道原则。 尽量降低类与类之间的耦合 优点：降低类之前的耦合 强调只和朋友交流，不和陌生人说话 什么是朋友类？ 朋友类指的是出现在成员变量、方法的输入、输出参数中的类称为成员朋友类，而出现在方法体内部的类不属于朋友类。 二、代码实现 1.违背迪米特原则的反例 public class Course { } public class Boss { public void commandCheckNumber(TeamLead
【设计模式】迪米特原则
StudyWinter的博客
04-24 174
迪米特法则，也称为最少知识原则。如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用，如果其中一个类需要调用另一个类的某一个方法的话，可以通过第三者转发这个调用。 即一个对象应该对其他对象有最少的了解，就是一个类应该对自己需要耦合或调用的类知道的最少，被耦合或调用的类内部是如何的复杂和我没有任何的关系，我只需知道它们提供的public方法即可。 迪米特法则首先强调的前提是在类的结构设计上，每一个类都应当尽量降低成员的访问权限，也就是说，一个类包装好自己的private状态，不需要让别.
Android设计模式之迪米特原则
Androidbye的博客
08-13 174
一、定义 迪米特原则（LOD：Law of Demeter）：一个类对于其他类知道的越少越好，就是说一个对象应当对其他对象有尽可能少的了解，只和朋友通信，不和陌生人说话。 二、场景运用 小明去找中介租房，他的原则是：只要求房子的面积和租金，其他一律不管，中介将符合要求的房子给到他就行。 /** * 租客 */ public class Tenant { private static final String TAG = Tenant.class.getSimpleName();
设计模式六大原则(五)迪米特法则（最少知道原则）
高兴的地方
08-25 1164
<br />10.3.5  迪米特法则（最少知道原则）（Demeter Principle）<br />迪米特法则（Law of Demeter）又叫最少知道原则（Least Knowledge Principle），1987年秋天由美国Northeastern University的Ian Holland提出，被UML的创始者之一Booch等普及。后来，因为在经典著作《 The Pragmatic Programmer》中提出而广为人知。<br />迪米特法则可以简单说成：talk only to you
JAVA设计模式六大原则：（5）迪米特法则
上善若泪
05-31 748
1 定义 迪米特法则定义：一个对象应该对其他对象保持最少的了解。 2 描述 问题由来：类与类之间的关系越密切，耦合度越大，当一个类发生改变时，对另一个类的影响也越大。 解决方案：尽量降低类与类之间的耦合。 自从我们接触编程开始，就知道了软件编程的总的原则：低耦合，高内聚。无论是面向过程编程还是面向对象编程，只有使各个模块之间的耦合尽量的低，才能提高代码的复用率。低耦合的优点不言而喻，但是...
面向对象的六大原则（一）
小黄人的博客
08-07 480
单一职责原则 读《Android源码设计模式》 单一职责的定义为：就一个类而言，应该仅有一个引起它变化的原因，简单来说，一个类中应该是一组相关性很高的函数，数据的封装 我们从最入门的方式入手 入手 假设现在要实现图片加载的功能，并且能将图片缓存，我们可能写出的代码是这样的 public class ImageLoader { //图片缓存 LruCach...
面向对象如何理解？六大设计原则？
04-25
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程思想，它将现实世界中的对象抽象为程序中的对象，并且通过对象之间的交互来完成指定的任务。 在面向对象编程中，对象是代码的基本单元，它包含了数据和一些与数据相关的操作方法。 这些对象可以相互交互，通过消息传递和方法调用实现程序功能。 六大设计原则（SOLID）是指： 1.单一职责原则（Single Responsibility Principle，SRP）：一个类只负责一个功能领域中的相应职责。 2.开闭原则（Open-Closed Principle，OCP）：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。 3.里氏替换原则（Liskov Substitution Principle，LSP）：子类可以替换父类出现在程序任何地方，并且能够保证原功能不受影响。 4.依赖倒置原则（Dependency Inversion Principle，DIP）：高层模块不应该依赖底层模块，二者都应该依赖其抽象，抽象不应该依赖细节，细节应该依赖抽象。 5.接口隔离原则（Interface Segregation Principle，ISP）：使用多个专门的接口，而不是使用单一的总接口，客户端不必依赖于它不需要的方法。 6.迪米特法则（Law of Demeter，LoD）：一个软件实体应当尽可能少地与其他实体发生相互作用，应当尽量减少对象之间的依赖关系。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值