0
0

接口、抽象类、面向对象设计、单元测试 一篇文章学会！

抽象类和接口

接口和抽象类是面向对象编程中最精密的部分

软件经得起测试、程序健康状态能被监控以及发现问题后好修复都有赖于接口和抽象类的正确使用

学好solid设计原则和接口与抽象类是学习设计模式的条件

solid是五个面向对象基本设计原则的缩写S-单一职责原则，O-开放关闭原则，L-替换原则，I-接口隔离原则，D-依赖反转原则

初识：

抽象类

感性认识

先对抽象类有点感性认识：

抽象方法：被abstract修饰，没有方法体，没有花括号。也就是没有被实现的方法

一旦一个类有了抽象方法或抽象成员后，这个类就成了抽象类。那么类也必须用abstract修饰。

如图：

抽象类和开闭原则

抽象类指的是：函数成员没被完全实现的类，用abstract修饰，并且抽象成员不能用private修饰。

如果函数成员全被实现的话那么它就不是抽象类，即具体类

如果抽象成员被private修饰，就意味着不能再被访问，更不可能被实现，无意义。

编译器不允许去实例化一个抽象类，那么抽象类还剩两种作用：

①当成基类，让派生类去实现抽象方法

②抽象类作为基类可以去声明变量，让该变量去引用一个子类的实例，而子类中已经实现了基类中抽象方法。（多态）

开闭原则：指的是封装那些不变的、确定的成员，而把那些不确定、可能改变的成员声明为抽象类，留给子类去实现

开闭原则的核心思想是：软件实体（模块、类、函数等）应该对扩展开放，而对修改关闭。

这意味着我们应当尽量设计系统，使得当需要添加新的功能时，不需要去修改现有的代码，而是通过扩展已有结构来实现。

具体来说，开闭原则有三个要点：

1、开放：允许增加新的行为或功能，而不改变已有的代码结构。

2、封闭：已经完成的功能不应该因为添加新功能而被修改。

3、子类可以替代它们的基类，不影响程序的行为。

示例

  1. using System;
  2. namespace ConsoleApp1
  3. {
  4.     internal class Program
  5.     {
  6.         static void Main(string[] args)
  7.         {
  8.             Vehicle vehicle = new Car();
  9.             vehicle.Run();
  10.         }
  11.     }
  12.     abstract class Vehicle {//基类，抽象类
  13.         public void Stop() {
  14.             Console.WriteLine("停车");
  15.         }
  16.         public abstract void Run();
  17.     }
  18.     class Car:Vehicle {
  19.         public override void Run()
  20.         {
  21.             Console.WriteLine("Car在开动");
  22.         }
  23.     }
  24.     class Truck : Vehicle
  25.     {
  26.         public override void Run()
  27.         {
  28.             Console.WriteLine("Truck在开动");
  29.         }
  30.     }
  31. }

给Vehicle添加子类Truck不用修改原来的代码，符合开闭原则。

子类实现抽象类时，抽象成员要加override修饰符。

可以看出抽象类简直就是为基类而是的

再识：

由抽象类到接口

在这里突发奇想设置一个成员变量全是抽象的类（纯虚类）即：

  1.  abstract class VehicleBase
  2.  {
  3.      abstract public void Run();
  4.      abstract public void Fill();
  5.      abstract public void Run();
  7.  }

实际上在C#中全抽象类就是接口

现在将此代码改成接口型：
形式上abstract class替换成interface
接口要求所有成员都必须是public的，而且接口的成员都是抽象的
所以方法体中的abstract、public要删去
因为abstract去掉了，所以实现过程中的override得去掉。就成了类实现接口

  1.  interface VehicleBase
  2.  {
  3.      void Run();
  4.      void Fill();
  5.      void Run();
  7.  }

另外看下实现接口的抽象类：

  1.  abstract class Vehicle
  2.  {//不完全实现接口，留一个不实现
  3.      public void Stop()
  4.      {
  5.          Console.WriteLine("停车");
  6.      }
  7.      public void Fill()
  8.      {
  9.          Console.WriteLine("加油");
  10.      }
  11.      abstract public void Run();//不实现接口中该方法,让其子类再去实现
  12.  }

