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

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

文章目录

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

接口==契约

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

csharp 复制代码

        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.

csharp 复制代码

		//不采用泛型编程的话,得写两份.但是接口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开头

csharp 复制代码

interface IVehicle
{
    void Run();
}

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

csharp 复制代码

    interface IVehicle
    {
        void Run();
    }

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

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

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

csharp 复制代码

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的.

接口是引用类型

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

csharp 复制代码

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运算符虽然和强转所达成的效果差不多.但实际可差远了.

csharp 复制代码

        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).

csharp 复制代码

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");
        }
    }
}

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

csharp 复制代码

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

        void IKiller.Kill()
        {
            Console.WriteLine("Kill you");
        }
    }

IKiller.Kill()就是显示接口实例化,可以把杀手这个身份隐藏起来.此时用wk这个对象调用不了Kill这个函数.

我们只能把它转化成Ikiller这个接口才能调用它.
你得是专业的才能看出别人杀手的身份.

csharp 复制代码

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

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

紧耦合及解决方法

接口天生就是用来解决紧耦合这个问题的.

我们先来认识紧耦合的危害.大家不需要完全理解下面的代码,只需要知道紧耦合的危害.

csharp 复制代码

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的接口,具有发消息和拨号两个功能,诺基亚和华为实现这个接口.

csharp 复制代码

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

csharp 复制代码

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

main函数调用:

csharp 复制代码

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

这就叫低耦合,不管你传进来是什么手机,我都能用,不具体依赖于哪一款手机.