c# 接口、依赖反转

 

 

接口和抽象类的区别：

1.接口用于规范，抽象类用于共性。

2.抽象类是类，所以只能被单继承，但是接口却可以一次实现多个。

3.接口中只能声明方法，属性，事件，索引器（本质是方法），接口不能包含字段、构造函数、析构函数、静态成员或常量。

4.抽象类可以提供某些方法的部分实现，接口不可以。抽象类的实例是它的子类给出的。接口的实例是实现接口的类给出的。

5.在抽象类中加入一个方法，那么它的子类就同时有了这个方法。而在接口中加入新的方法，那么实现它的类就要重新编写（这就是为什么说接口是一个类的规范了）。

6.接口成员默认为公共的，不能用static/public/private等修饰符，但抽象类的成员也可以是私有的、受保护的、内部的或受保护的内部成员（其中受保护的内部成员只能在应用程序的代码或派生类中访问）。

 

注意：

1.隐式的接口实现方式是属于继承类的，显式实现方法是属于接口本身的私有成员，只能接口访问

显式方法：void 接口名.方法（），继承多接口时推荐使用显式方法，可以避免接口的方法重名，不好分辨来自于哪个接口，继承单接口时可以用隐式实现。

    class Program
    {
        static void Main(string[] args)
        {
            Teacher a = new Teacher();
            a.Sayhello();  // a.work(); 实现不了，因为属于接口的方法
            

            //里式转换实现接口方法
            IWorkable b = (IWorkable)a;
            b.Work();
            //偷懒方法：声明一个接口类，将子类放入，实现的仍是父类接口自己的方法
            Iworkable b = new teacher();
            b.Work();

            Console.ReadLine();

        }
    }
    public interface ISayable 
    {
        void Sayhello();
    }
    public interface IWorkable
    {
        void Work();
    }

    public class Teacher : ISayable, IWorkable
    {
        public void Sayhello() //隐式实现接口，属于teacher类自己的
        {
            Console.WriteLine("sayhello");
        }

        void IWorkable.Work() //显式实现接口，属于接口Iworkable的,里式转换调用，不写public
        {
            Console.WriteLine("work");
        }
    }

 

依赖反转：

当我们在一个类中定义另一个类时，这就形成了耦合，通过具体的逻辑这种耦合可大可小，我们可以利用接口来解除这种不必要的耦合性，如下所示，这是没有使用接口的情况：

class Car
{
    public void SayHello()
    {
        Console.WriteLine("Hello, I'm is Car!!!");
    }
}

class Truck
{
    public void SayHello()
    {
        Console.WriteLine("Hello, I'm is Truck!!!");
    }
}

class Driver
{
    public Car car { get; set; }

    public Driver(Car ccar)
    {
        car = ccar;
    }

    public void SayHello()
    {
        car.SayHello();
    }
}

在上面的代码中，我们在 Driver（司机）类中定义了一个 Car（小汽车）类，司机之所以被称为司机，是因为他有自己的小汽车，但是当司机的小汽车坏了时，这个司机就不是一个司机了，我们还有检查小汽车的问题出现在哪里，而且上面我定义了一个 Truck（卡车）类，如果司机想要开这个卡车，那么我们就要重构一下这个Driver类，这就是一个大问题了，因为一个类一旦定义好，他就不应该去修改，这个耦合就非常的大，下面我们来利用接口来解除这个耦合性 . . .

新的代码如下所示：

interface IDrivingTool
{
    void SayHello();
}

class Car : IDrivingTool
{
    public void SayHello()
    {
        Console.WriteLine("Hello, I'm is Car!!!");
    }
}

class Truck : IDrivingTool
{
    public void SayHello()
    {
        Console.WriteLine("Hello, I'm is Truck!!!");
    }
}

class Driver
{
    public IDrivingTool MyCar { get; set; }

    public Driver(IDrivingTool ccar)
    {
        MyCar = ccar;
    }

    public void SayHello()
    {
        MyCar.SayHello();
    }
}

刚开始时的司机是这样的：

而现在我们将依赖反转之后，是这样的：