接口

接口是由抽象类进化而来，且接口里的“方法”必须是public，而抽象类的方法只要求不是private。

接口里的“方法”必须是public，所以不用写修饰符，默认是public

用接口提高代码复用性

以下将写两段代码，一段不用接口，一段接口。突出接口的作用：

现有一个整形数组，以及一整数集合ArrayList，求它们的和及平均值，请编写代码：

代码一（不使用接口）：

  1. using System;
  2. using System.Collections;
  3. namespace ConsoleApp1
  4. {
  5.     internal class Program
  6.     {
  7.         static void Main(string[] args)
  8.         {
  9.             int[] nums1 = { 1, 2, 3, 4, 5 };
  10.             ArrayList nums2= new ArrayList { 1,2,3,4,5};
  11.             Console.WriteLine(Sum(nums1));
  12.             Console.WriteLine(Avg(nums1));
  13.             Console.WriteLine(Sum(nums2));
  14.             Console.WriteLine(Avg(nums2));
  15.         }
  17.         static int Sum(int[] nums)
  18.         {
  19.             int sum = 0;
  20.             foreach (var n in nums)
  21.             {
  22.                 sum += n;
  23.             }
  24.             return sum;
  25.         }
  27.         static int Sum(ArrayList nums)
  28.         {
  29.             int sum = 0;
  30.             foreach (var n in nums)
  31.             {
  32.                 sum += (int)n;//因为ArrayList数据是object类型，所以要类型转换
  33.             }
  34.             return sum;
  35.         }
  37.         static double Avg(int[] nums)
  38.         {
  39.             int sum = 0; double count = 0;
  40.             foreach (var n in nums)
  41.             {
  42.                 sum += n;
  43.                 count++;
  44.             }
  45.             return sum / count;
  46.         }
  48.         static double Avg(ArrayList nums)
  49.         {
  50.             int sum = 0; double count = 0;
  51.             foreach (var n in nums)
  52.             {
  53.                 sum += (int)n;
  54.                 count++;
  55.             }
  56.             return sum / count;
  57.         }
  58.     }
  59. }

因为数组和ArrayList是不同类型，导致要多写一段，来实现同样的功能。其实也说明了用于处理数组的方法与数组是紧耦合的，不能用来处理ArrayList集合。

第二段代码（含接口）：

接口类似于合同，就是供需双方要遵守的规则，这里面需求者（求和、求平均方法）只要求供应者（数组和集合）能够迭代。而供应者满足。可用接口

  1. using System;
  2. using System.Collections;
  3. namespace ConsoleApp1
  4. {
  5.     internal class Program
  6.     {
  7.         static void Main(string[] args)
  8.         {
  9.             int[] nums1 = { 1, 2, 3, 4, 5 };
  10.             ArrayList nums2= new ArrayList { 1,2,3,4,5};
  11.             Console.WriteLine(Sum(nums1));
  12.             Console.WriteLine(Avg(nums1));
  13.             Console.WriteLine(Sum(nums2));
  14.             Console.WriteLine(Avg(nums2));
  15.         }
  17.         static int Sum(IEnumerable nums)
  18.         {
  19.             int sum = 0;
  20.             foreach (var n in nums)
  21.             {
  22.                 sum += (int)n;//因为ArrayList数据是object类型，所以要类型转换
  23.             }
  24.             return sum;
  25.         }
  27.         static double Avg(IEnumerable nums)
  28.         {
  29.             int sum = 0; double count = 0;
  30.             foreach (var n in nums)
  31.             {
  32.                 sum += (int)n;
  33.                 count++;
  34.             }
  35.             return sum / count;
  36.         }
  37.     }
  38. }

该方法现在可以接受整形数组和ArrayList两种类型，不用为不同类型各写一个方法。

IEnumerable是一个接口，在.NET框架中，它表示一个序列，可以逐个返回元素而不是一次性获取所有元素。实现了IEnumerable接口的数据结构可以被foreach循环遍历。

用接口解耦

人不是万能的，人之间需要合作。类与类也是需要合作的，那么合作就产生了依赖关系，类之间就耦合了，依赖强那么耦合就高。

