C#:深入理解接口及低耦合等周边知识

接口是完全未实现逻辑的类,纯虚类,只有函数成员,且都为public.换句话说:接口是函数成员全都是abstract public类型的抽象类.

文章目录

接口==契约
声明接口
接口是引用类型
- 实践价值
接口与as运算符
显示接口成员实现
紧耦合及解决方法
- 解决方法:接口隔离

接口==契约

定义两个不同类型的集合int和ArrayList.

        static void Main(string[] args){int[] num1 = new int[] { 1, 2, 3 };ArrayList num2 = new ArrayList() { 1, 2, 3 }; //非泛型集合,元素都被视为objectConsole.WriteLine(Sum(num1));  //和Console.WriteLine(Avg(num1));  //平均值Console.WriteLine(Sum(num2));Console.WriteLine(Avg(num2));}

然后我们想遍历这个集合计算所有元素的和与平均值.按道理来说,我们得实现两份,一份int,一份ArrayList的.
有的同学可能会想到强转.但问题是,我们传入的类型与int类型结构不同,其字段的名称和类型与int不同,而Sum和Avg对此一无所知.可能在运行时会出现问题.
我们能不能创建一个能够成功传入Sum的类,不管该类是什么类型,Sum都能很好地进行处理呢?接口应运而生.
我们计算Sum和Avg要的功能是什么?迭代.而int数组和ArrayList都有一个支持迭代的接口IEnumerable. 在这里插入图片描述

		//不采用泛型编程的话,得写两份.但是接口IEnumerable相当于应该契约,确认供方(Main)提供的是可迭代的static int Sum(IEnumerable nums){int ret = 0;foreach (var num in nums) ret += (int)num;return ret;}static double Avg(IEnumerable nums){double ret = 0;int cnt = 0;foreach (var num in nums){ret += (int)num;cnt++;}return ret / cnt;}

int[]和ArrayList都实现了IEnumerable这个接口,确保它能够迭代.因为接口是引用类型,我们传参给Sum和Avg都会隐式类型转化为IEnumerable接口.结构一样

声明接口

1.因为接口是由抽象类进化过来的,接口中也不能包括数据成员和字段.类实现接口就必须实现接口说有成员.
2.按照惯例,接口必须是I开头

interface IVehicle
{void Run();
}

3.基类只有一个,而接口可以有多个.基类必须在接口前面.且实现接口的成员不需要写override
同时,接口也可以继承接口.多个接口间用逗号分隔.

    interface IVehicle{void Run();}interface IWeapon{void Fire();}interface ITank : IVehicle, IWeapon{ }class VehicleBase{//...}class Vehicle : VehicleBase, IVehicle  //基类必须在接口前面{public void Run()  //实现接口的方法不需要写override{//...}}

例如:坦克可以驾驶也可以当武器.

4.具有重复成员的接口只需要实现一份

namespace shh
{interface Inf1{void PrintOut(string s);}interface Inf2{void PrintOut(string s);}class Myclass : Inf1, Inf2{public void PrintOut(string s){Console.WriteLine(s);}}class Program{static void Main(string[] args){Myclass myclass = new Myclass();myclass.PrintOut("sss");}}
}

Inf1和Inf2有相同的返回类型,函数名,参数.我们在继承这两个接口时只需要实现一次.
5.接口的声明可以用修饰符(public,internal),接口成员默认都是public的.

接口是引用类型

我们不能直接访问接口,但是我们可以通过类对象引用强制转化为接口类型,来使用这个接口.

class Program
{static void Main(string[] args){HuaWei huaWei = new HuaWei();IPhone phone = (IPhone)huaWei;Func(phone);}public static void Func(IPhone phone){phone.Call();}
}
interface IPhone
{void Call();
}
class HuaWei : IPhone
{public void Call(){Console.WriteLine("HuaWei...");}public void Receive(){Console.WriteLine("Rolling");}
}

我们把华为这个具体的类转成IPhone这个接口,然后去调用Func方法.

实践价值

**如果一个函数里面需要有什么功能,就只给它传什么功能.例如我们只想用Call这个功能,传HuaWei整个类既显得臃肿,又会降低代码的可维护性.**这个又从何说起呢?
如果Func类型传的参数是HuaWei类型的,但是这个时候我又想传进去一个实现IPhone接口的vivo又会因为结构不一样传不进去.导致我们经常要修改类.这不就降低代码的维护性了.

接口与as运算符

看起来as运算符虽然和强转所达成的效果差不多.但实际可差远了.

        static void Main(string[] args){HuaWei huaWei = new HuaWei();IPhone phone = huaWei as IPhone;if (phone != null ){Func(phone);}}

强制转化失败会抛异常,代码会直接挂掉.as运算符转化失败则是返回null.
异常会严重影响代码的执行速度,我们在使用时能用as就用as

显示接口成员实现

不知道大家看没看过这个杀手不太冷这一部电影.主角既是一个绅士,也是一个杀手.我们以主角为例子展开下面的学习.
我们先来看普通的接口实现.定义对象wk是一个温柔的杀手,能爱人(Love)也能杀人(Kill).

namespace shh
{class Program{static void Main(string[] args){var wk = new WarmKiller();wk.Love();wk.Kill();}}interface IGentle{void Love();}interface IKiller{void Kill();}class WarmKiller : IGentle, IKiller{public void Love(){Console.WriteLine("Love");}public void Kill(){Console.WriteLine("Kill you");}}
}

但是问题来了,杀手能让你这么直接就认出来吗?不得有些隐藏手段什么的.

    class WarmKiller : IGentle, IKiller{public void Love(){Console.WriteLine("Love");}void IKiller.Kill(){Console.WriteLine("Kill you");}}

IKiller.Kill()就是显示接口实例化,可以把杀手这个身份隐藏起来.此时用wk这个对象调用不了Kill这个函数.
在这里插入图片描述
我们只能把它转化成Ikiller这个接口才能调用它.
你得是专业的才能看出别人杀手的身份.

 static void Main(string[] args){var wk = new WarmKiller();//wk.Kill(); 找不到Kill,杀手怎么可能让你直接看出来var t = wk as IKiller;  //得转化成特定对象才能看到if (t != null){t.Kill();}}

显示接口成员实现之后,这个成员相当于只属于这个接口,类调用不了.

紧耦合及解决方法

接口天生就是用来解决紧耦合这个问题的.
我们先来认识紧耦合的危害.大家不需要完全理解下面的代码,只需要知道紧耦合的危害.

namespace shh
{class Program{static void Main(string[] args){Engine engine = new Engine();Car car = new Car(engine);car.Run(3);Console.WriteLine(car.speed);}}//引擎和汽车高度耦合,引擎出现一点问题,就算汽车类本身的实现没问题也会报错class Engine{public int RPM { get; private set; }public void Work(int gas){RPM = gas * 1000;}}class Car{private Engine _engine; //高度耦合public Car(Engine engine){_engine = engine;}public int speed { get; private set; }public void Run(int gas){_engine.Work(gas);speed = _engine.RPM / 100;}}
}

在上面的代码中,引擎和汽车高度耦合,引擎出现一点问题,就算汽车类本身的实现没问题也会报错.
Car这个类实现是没问题的,结果却因为_engine坏了导致报错.要是_engine生成的类再多点,会导致错误极难排除.这会大大降低代码的可维护性.

解决方法:接口隔离

在日常生活中,人和手机是解耦的.从vivo换到oppo也能迅速上手,没什么门槛.
声明一个Iphone的接口,具有发消息和拨号两个功能,诺基亚和华为实现这个接口.

    interface IPhone{void Send();void Dial();}class Nokia : IPhone{public void Send(){Console.WriteLine("Nokia sending...");}public void Dial(){Console.WriteLine("Nokia Dailing...");}}class Huawei : IPhone{public void Send(){Console.WriteLine("Huawei sending...");}public void Dial(){Console.WriteLine("Huawei Dailing...");}}

声明users这个类.类里面声明可以接口的字段,我们不需要传具体的哪一款手机,只需要传实现了拨号和发消息这两个功能的手机就行,没有型号要求.

    class Users{//类里面声明可以接口的字段,相当于泛化了,不再确切地指定特定内容(如某一款特定的手机)private IPhone _phone;public Users(IPhone phone){_phone = phone;}public void Work(){_phone.Send();_phone.Dial();}}

main函数调用:

    class Program{static void Main(string[] args){Users Danel = new Users(new Nokia());Danel.Work();}}

在这里插入图片描述
这就叫低耦合,不管你传进来是什么手机,我都能用,不具体依赖于哪一款手机.