`
memorymyann
  • 浏览: 271052 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

依赖倒转原则和工厂模式

 
阅读更多

依赖倒转原则讲的是:要依赖于抽象,不要信赖于实现。 这是为实现开闭原则的一种手段。

 

比如之前的代码,我们的主程序中:

Graph g = new xxx();

......

g.getArea();

 

对g的声明则是Graph,而非具体的三角或者原型。我们下面的一切对g的操作,都是依赖Graph,而非对具体的图形的依赖。但只有在初始化g的时候,我们必须制定三角Graph g = new Triangl()或者圆形Graph g = new Circle();这就和依赖倒转原则冲突。由此引入工厂模式。

 

简单工厂模式:

package sty;

public class GraphFactory {

    public static Graph createGraph(String type) {
        Graph g = null;
        if(type.equals("triangle"))
            g = new Triangle();
        if(type.equals("Circle"))
            g = new Circle();
        return g;
    }
}

 

抽象工厂模式,直接从别人哪儿拷贝来的代码

  1. //  产品 Plant接口         
  2. public   interface  Plant {   
  3. }   
  4.   
  5. // 具体产品PlantA,PlantB   
  6. public   class  PlantA  implements  Plant {   
  7.   
  8.      public  PlantA() {   
  9.         System.out.println( " create PlantA ! " );   
  10.     }   
  11.   
  12.      public   void  doSomething() {   
  13.         System.out.println( "  PlantA do something  " );   
  14.     }   
  15. }   
  16.   
  17. public   class  PlantB  implements  Plant {   
  18.      public  PlantB() {   
  19.         System.out.println( " create PlantB ! " );   
  20.     }   
  21.   
  22.      public   void  doSomething() {   
  23.         System.out.println( "  PlantB do something  " );   
  24.     }   
  25. }   
  26.   
  27. // 产品 Fruit接口   
  28. public   interface  Fruit {   
  29. }   
  30.   
  31. // 具体产品FruitA,FruitB   
  32. public   class  FruitA  implements  Fruit {   
  33.      public  FruitA() {   
  34.         System.out.println( " create FruitA ! " );   
  35.     }   
  36.   
  37.      public   void  doSomething() {   
  38.         System.out.println( "  FruitA do something  " );   
  39.     }   
  40. }   
  41.   
  42. public   class  FruitB  implements  Fruit {   
  43.      public  FruitB() {   
  44.         System.out.println( " create FruitB ! " );   
  45.     }   
  46.   
  47.      public   void  doSomething() {   
  48.         System.out.println( "  FruitB do something  " );   
  49.     }   
  50. }   
  51.   
  52. // 抽象工厂方法   
  53. public   interface  AbstractFactory {   
  54.      public  Plant createPlant();   
  55.   
  56.      public  Fruit createFruit();   
  57. }   
  58.   
  59. // 具体工厂方法   
  60. public   class  FactoryA  implements  AbstractFactory {   
  61.      public  Plant createPlant() {   
  62.          return   new  PlantA();   
  63.     }   
  64.   
  65.      public  Fruit createFruit() {   
  66.          return   new  FruitA();   
  67.     }   
  68. }   
  69.   
  70. public   class  FactoryB  implements  AbstractFactory {   
  71.      public  Plant createPlant() {   
  72.          return   new  PlantB();   
  73.     }   
  74.   
  75.      public  Fruit createFruit() {   
  76.          return   new  FruitB();   
  77.     }   
  78. }  

 

 

分享到:
评论

相关推荐

    设计模式之依赖倒转原则

    依赖倒转原则(Dependency Inversion Principle,DIP)是面向对象设计的基本原则之一,它在软件工程中扮演着至关重要的角色。这个原则主要是为了降低模块之间的耦合度,提高系统的可扩展性和可维护性。在C#编程语言...

    依赖倒转原则例子程序DIP.zip

    在DIP的应用中,我们经常看到设计模式如工厂模式、策略模式、观察者模式等,它们都是依赖倒转原则的具体实践。这些模式有助于创建松耦合、高内聚的系统,从而提高软件的可维护性和可扩展性。 总结起来,依赖倒转...

    第二十九讲:基础四依赖倒转原则

    依赖倒转原则(Dependency Inversion Principle,简称DIP)是软件设计中的一个重要原则,它在面向对象编程领域具有深远的影响。这一原则的核心思想是“高层模块不应该依赖于低层模块,两者都应该依赖于抽象”。简单...

    依赖倒置原则Demo

    以设计模式为例,依赖倒置原则在很多模式中都有体现,如工厂模式、策略模式、观察者模式等。在工厂模式中,我们定义一个工厂接口,具体的生产逻辑由各个具体的工厂类实现,这样调用者只需要依赖工厂接口,无需关心...

    Java依赖倒转原则_动力节点Java学院整理

    依赖倒转原则是软件开发中的一个基本原则,尤其在Java编程中具有重要的意义。该原则指出,高层模块(通常处理复杂的业务逻辑)不应当直接依赖于底层模块(通常是基础的、具体的实现),两者都应该依赖于它们的抽象。...

    面向对象设计原则和设计模式的概念

    面向对象设计原则与设计模式是软件工程领域的重要组成部分,它们为构建高质量、可维护和可扩展的软件系统提供了指导方针。下面将详细阐述面向对象设计原则及其如何促进软件的复用,以及设计模式的概念。 ### 面向...

    24种设计模式C#版

    3、依赖倒转原则【DEPENDENCE INVERSION PRINCIPLE】:高层模块不应该依赖低层模块,二者都应该依赖其抽象;抽象不应该依赖细节;细节应该依赖抽象。即针对接口编程,不要针对实现编程。 4、接口隔离原则...

    24种设计模式介绍与6大设计原则

    3、依赖倒转原则(Dependence Inversion Principle) 这个是开闭原则的基础,具体内容:真对接口编程,依赖于抽象而不依赖于具体。 4、接口隔离原则(Interface Segregation Principle) 这个原则的意思是:使用...

    Java与模式(清晰书签版) 设计模式 part3

    第1章 模式的简史和形而上学 ...第8章 依赖倒转原则 第9章 接口隔离原则 第10章 合成、聚合复用原则 第11章 迪米特法则 第12章 简单工厂模式 第13章 工厂方法模式 第14章 抽象工厂模式 第15章 单例模式 第16章 .......

    工厂方法模式.docx

    工厂方法模式是设计模式中的创建型模式...同时,通过定义接口,降低了系统内部组件之间的耦合,遵循了依赖倒转原则和接口隔离原则。在实际开发中,工厂方法模式被广泛应用于框架和库的设计,以提供灵活的组件创建机制。

    面向对象设计原则Java概要.ppt

    单一职责原则、开闭原则、里氏代换原则、依赖倒转原则、接口隔离原则、合成复用原则和迪米特法则相互补充,共同构成了面向对象设计的基石。理解并熟练应用这些原则,可以有效提高软件开发的效率,降低维护成本,实现...

    java 设计模式试题

    面向对象的六大基本原则包括开闭原则、里氏替换原则、合成聚合原则、依赖倒转原则、迪米特法则和单一职责原则。这些原则有助于指导开发者编写高质量的面向对象代码。 ### 22. 方法和数据的集中 在存在继承关系的...

    C++设计模式

    依赖倒转原则 7 (三)装饰模式 7 (四)代理模式 9 (五)工厂方法模式 11 (六)原型模式 13 (七)模板方法模式 15 迪米特法则 16 (八)外观模式 16 (九)建造者模式(生成器模式) 19 (十)观察者模式 23 ...

    01 设计模式1

    设计原则是指导良好软件设计的基本准则,包括单一职责原则(SRP)、里氏代换原则(LSP)、依赖倒转原则(DIP)、接口隔离原则(ISP)、合成/聚合复用原则(CARP)和迪米特法则(Least Knowledge Principle,LKP)。...

    设计模式学习笔记

    同时,依赖倒转原则与里氏代换原则密切相关,后者强调子类必须能够替换掉它们的父类,确保软件系统的稳定性。 设计模式和设计原则共同构成了软件设计的基石,帮助开发者构建出可维护、可扩展、可复用的高质量软件。...

    自己总结的设计模式笔记

    依赖倒转原则是指抽象不应该依赖于细节,细节应当依赖于抽象。要针对接口编程,而不是针对实现编程。 5. 接口隔离原则 接口隔离原则是指每一个接口应该是一种角色,不多不少,不干不该干的事,该干的事都要干。这...

    设计模式PPT.rar

    22第二十二讲备忘录模式 23第二十三讲状态模式 24第二十四讲命令模式 25第二十五讲访问者模式 26第二十六讲开放封闭原则 27第二十七讲单一职责原则 28第二十八讲里氏代换原则 29第二十九讲依赖倒转原则 30第三十讲...

    Java 设计模式之创建模式

    本文将深入探讨三种工厂模式和单例、多例模式。 首先,理解创建模式的核心概念是关键。创建模式是对类实例化过程的抽象化,它允许系统在运行时动态决定要创建哪些对象以及如何创建。这样做的目的是为了提升代码的...

    《设计模式实训教程》【PPT+类图与代码+样章】

    2.1.5依赖倒转原则 2.1.6接口隔离原则 2.1.7合成复用原则 2.1.8迪米特法则 2.2实训实例 2.2.1单一职责原则实例分析 2.2.2开闭原则实例分析 2.2.3里氏代换原则实例分析 2.2.4依赖倒转原则实例分析 2.2.5接口...

    设计模式(23种)与设计原则(6种)

    3. **依赖倒转原则**(Dependency Inversion Principle, DIP):高层模块不应该依赖低层模块,两者都应该依赖其抽象。这意味着我们应该依赖接口或抽象类,而不是具体的实现。这有助于降低模块间的耦合度。 4. **...

Global site tag (gtag.js) - Google Analytics