耦合（Coupling）是指软件系统中两个模块之间的相互关联程度，即一个模块对另一个模块的功能、数据或状态的依赖程度。高耦合意味着如果一个模块发生变化，可能会导致其他模块也受到影响，增加维护的复杂性和困难。

解耦（Decoupling）则是设计原则之一，它的目标是降低模块间的耦合度，使得改动一个模块不会直接影响到其他模块，提高系统的灵活性和稳定性。通过良好的设计，比如使用接口、抽象类、事件驱动等技术，可以减少模块之间的直接联系。

依赖（Dependency）则是指一个模块需要另一个模块的存在才能正常运行。它描述了模块间功能上的从属关系，一个模块可能依赖于另一个模块提供的服务。然而，好的依赖应该是轻量级的，尽量避免循环依赖和过度依赖。

三者区别在于，耦合强调的是模块之间的连接紧密程度，而依赖则更侧重于功能层面的关系；解耦则是为了降低这两个概念，使得系统的各个部分能够独立变化和升级。简单来说，低耦合对应着松散的依赖，而高的模块内聚和低的模块间耦合则是理想的设计状态。

示例

以下两段代码，前段代码用来体现什么是依赖和耦合，后段代码用来体现接口的解耦。

第一段：

表示汽车依赖于发动机，汽车和发动机紧耦合，没有发动机，或者说发动机出现故障。汽车都无法正常运行。

  1. using System;
  2. namespace ConsoleApp1
  3. {
  4.     internal class Program
  5.     {
  6.         static void Main(string[] args)
  7.         {
  8.             var engine=new Engine();
  9.             var car = new Car(engine);
  10.             car.Run(3);
  11.             Console.WriteLine(car.Speed);
  12.         }
  13.     }
  14.     //汽车的运行依赖于发动机
  15.     class Engine//发动机
  16.     {
  17.         public int RPM { get; private set; }//发动机每分钟多少转，且无法从外界设置set
  18.         public void Work(int gas)
  19.         { //发动机运行时，给的gas（油门）大小
  20.             this.RPM = gas * 1000;//规定发动机转速等于油门*1000
  21.         }
  22.     }
  24.     class Car//汽车
  25.     {
  26.         private Engine engine;//产生依赖，汽车必须有发动机
  27.         public Car(Engine engine)//产生汽车时，必须有发动机
  28.         {
  29.             this.engine = engine;
  30.         }
  31.         public int Speed { get; private set; }//汽车的速度
  32.         public void Run(int gas) {//汽车运行
  33.             engine.Work(gas);//汽车运行，发动机工作
  34.             this.Speed = engine.RPM/100;//运行速度
  35.         }
  36.     }
  37. }

代码二：

引入接口，可以有效的降低耦合。

理解接口：接口就是契约，用来约束一组功能。功能的调用者是被约束的，只能调用接口中包含的功能。并且让调用者放心调用，不用担心功能内部是怎么实现的。

老型手机，对于用户来说，可以去放心使用它的打电话、发短信、接电话，收短信功能，不用管它怎么实现的。对于厂商来说，必须要实现手机的打电话、发短信、接电话，收短信功能。

