zoukankan      html  css  js  c++  java
  • 北风设计模式课程---35、迪米特法则

    北风设计模式课程---35、迪米特法则

    一、总结

    一句话总结:

    一个对象应当对其他对象尽可能少的了解

    1、如何用依赖倒置原则实现 迪米特法则?

    依赖抽象,不依赖具体:比如和陌生人的抽象有依赖,但是没和具体的陌生人有依赖。

    2、迪米特法则 实例(比如我要和陌生人通信)?

    1、通过第三方:通过朋友类
    2、依赖倒置原则:通过抽象:通过陌生人的抽象类

    3、什么是迪米特法则?

    一个对象应当对其他对象尽可能少的了解


       迪米特法则(Law of Demeter )又叫做最少知识
    原则,也就是说,一个对象应当对其他对象尽可
    能少的了解。
        迪米特法则最初是用来作为面向对象的系统设
    计风格的一种法则,于1987年秋天由lan holland
    在美国东北大学为一个叫做迪米特的项目设计提
    出的。

    4、狭义的迪米特法则?

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

    5、迪米特法则和设计模式?

    1.外观模式
    2.中介者模式

    二、面向对象五大原则-----迪米特法则

    转自或参考:面向对象五大原则-----迪米特法则
    https://www.cnblogs.com/xiaobai1226/p/8670245.html

      什么是迪米特法则

      迪米特法则(Law of Demeter )又叫做最少知识原则,也就是说,一个对象应当对其他对象尽可能少的了解。不和陌生人说话。英文简写为: LoD。

      迪米特法则最初是用来作为面向对象的系统设计风格的一种法则,于1987年秋天由lan holland在美国东北大学为一个叫做迪米特的项目设计提出的。

      迪米特法则的模式与意义

      迪米特法则可以简单说成:talk only to your immediate friends。 对于OOD来说,又被解释为下面几种方式:一个软件实体应当尽可能少的与其他实体发生相互作用。每一个软件单位对其他的单位都只有最少的知识,而且局限于那些与本单位密切相关的软件单位。

      迪米特法则的初衷在于降低类之间的耦合。由于每个类尽量减少对其他类的依赖,因此,很容易使得系统的功能模块功能独立,相互之间不存在(或很少有)依赖关系。

      迪米特法则不希望类之间建立直接的联系。如果真的有需要建立联系,也希望能通过它的友元类来转达。因此,应用迪米特法则有可能造成的一个后果就是:系统中存在大量的中介类,这些类之所以存在完全是为了传递类之间的相互调用关系——这在一定程度上增

    加了系统的复杂度。

      狭义的迪米特法则

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

      这么看不太形象,我们来举个例子,和陌生人说话,甲和朋友认识,朋友和陌生人认识,而甲和陌生人不认识,这时甲可以直接和朋友说话,朋友可以直接和陌生人说话,而如果甲想和陌生人说话,就必须通过朋友

      首先,第一种方式代码实现:

    1 public class Jia{
    2     public void play(Friend friend){
    3         friend.play();
    4     }
    5     
    6     public void play(Stranger stranger) {
    7         stranger.play();
    8     }
    9 }
    1 //朋友
    2 public class Friend {
    3     public void play(){
    4         System.out.println("朋友");
    5     }
    6 }
    1 //陌生人
    2 public class Stranger {
    3     public void play(){
    4         System.out.println("陌生人");
    5     }
    6 }

      这种方式是肯定不对的,甲根本没有通过朋友,直接引用了陌生人的方法,不符合迪米特法则

      第二种方式

       

       代码实现

    1 //
    2 public class Jia{
    3     public void play(Friend friend){
    4         friend.play();
    5         Stranger stranger = friend.getStranger();
    6         stranger.play();
    7     }
    8 }
     1 //朋友
     2 public class Friend {
     3     public void play(){
     4         System.out.println(朋友");
     5     }
     6     
     7     public Stranger getStranger() {
     8         return new Stranger();
     9     }
    10 }
    1 //陌生人
    2 public class Stranger {
    3     public void play(){
    4         System.out.println("陌生人");
    5     }
    6 }

      这样的方式呢,看上去陌生人的实例是通过朋友来创建了,但还是不行,因为甲中包含的陌生人的引用,甲还是和陌生人直接关联上了,所以,不符合迪米特法则,我们要的是甲和陌生人没有一丁点直接关系

      第三种方式

     1 //
     2 public class Jia{
     3     private Friend friend;
     4     
     5     public Friend getFriend() {
     6         return friend;
     7     }
     8 
     9     public void setFriend(Friend friend) {
    10         this.friend = friend;
    11     }
    12 
    13     public void play(Friend friend){
    14         friend.play();
    15     }
    16 }
     1 //朋友
     2 public class Friend {
     3     public void play(){
     4         System.out.println("朋友");
     5     }
     6     
     7     public void playWithStranger() {
     8         Stranger stranger = new Stranger();
     9         stranger.play();
    10     }
    11 }
    1 public class Stranger {
    2     public void play(){
    3         System.out.println("陌生人");
    4     }
    5 }

       这种方式,甲和陌生人之间就没有了任何直接联系,这样就避免了甲和陌生人的耦合度过高

      当然还有一种更好的方式,与依赖倒转原则结合,为陌生人创建一个接口

     1 //
     2 public class Jia{
     3     private Friend friend;
     4     private Stranger stranger;
     5 
     6     public Stranger getStranger() {
     7         return stranger;
     8     }
     9 
    10     public void setStranger(Stranger stranger) {
    11         this.stranger = stranger;
    12     }
    13 
    14     public Friend getFriend() {
    15         return friend;
    16     }
    17 
    18     public void setFriend(Friend friend) {
    19         this.friend = friend;
    20     }
    21 
    22     public void play() {
    23         System.out.println("someone play");
    24         friend.play();
    25         stranger.play();
    26     }
    27 }
    1 public class Friend {
    2     public void play(){
    3         System.out.println("朋友");
    4     }
    5 }
    1 //陌生人抽象类
    2 public abstract class Stranger {
    3     public abstract void play();
    4 }
    1 //具体陌生人
    2 public class StrangerA extends Stranger {
    3 
    4     public void play() {
    5         System.out.println("陌生人");
    6     }
    7 
    8 }

      这样的方式,和甲直接通信的是陌生人的抽象父类,和具体陌生人没有直接关系,所以符合迪米特法则

      狭义的迪米特法则的缺点:

      1、在系统里造出大量的小方法,这些方法仅仅是传递间接的调用,与系统的商务逻辑无关。

      2、遵循类之间的迪米特法则会是一个系统的局部设计简化,因为每一个局部都不会和远距离的对象有直接的关联。但是,这也会造成系统的不同模块之间的通信效率降低,也会使系统的不同模块之间不容易协调。

      迪米特法则应用实例

      1.外观模式

      2.中介者模式

     
  • 相关阅读:
    【JAVA笔记——道】JAVA对象销毁
    【JAVA笔记——道】并发编程CAS算法
    httpClientUtil的get请求
    python基础 day11 下 ORM介绍 sqlalchemy安装 sqlalchemy基本使用 多外键关联 多对多关系 表结构设计作业
    python基础 day11 上 数据库介绍 mysql 数据库安装使用 mysql管理 mysql 数据类型 常用mysql命令 事务 索引 python 操作mysql ORM sqlachemy学习
    Python基础 Day10 Gevent协程 SelectPollEpoll异步IO与事件驱动 Python连接Mysql数据库操作 RabbitMQ队列 RedisMemcached缓存 Paramiko SSH Twsited网络框架
    python基础 day9 进程、与线程区别 python GIL全局解释器锁 线程 进程
    python基础 day8 Socket语法及相关 SocketServer实现多并发
    python基础 day7 面向对象高级语法部分 异常处理 异常处理 Socket开发基础
    python基础 day6 面向对象的特性:封装、继承、多态 类、方法、
  • 原文地址:https://www.cnblogs.com/Renyi-Fan/p/11111113.html
Copyright © 2011-2022 走看看