书籍文库  |  文档资料  |  最近更新  |  MAP  |  TAG  | 
注册
手机版
就爱阅读网
当前位置:首页 > 电脑办公 > 电脑设计 > 程序设计 > [迪米特原则]设计模式6大原则:迪米特法则

[迪米特原则]设计模式6大原则:迪米特法则

分享人:晶莹 来源:互联网 时间:2017-06-18 阅读:0
导读:就爱阅读网友为大家分享了多篇关于“[迪米特原则]设计模式6大原则:迪米特法则”资料,内容精辟独到,非常感谢网友的分享,希望从中能找到对您有所帮助的内容。

相关资料一 : 设计模式6大原则:迪米特法则

迪米特法则(Law of emeter)

定义:一个对象应该对其他对象了解最少

迪米特法则的核心观念就是类间解耦,弱耦合,只有弱耦合了以后,类的复用性才可以提高。

形象一点的比喻类似于:监狱内的犯人是不应该跟外面的人接触的,当然或许会有探亲的。这里的监狱就是类,里面的犯人就是类内部的信息,而监狱里的狱警就相当于迪米特法则的执行者

举个例子

家人探望犯人

家人:家人只与犯人是亲人,但是不认识他的狱友

  1. packagecom.loulijun.chapter5;
  2. publicclassFamily{
  3. //家人探望犯人
  4. publicvoidvisitPrisoner(Prisonersprisoners)
  5. {
  6. //家人希望犯人与狱友互帮互助
  7. Inmatesinmates=prisoners.helpEachOther();
  8. //狱友说,我们是盟友
  9. inmates.weAreFriend();
  10. }
  11. }

犯人:犯人与家人是亲人,犯人与狱友是朋友

  1. packagecom.loulijun.chapter5;
  2. publicclassPrisoners{
  3. privateInmatesinmates=newInmates();
  4. publicInmateshelpEachOther()
  5. {
  6. System.out.println("家人说:你和狱友之间应该互相帮助...");
  7. returninmates;
  8. }
  9. }

狱友:犯人与狱友是朋友,但是不认识他的家人

  1. packagecom.loulijun.chapter5;
  2. //Inmates是狱友的意思
  3. publicclassInmates{
  4. publicvoidweAreFriend()
  5. {
  6. System.out.println("狱友说:我们是狱友...");
  7. }
  8. }

场景类:发生在监狱里

  1. packagecom.loulijun.chapter5;
  2. publicclassPrison{
  3. publicstaticvoidmain(Stringargs[])
  4. {
  5. Familyfamily=newFamily();
  6. family.visitPrisoner(newPrisoners());
  7. }
  8. }

运行结果:

家人说:你和狱友之间应该互相帮助... 狱友说:我们是狱友...

看到这样的结果,是不是有些别扭,家人告诉犯人要与狱友好好相处,而狱友确冒出来说话。这显然越界了,因为监狱只允许家人探望犯人,而不是随便谁都可以见的

这里的家人和狱友有了沟通是违背迪米特法则的,所以我们需要将家人和狱友隔离开,对其进行重构

家人

  1. packagecom.loulijun.chapter5;
  2. publicclassFamily{
  3. //家人探望犯人
  4. publicvoidvisitPrisoner(Prisonersprisoners)
  5. {
  6. System.out.print("家人说:");
  7. prisoners.helpEachOther();
  8. }
  9. }

犯人

  1. packagecom.loulijun.chapter5;
  2. publicclassPrisoners{
  3. privateInmatesinmates=newInmates();
  4. publicInmateshelpEachOther()
  5. {
  6. System.out.println("犯人和狱友之间应该互相帮助...");
  7. System.out.print("犯人说:");
  8. inmates.weAreFriend();
  9. returninmates;
  10. }
  11. }

狱友

  1. packagecom.loulijun.chapter5;
  2. //Inmates是狱友的意思
  3. publicclassInmates{
  4. publicvoidweAreFriend()
  5. {
  6. System.out.println("我们是狱友...");
  7. }
  8. }