而丢了诺基亚的手机，不会让用户不会使用爱立信手机。因为这些手机都是那几个主要功能。所以手机和用户是解耦的。

  1. using System;
  3. namespace ConsoleApp2
  4. {
  5.     internal class Program
  6.     {
  7.         static void Main(string[] args)
  8.         {
  9.             var user=new User(new NoliaPhone());
  10.             //如果诺基亚手机坏了，那么只需修改上方的NoliaPhone为ErissonPhone
  11.             //就变成用爱立信手机。无需该其他地方
  12.             user.UsePhone();
  13.         }
  14.     }
  16.     class User {
  17.         private Iphone _iphone;
  18.         public User(Iphone iphone) { 
  19.             _iphone = iphone;
  20.         }
  22.         public void UsePhone()
  23.         {
  24.             _iphone.Dail();
  25.             _iphone.Receive();
  26.             _iphone.Send();
  27.             _iphone.PickUp();
  28.         }
  29.     }
  30.     interface Iphone
  31.     {
  32.         void Dail();
  33.         void PickUp();
  34.         void Send();
  35.         void Receive();
  36.     }
  37.     class NoliaPhone : Iphone
  38.     {
  39.         public void Dail()
  40.         {
  41.             Console.WriteLine("诺基亚手机正在打电话");
  42.         }
  44.         public void PickUp()
  45.         {
  46.             Console.WriteLine("诺基亚手机正在接电话");
  47.         }
  49.         public void Receive()
  50.         {
  51.             Console.WriteLine("诺基亚手机正在收短信");
  52.         }
  54.         public void Send()
  55.         {
  56.             Console.WriteLine("诺基亚手机正在发短信");
  57.         }
  58.     }
  59.     class ErissonPhone:Iphone
  60.     {
  61.         public void Dail()
  62.         {
  63.             Console.WriteLine("爱立信手机正在打电话");
  64.         }
  66.         public void PickUp()
  67.         {
  68.             Console.WriteLine("爱立信手机正在接电话");
  69.         }
  71.         public void Receive()
  72.         {
  73.             Console.WriteLine("爱立信手机正在收短信");
  74.         }
  76.         public void Send()
  77.         {
  78.             Console.WriteLine("爱立信手机正在发短信");
  79.         }
  80.     }
  81. }
总结

像后面的代码，一个类坏了，只需修改让另一个类替换（学了反射，这也不用改），相关耦合类仍能正常使用，松耦合。而前面的代码，一类坏了，另一个类就不能用了，除非调试找出bug。可知：接口就是让功能的提供方可以被替换。所以有替换的地方，就有接口。

依赖反转原则和单元测试

解耦在代码中的表现就是依赖反转，单元测试是依赖反转的应用者和受益者。

自顶向下逐步求精（紧耦合），是人解决问题的一种思维方式。在非面向对象编程里，就是函数之间的关系。在面向对象编程中就是，类之间的关系。如图：

依赖反转（依赖倒置）思维是来平衡这种单一的思维方式

左图是不用依赖倒置原则、接口。也就是自顶向下思维。上面的司机依赖于下面的车

图示意思：Diver司机有个Car类字段。当司机要开车时，调用Drive方法。Drive就调用Car中的Run方法。其他两个同理。

那么此时我让Driver司机调用卡车Truck方法能行吗？很明显传不过去，因为Driver只有Car字段，也就是Driver类和Car紧耦合。

此时我就是让Driver司机能调用卡车Truck，如何实现？右图即可

右图用来依赖倒置原则、接口。下面的类都依赖于上面要实现的接口。这就是依赖反转。

图示中：有个IVehicle接口，让Car类、Truck类都实现接口的Run方法。并且让Driver中的字段不再是具体的（如Car、Truck），而是IVehicle类型的字段。那么我们可以声明个IVehicle类型的变量，再实例Car或Truck类型(多态)，调用它们中的方法。那么就实现了Driver可以用Car的Run,或Truck的Run.

多个（服务的使用者），和多个（服务的提供者），都遵循同一个接口，就能实现多种配对。

如下：Car类和Truck类是接口中Run方法的提供者。而Driver和AiDriver类是使用者。就可以实现多种配对方式，如Driver用Car、AiDriver用Car、Driver用Truck、AiDriver用Truck。

解释图示：由上方右图升级而来，变化之处在于：左边是一个抽象父类，外加两个子类Driver、AiDriver，让Driver中的字段不再是具体的（如Car、Truck），而是IVehicle类型的字段。那么我们可以声明个IVehicle类型的变量，再实例Car或Truck类型(多态)，然后传入使用者的构造方法中，就可以调用拥有者的方法。

示例

目的：展示依赖反转、接口、解耦是怎样被单元测试所应用的。

