目录
依赖倒置原则的本质就是通过抽象，使各个模块的实现彼此独立，互不影响，实现松耦合（也就是低耦合）
目录
依赖倒置原则的本质就是通过抽象，使各个模块的实现彼此独立，互不影响，实现松耦合（也就是低耦合）
那么什么是高层模块和低层模块：在我们的程序中有A类和B类两个类，我们在A类里调用B类的对象，那么这里的A类就是高层模块，B类就是低层模块。也可以理解成，调用者就是高层模块，被调用者就是低层模块。
在设计原则中依赖倒置原则更为抽象，它是我们开放封闭原则实现的基础，我们开放封闭原则指的是：对功能的扩展开放，对修改封闭（也不说不能修改，只能修改一小部分代码，不要造成牵一动百）。
如果开放封闭原则是设计大楼的蓝图，那么我们依赖倒置原则就是大楼的钢铁架构。
高层模块不应该依赖于低层模块，都应该去依赖抽象。
举例说明：歌手唱中国歌
static void Main(string[] args)
{
//歌手唱中国的歌曲
歌手 歌手 = new 歌手();
中国歌曲 中国歌曲 = new 中国歌曲();
歌手.唱歌(中国歌曲);
Console.ReadKey();
}
public class 中国歌曲
{
public string 歌曲歌词()
{
return "辣妹子，辣妹子，不怕辣！";
}
}
public class 歌手
{
public void 唱歌(中国歌曲 中国歌曲)
{
Console.WriteLine("歌手正在唱："+中国歌曲.歌曲歌词());
}
}乍一看确实这个需求很简单，但是当我们吧需求改成歌手不仅唱中国歌曲还唱外国歌曲。我们可以想想如何改动这个代码
static void Main(string[] args)
{
//歌手唱中国的歌曲
歌手 歌手 = new 歌手();
//中国歌曲 中国歌曲 = new 中国歌曲();
外国歌曲 外国歌曲 = new 外国歌曲();
//歌手.唱中国歌(中国歌曲);
歌手.唱外国歌(外国歌曲);
Console.ReadKey();
}
public class 中国歌曲
{
public string 歌曲歌词()
{
return "辣妹子，辣妹子，不怕辣！";
}
}
public class 外国歌曲
{
public string 外国歌曲歌词()
{
return "sfss sdfasdf sdf sdfdfgf";
}
}
public class 歌手
{
public void 唱中国歌(中国歌曲 中国歌曲)
{
Console.WriteLine("歌手正在唱："+中国歌曲.歌曲歌词());
}
public void 唱外国歌(外国歌曲 外国歌曲)
{
Console.WriteLine("歌手正在唱：" + 外国歌曲.外国歌曲歌词());
}
}虽然我们现在实现了歌手唱外国歌曲，但是我们如果让歌手唱其他国家的歌曲呢？我们就需要创建不同国家歌词的类，我们还要去歌手类里面去添加方法。我们不难看出，我们的这个类会越写越冗余。也不符合我们的单一职责原则和开放封闭原则，前面提过依赖倒置原则是我们开放封闭的核心，此处已经不符合开放封闭原则，也就意味着也不符合我们的依赖倒置。我们回过头可以看到我们依赖倒置原则：高层模块不应该依赖于低层模块，在我们这个代码中，歌手就是我们的高层模块，中国歌曲、外国歌曲就是我们的低层模块。
static void Main(string[] args)
{
//歌手唱不同国家的歌曲
歌手 歌手 = new 歌手();
歌手.唱歌(new 中国歌曲());
歌手.唱歌(new 外国歌曲());
Console.ReadKey();
}
public interface I歌曲歌词
{
string 歌曲歌词();
}
public class 中国歌曲:I歌曲歌词
{
public string 歌曲歌词()
{
return "中国歌曲";
}
}
public class 外国歌曲:I歌曲歌词
{
public string 歌曲歌词()
{
return "外国歌曲";
}
}
public class 歌手
{
public void 唱歌(I歌曲歌词 歌曲歌词)
{
Console.WriteLine("歌手正在唱："+歌曲歌词.歌曲歌词());
}
}
抽象不应该依赖细节，细节应该依赖抽象
这里的抽象就是我们的抽象类或者是接口，抽象类和接口不允许创建对象。
细节指的就是实现，当我们写了一个抽象类或者接口的时候，需要有具体的实现类来继承抽象类和接口。就好比我们的插线板和插头，如果我是插头的生产厂家，我肯定会根据市场最普遍存在的插座去生产插头，不可能去生产单头的，或者四头，五头的插座对不对。
抽象就是我们的插座，而我们的细节就是插头
依赖倒置原则的本质就是通过抽象，使各个模块的实现彼此独立，互不影响，实现松耦合（也就是低耦合）
关于我们的依赖
- 一个优秀的面向对象程序设计，核心的原则就是将变化进行隔离和封装，使得变化的部分发生修改的时候其他部分不受影响
- 为了实现这个目的，需要使用面向接口编程，使用后客户类不能直接依赖于服务类，而是依赖一个抽象的接口，这样，客户类就不能直接在内部实例化服务类。
- 但是我们的客户类在运行的过程中，又需要具体的服务类去提供服务，因为接口不能实例化，这里就产生了一个矛盾，客户类不允许直接实例化服务类，但是客户类有需要我们服务类提供服务。
- 为了解决这个矛盾，可以设计出一个解决方案:客户类定义一个注入点，用于服务类的注入，而客户类的类根据情况，实例化服务类，注入到我们的客户类中。
我们如何进行依赖注入
1.通过接口传递
static void Main(string[] args)
{
//不同的人开不同的车
//思路：我们应该把变化的部分抽象起来；开车的人、不同的车
大学生 大学生 = new 大学生();
大学生.开车(new 奔驰());
Console.ReadKey();
}
public interface I各种车
{
void 跑();
}
public interface I不同的司机
{
//在接口或者类中，将要注入的服务对象以参数的形式注入，就叫接口注入
void 开车(I各种车 车);
}
public class 奔驰 : I各种车
{
public void 跑()
{
Console.WriteLine("开的奔驰");
}
}
public class 大学生 : I不同的司机
{
public void 开车(I各种车 车)
{
车.跑();
}
}2.通过构造方法传递
static void Main(string[] args)
{
//不同的人开不同的车
//思路：我们应该把变化的部分抽象起来；开车的人、不同的车
大学生 大学生 = new 大学生(new 奔驰());
大学生.开车();
Console.ReadKey();
}
public interface I各种车
{
void 跑();
}
public interface I不同的司机
{
//在接口或者类中，将要注入的服务对象以参数的形式注入，就叫接口注入
//void 开车(I各种车 车);
void 开车();
}
public class 奔驰 : I各种车
{
public void 跑()
{
Console.WriteLine("开的奔驰");
}
}
public class 大学生 : I不同的司机
{
private I各种车 各种车;
public 大学生(I各种车 _各种车)
{
各种车 = _各种车;
}
public void 开车()
{
this.各种车.跑();
}
}3.通过set传递
static void Main(string[] args)
{
//不同的人开不同的车
//思路：我们应该把变化的部分抽象起来；开车的人、不同的车
大学生 大学生 = new 大学生();
大学生.Set车(new 奔驰());
大学生.开车();
Console.ReadKey();
}
public interface I各种车
{
void 跑();
}
public interface I不同的司机
{
//在接口或者类中，将要注入的服务对象以参数的形式注入，就叫接口注入
//void 开车(I各种车 车);
void Set车(I各种车 各种车);
void 开车();
}
public class 奔驰 : I各种车
{
public void 跑()
{
Console.WriteLine("开的奔驰");
}
}
public class 大学生 : I不同的司机
{
private I各种车 _各种车;
public void Set车(I各种车 各种车)
{
this._各种车 = 各种车;
}
public void 开车()
{
this._各种车.跑();
}
}
141
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