监狱

  1. packagecom.loulijun.chapter5;
  2. publicclassPrison{
  3. publicstaticvoidmain(Stringargs[])
  4. {
  5. Familyfamily=newFamily();
  6. family.visitPrisoner(newPrisoners());
  7. }
  8. }

运行结果

家人说:犯人和狱友之间应该互相帮助... 犯人说:我们是狱友...

这样家人和狱友就分开了,但是也表达了家人希望狱友能跟犯人互相帮助的意愿。也就是两个类通过第三个类实现信息传递

网上还有如下一些关于应用迪米特法则的注意事项:

① 在类的划分上,应该创建有弱耦合的类;

② 在类的结构设计上,每一个类都应当尽量降低成员的访问权限;

③ 在类的设计上,只要有可能,一个类应当设计成不变类;

④ 在对其他类的引用上,一个对象对其它对象的引用应当降到最低;

⑤ 尽量降低类的访问权限;

⑥ 谨慎使用序列化功能;

⑦ 不要暴露类成员,而应该提供相应的访问器(属性)。

原文链接:



相关资料二 : 设计模式之六大原则——迪米特法则(LoD,LKP)

定义:

迪米特法则(Law of Demeter,LoD)也称为最少知识原则(Least Knowledge Principle,LKP)。[]

一个对象应该对其他对象有最少的了解。通俗地讲,一个类应该对自己需要耦合或调用的类知道得最少,你(被耦合或调用的类)的内部是如何复杂都和我没关系,那是你的事情,我就知道你提供的public方法,我就调用这么多,其他的一概不关心。

含义:

  • 只和朋友交流

朋友类的定义是这样的:出现在成员变量、方法的输入输出参数中的类称为成员朋友类,而出现在方法体内部的类不属于朋友类。

下面的代码在方法体内部依赖了其他类,这严重违反迪米特法则

public class Teacher {

    public void commond(GroupLeader groupLeader) {
        List<Girl> listGirls = new ArrayList<Girl>();

        for (int i = 0; i < 20; i++) {
            listGirls.add(new Girl());
        }

        groupLeader.countGirls(listGirls);
    }

}

方法是类的一个行为,类竟然不知道自己的行为与其他类产生了依赖关系,这是不允许的。

正确的做法是:

public class Teacher {

    public void commond(GroupLeader groupLeader) {
        groupLeader.countGirls();
    }

}
public class GroupLeader {

    private List<Girl> listGirls;

    public GroupLeader(List<Girl> _listGirls) {
        this.listGirls = _listGirls;
    }

    public void countGirls() {
        System.out.println("女生数量是:" + listGirls.size());
    }

}

注意:一个类只和朋友交流,不与陌生类交流,不要出现getA().getB().getC().getD()这种情况(在一种极端情况下允许出现这种访问,即每一个点号后面的返回类型都相同),类与类之间的关系是建立在类间的,而不是方法间,因此一个方法尽量不引入一个类中不存在的对象,当然,JDK API提供的类除外。

  • 朋友间也是有距离的

一个类公开的public属性或方法越多,修改时涉及的面也就越大,变更引起的风险扩散也就越大。因此,为了保持朋友类间的距离,在设计时需要反复衡量:是否还可以再减少public方法和属性,是否可以修改为private、package-private(包类型,在类、方法、变量前不加访问权限,则默认为包类型)、protected等访问权限,是否可以加上final关键字等。

注意:迪米特法则要求类“羞涩”一点,尽量不要对外公布太多的public方法和非静态的public变量,尽量内敛,多使用private、package-private、protected等访问权限。

  • 是自己的就是自己的

如果一个方法放在本类中,既不增加类间关系,也对本类不产生负面影响,就放置在本类中。

  • 谨慎使用Serializable

最后,迪米特法则的核心观念就是类间解耦,弱耦合,只有弱耦合了以后,类的复用率才可以提高。



相关资料三 : 迪米特原则

迪米特原则

迪米特原则(Law of Demeter)

1、迪米特原则的定义

