java 依赖倒置_java 设计模式之依赖倒置实例详解

本文实例讲述了java 设计模式之依赖倒置。分享给大家供大家参考，具体如下：

依赖倒置的概念我也是在一篇博文上理解的，我觉得很精辟，所以收录在我的博客中。

类A 依赖 类B，之后根据需求 类A 变换为依赖 类C，这时候我们认为类A 是高层模块， 类B 和 类C 是低层模块。

什么是高层模块？什么是底层模块？

高层模块你可以理解为控制层，负责复杂的业务逻辑。

低层模块你可以理解为数据层，负责基本的原子操作。

什么意思？ 我举个例子。

比如大胃王比赛。

在这场比赛中的规则是比赛谁吃馒头吃的最多。有参赛选手Q和W

/**

* 馒头 实体类

*/

class SteamedBuns

{

private String name = "馒头";

public String getName()

{

return this.name;

}

}

class Player

{

//得了多少分

private int intgral;

private Sting name;

public Player(String name)

{

setName(name);

}

public void setName(String name)

{

this.name = name;

}

public String getName()

{

return name;

}

public void setIntgral(int intgral)

{

this.intgral= intgral;

}

public int getIntgral()

{

return this.intgral;

}

public void eat(SteamedBuns steamedBuns)

{

System.out.println("我开吃了");

setIntgral(getIntgral() + 1);

}

}

public class Main

{

pubic static void main(String[] agrs)

{

Player q = new Player("Q");//选手Q

Player w = new Player("W");//选手W

q.eat(new SteamedBuns());//选手Q吃馒头

w.eat(new SteamedBuns());//选手W吃馒头

}

}

那么，之后问题来了。Q和W 比分一样，胃口太大把馒头吃光了，现在好追加比赛吃包子。 但Q和W 的实体只支持吃馒头，这个不符合情理哇，不可能一个人能吃馒头不能吃包子哇。

public void eat(SteamedBuns steamedBuns)//选手只支持吃馒头

有的同学可能会想到用重载这个方法。

public void eat(SteamedBuns steamedBuns){} //选手支持吃馒头

public void eat(SteamedStuffedBun steamedStuffedBun){} //选手支持吃包子

思路是正确的，但是在实际开发中，这样做，可能会给程序带来不必要的风险。

这时候依赖倒置的优越性就体现出来了。

还是思考。既然馒头吃光了，现在要比赛吃包子，那么我们想一下如果包子也吃光了还没有分出胜负，要继续追加比赛怎么办？再用重载吗？ 人都是可以吃食物的，我们要让包子和馒头都实现食物接口。而参赛选手的依赖应该从包子和馒头 抽象出来 依赖食物接口。 这样只要一个类实现了食物接口，那么都能被吃。

/**

* 食物接口

*/

interface Food

{

public String getName();

}

/**

* 馒头 实体类

*/

class SteamedBuns implements Food

{

private String name = "馒头";

@Override

public String getName()

{

return this.name;

}

}

/**

* 包子 实体类

*/

class SteamedStuffedBun implements Food

{

private String name = "包子";

@Override

public String getName()

{

return this.name;

}

}

class Player

{

private int intgral;

private Sting name;

public Player(String name)

{

setName(name);

}

public void setName(String name)

{

this.name = name;

}

public String getName()

{

return name;

}

public void setIntgral(int intgral)

{

this.intgral= intgral;

}

public int getIntgral()

{

return this.intgral;

}

/**取消对具体食物种类的依赖

public void eat(SteamedBuns steamedBuns)

{

System.out.println("我开吃了");

setIntgral(getIntgral() + 1);

}

*/

public void eat(Food food)

{

System.out.println("我开吃了");

setIntgral(getIntgral() + 1);

}

}

public class Main

{

pubic static void main(String[] agrs)

{

Player q = new Player("Q");//选手Q

Player w = new Player("W");//选手W

q.eat(new SteamedBuns());//选手Q吃馒头

w.eat(new SteamedBuns());//选手W吃馒头

q.eat(new SteamedStuffedBun());//选手Q吃包子

w.eat(new SteamedStuffedBun());//选手W吃包子

}

}

这样的设计有助于降低类之间的耦合程度，抽象稳定的多，细节交给实现类。

希望本文所述对大家java程序设计有所帮助。