该项目代码描述的是生成电扇的厂商。电扇转的快，需要大电流。转的慢，则需要小电流。同时，电流过大，就会给出安全警告：

  1. using System;
  2. namespace ConsoleApp3
  3. {
  4.     internal class Program
  5.     {
  6.         static void Main(string[] args)
  7.         {
  8.             var fan = new DeskFan(new PowerSupply());
  9.             Console.WriteLine(fan.Work());
  10.         }
  11.     }
  12.     class PowerSupply{//电源
  13.         public int GetPower() {//一次给100伏特
  14.             return 100;
  15.         }
  16.     }
  18.     class DeskFan { //风扇
  19.         private PowerSupply _powerSupply;
  20.         public DeskFan(PowerSupply powerSupply)//建立依赖，传递电源构造风扇
  21.         {
  22.             _powerSupply = powerSupply;
  23.         }
  24.         public string Work()//根据电流大小反应工作状态
  25.         {
  26.             int power=_powerSupply.GetPower();
  27.             if (power <= 0)
  28.             {
  29.                 return "电扇关闭";
  30.             }
  31.             else if (power <= 100)
  32.             {
  33.                 return "一档风力";
  34.             }
  35.             else if (power <= 200)
  36.             {
  37.                 return "二档风力";
  38.             }
  39.             else {
  40.                 return "电流过大，危险！！！";
  41.             }
  42.         }
  43.     }
  45.     
  47. }

该代码的问题：给不同的电源值，需要在代码里修改，这是极其不好的。

接口设置一般是自底向上（重构），还有高手用的自顶向下（设计）。

这里用用自底向上设置接口，来解耦

添加接口，实现接口：

  1.  public interface IPowerSupply
  2.  {//电源接口
  3.      int GetPower();
  4.  }
  5.  public class PowerSupply:IPowerSupply{//电源
  6.      public int GetPower() {//一次给100伏特
  7.          return 100;
  8.      }
  9.  }

添加测试项目，添加依赖，可以在测试项目中实现接口，提供任意电源值，测试程序能否正常运行。如果测试代码没问题，但是测试结果不成功，说明源代码有问题可以改

  1. using ConsoleApp3;
  3. namespace TestProject1
  4. {
  5.     public class DeskFanTest1
  6.     {
  7.         [Fact]//特征、特性
  8.         public void Test1()//测试为0的电力
  9.         {
  10.             var fan = new DeskFan(new le_text1());
  11.             Console.WriteLine(fan.Work()); 
  12.             
  13.         }
  14.     }
  15.     class le_text1 : IPowerSupply//需要产生电力为0的电源，实现接口就行。不需要改代码
  16.     {
  17.         public int GetPower()
  18.         {
  19.             return 1;
  20.         }
  21.     }
  22. }

下载第二个，可以直接创建实现了我们接口方法的实例，越过创建类的这一步。

就可以把代码改成如下，简化

  1. using ConsoleApp3;
  2. using Moq;
  3. using System.Net.NetworkInformation;
  4. //第一步：引入Moq名称空间
  5. //第二步：new一个Mock<IPowerSupply>()，将IPowerSupply接口传入
  7. namespace TestProject1
  8. {
  9.     public class DeskFanTest1
  10.     {
  11.         [Fact]//特征、特性
  12.         public void Test1()//测试为0的电力
  13.         {
  14.            // 添加如下两行
  15.             var mork = new Mock<IPowerSupply>();
  16.             mork.Setup(ps=>ps.GetPower()).Returns(()=>0);
  18.            // var fan = new DeskFan(new le_text1());修改为以下
  19.             var fan = new DeskFan(mork.Object);
  21.             var expected = "电扇关闭";
  22.             var actual = fan.Work();
  23.             Assert.Equal(expected, actual);
  24.             
  25.         }
  26.     }//下面的类可以删除了
  27.     //class le_text1 : IPowerSupply//需要产生电力为0的电源，实现接口就行。不需要改代码
  28.     //{
  29.     //    public int GetPower()
  30.     //    {
  31.     //        return 0;
  32.     //    }
  33.     //}
  34. }

几种方法归纳图示：

标签： java 开发语言
本文转载自: https://blog.csdn.net/m0_65804432/article/details/143799639
版权归原作者 陌上明苏 所有， 如有侵权，请联系我们删除。
登录后发布评论

“接口、抽象类、面向对象设计、单元测试 一篇文章学会！”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？