迪米特原则也叫最少知识原则(Least Knowledge Principle, LKP)简单的说,就是如果两个类不必彼此直接通信,那么这两个类就不应当发生直接的相互作用。[]如果一个类需要调用类另一个类的某个方法的话,应当通过第三个类来转发调用。迪米特法则可以简单说成:talk only to your immediate friends。

2、迪米特原则解释

一个软件实体应当尽可能少的与其他实体发生相互作用。每一个软件单位对其他的单位都只有最少的知识,而且局限于那些与本单位密切相关的软件单位。迪米特法则减少耦合的问题,类之间的耦合越弱,越有利于复用,一个处在弱耦合的类被修改,不会对有关系的类造成波及。也就是说,信息的隐藏促进了软件的复用。

3、迪米特原则含义

(1)、talk only to your immediate friends.只和直接朋友通信。在一个类中,出现在成员变量、方法的输入输出参数中的类被称为成员朋友类。

实例:张三李四是朋友关系,李四王五是朋友关系.张三和王五是陌生人关系,为了保证张三和王五不认识,而张三又能调用王五中的方法,通过一个李四作为中继,把张三和王五隔离开来。

(2)、迪米特法则就要求类“小气”一点,尽量不要对外公布太多的public 方法和非静态的public 变量,尽量内敛,

多使用private,package-private、protected 等访问权限。

实例:在软件的安装中,一个类中定义了多个步骤,同时一个类要调用此类中的方法完成安装,此时可以在客户端的类中随即地调用这些步骤,这样前边的类就定义多个public的方法,我们转换一种思路,把这些步骤方法都设置为private,同时,引入一个总的方法,在总的方法中调用安装步骤方法,避免了客户类和此类中多个方法的接触。

import java.util.Random;

/**

* 按照步骤执行的业务逻辑类

*/

public class Wizard {

private Random rand = new Random(System.currentTimeMillis());

//第一步

private int first(){

System.out.println("执行第一个方法...");

return rand.nextInt(100);

}

//第二步

private int second(){

System.out.println("执行第二个方法...");

return rand.nextInt(100);

}

//第三个方法

迪米特 迪米特原则

private int third(){

System.out.println("执行第三个方法...");

return rand.nextInt(100);

}

//软件安装过程

public void installWizard(){

int first = this.first();

//根据first返回的结果,看是否需要执行second

if(first>50){

int second = this.second();

if(second>50){

int third = this.third();

if(third >50){

this.first();

}

}

}

}

/**

* 业务组装类,负责调用各个步骤

*/

public class InstallSoftware {

public void installWizard(Wizard wizard){

//直接调用

wizard.installWizard();

}

}

(3)、如果一个方法放在本类中,即不增加类间关系,也对本类不产生负面影响,就放置在本类中。(]组合/聚合与之相似。

(4)、谨慎使用Serializable。

4、迪米特原则优缺点

由于狭义迪米特法则要求当两个类不必直接通信时,进行方法调用应当由第三个类来转发调用,这样就会在系统里制造出大量的小方法,是的系统显的凌乱。

迪米特法则的知识最小化,可以使得局部的模块得到简化,但是同时也会造成模块间的通信效率降低,使模块间不容易协调。

迪米特法则讨论的是对象之间信息的流量,方向以及信息影响的控制。其主要意图是控制信息过载,这就要求一个模块一个应当尽可能将自己的内部数据和实现细节隐藏起来,也就是要求有良好的封装。

因此,在类设计上的应用优先考虑将一个类设计成不变类,即使这个类是可变的在给她的属性设置赋值方法时,也应当尽可能的吝啬,除非确实需要,否则不要对该属性增加赋值方法。尽量降低一个类的访问权限,谨慎使用Serializable,尽量降低成员的访问权限。

迪米特 迪米特原则

设计模式的门面模式(Facade)和中介模式(Mediator),都是迪米特法则应用的例子。[)

以上关于“[迪米特原则]”的信息由网友上传分享,希望对您有所帮助 ,感谢您对就爱阅读网的支持!

热点阅读

网友最爱