接口是完全未实现逻辑的类,纯虚类,只有函数成员,且都为public.换句话说:接口是函数成员全都是abstract public类型的抽象类.
文章目录
接口==契约
定义两个不同类型的集合int和ArrayList.
static void Main(string[] args)
{
int[] num1 = new int[] { 1, 2, 3 };
ArrayList num2 = new ArrayList() { 1, 2, 3 }; //非泛型集合,元素都被视为object
Console.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();
}
}
这就叫低耦合,不管你传进来是什么手机,我都能用,不具体依赖于哪一款手机.