关于C#中的接口和抽象类的知识点小记

1.抽象类不能被实例化

2.类继承接口必须提供实现

C#虚基类继承与接口的区别

类 定义新的数据类型以及这些新的数据类型进行相互操作的方法 定义方式：

   class Cat {
      // ..........
   }
   class Cat : object {
      //  ..........
   }

C#中所有的类都是默认由object类派生来的，显示指定或者省略效果是一样的，所以上面的两个例子是完全相同的。 C#中类包括：抽象类、密封类、非抽象类 abstract：表示修饰的类不完整，也就是抽象类，只能用做基类。 在使用是不能直接实例化，不能使用new运算符。 sealed：表示修饰的类不可派生，也就是密封类。 base：访问最近的基类，也就是当前类继承的类。

    class Cat:Animal
    {
      public void Cat()
      {
        base.Eat();
      }
    }

 

以上例子中base代表Animal。 注意：base只能在类的内部使用。 接口 一个接口定义一个协定。接口可以看成是特殊的抽象类，但是又有所区别。 一个接口可以从多个基接口继承，而一个类或结构可以实现多个接口。 接口可以包含方法、属性、事件和索引器。接口本身不提供它所定义的成员的实现，而抽象类中可以提供定义成员的实现。 接口只指定实现该接口的类或结构必须提供的成员。 接口本质上是一种类 不过他与类的区分还是很明显的——不能实例化 他的精髓在于提供一些类共同的地方，而且能“多继承” 我们知道所谓对象其实是数据和方法的封装。接口的作用更多的是工程上的，一般上我们用他来封装通用的行为，来达到程序的多态。 不必用object的观点来统一接口，在我的感觉中，继承简化对象结构，增加代码重用，接口抽象行为。 1. 接口本质上是类吗 这个，要看你认为“类的本质是什么”了，过多纠缠于这个说法，很容易陷入文字之争，意义不大。 2. 接口和类有什么区别和联系,主要是联系 区别： 类的定义需要“实现”，接口的定义只需要“声明”； 类能实例化出一个对象，接口不能； 类只能单根继承，接口可以多根继承； 继承一个类，相当于借用了它已实现的功能，实现一个接口，相当于对外做了一个承诺； …… 联系：类可以“实现”接口 3. 接口是否具备类的特征 这要看你认为哪些是“类的特征”，hehe，比如，“编译后会生成一个 .class 文件”算不算特征…… 4. 接口是否是Object 不是。但可以用一个接口型的变量来引用一个对象，而且，被引用的对象，说到底，一定是一个 Object。 1、纯虚类与接口不同的是，纯虚类可以包含一些实现 2、用纯虚类包含一些基本的功能或方法 3、用接口来定义客户端与组件之间的通讯方法 4、虚基类的实现的变化可能会影响派生类 5、使用接口要比使用继承具有更强的适用性 接口的一些特征; 不可以包含任何实现；没有构造方法；任何成员都隐式声明为public； 接口是负责功能的定义，项目中通过接口来规范类，操作类以及抽象类的概念！ 而类是负责功能的具体实现！ 在类中也有抽象类的定义，抽象类与接口的区别在于： 抽象类是一个不完全的类，类里面有抽象的方法，属性，也可以有具体的方法和属性，需要进一步的专业化。 但接口是一个行为的规范，里面的所有东西都是抽象的！ 一个类只可以继承一个基类也就是父类，但可以实现多个接口 PS：接口除了规范一个行为之外，在具体项目中的实际作用也是十分重要的，在面向对象的设计原则以及设计模式的使用中，无不体现作为一个接口的使用好处，最直接的就是设计原则中OCP（开放封闭原则），我们使用接口，而不需要关心他的具体实现，具体实现的细节变化也无关客户端（使用接口的类）的使用，对与扩展是开放的，我们可以另写一个接口的实现来扩展当前程序，而不影响上层的使用，但对修改是封闭的，即我们不能够再去修改接口的定义，当然这个 “不能够”是指在规范原则上不应该这么做！ 接口的使用–多态的实现：

    public interface IPolimorphism()
    {
       void Say();
    }

建立一个Class1.cs文件，定义两个类，扩展IPolimorfism：

 

using System;
using System.Windows.Forms;
namespace NorthWind
{
   public class Red:IPolimorphism  //实现接口的方法
   {
      public void Say()  //不需要指定override关键字
      {
          MessageBox.Show("Red!");
      }
   }
     
   public class Yello:IPolimorphism
   {
      public void Say() //不需要指定override关键字
      {
         MessageBox.Show("Yello!");
      }
   }
     
}

 

另一个MainFrm.cs文件，应用程序入口处：

 

using System;
using System.Windows.Forms;
namespace NorthWind {
   public class MainFrm : System.Windows.Forms {
      [STAThread]
      static void Main() {
         IPolimorphism red = new Red();
         red.Say();
         IPolimorphism yello = new Yello();
         yello.Say();
      }

   }
}

 

举个例子,有一个老汉,做了一个面饼,给了他的几个儿子,老大用这个饼,加上点馅,包一下,做成了包子,老二用这个面饼,在外面刷上油,撒上料,烤一烤,做成了土家烧饼,老三呢,胡乱做,在饼上抹上乱七八糟的东西,烤一烤,做成了披萨饼.基类和派生类的关系就是这样,基类提供了基本的实现,派生类就在上面添料,最终就成了每个人心中想要的饼.

那接口的故事则不一样,老汉没有给众人面,老汉这回给儿子们画了一个饼的设计图,规定了这个饼的厚度,直径等等,然后把这个规格表发给儿子们了,儿子们拿着画的饼,各自按自己的想法去做了.

两个故事的区别告诉我们,接口是一种规格,是一个统一的标准,在实际应用中,接口有两方法的作用.

1。通过接口更容易表现设计,更容易沟通,而且接口是没有实现代码的,因此,定好接口,再写实现代码,就算设计上有变动,也可以通过接口轻易实现修改.而如果不用接口的话,你将直接去写类,好不容易实现了一个类的代码,如果设计上有少许的变动,就要去改代码.

2。接口是写类的实现者看的,这好比建筑图纸是画给施工工人看的.

 

C#中对于接口的实现方式

C#中对于接口的实现方式有隐式接口和显式接口两种：

隐式地实现接口成员
创建一个接口，IChinese，包含一个成员 Speak;我们创建一个类Speaker，实现接口Chinese

 

//隐藏式实现例子
public interface IChinese
{
    string Speak();
}
public class Speaker : IChinese
{
    public string Speak()
    {
        return "中文";
    }
}

这个就是隐式实现接口。

隐式实现调用方法如下：

IChinese s = new Speaker();
s.Speak();

Speaker s = new Speaker();
s.Speak();

都可以调用Speak这个方法。

创建一个接口，IEnglish，包含一个成员 Speak;让我们的类Speaker来实现接口IEnglish

//显式实现例子
public interface IEnglish
{
    string Speak();
}
public class Speaker : IEnglish
{
     string English.Speak()
    {
        return "English";
    }
}

通过这种显示接口实现。Speak方法就只能通过接口来调用:

IEnglish s = new Speaker();
s.Speak(); 

下面的这种方式将会编译错误： 

Speaker s = new Speaker();
s.Speak(); 

隐式实现和显示实现的区别:

一、语法的区别

1、隐式方式Speaker的成员（Speak）实现有而且必须有自己的访问修饰符（public），显示实现方式Speaker的成员（Speak）不能有任何的访问修饰符。
2、显示实现方式Speaker使用接口名称和一个句点命名该类成员（Speak）来实现的：English.Speak();也就是
二、调用的区别
隐式接口实现的调用，注意类的声明，可以用接口声明，也可以用实现类 Speaker声明。调用者都可以得到调用实例化对象的行为Speak;

 

class Program
{
    static void Main(string[] args)
    {
        IChinese s = new Speaker();
        s.Speak();
        Speaker s = new Speaker();
        s.Speak();
    }
} 

显式接口实现调用，注意类的声明，只可以用接口声明，调用者才可以可以得到调用实例化对象的行为Speak;   

 

class Program
{
        static void Main(string[] args)
        {
            IEnglish s = new Speaker();
            s.Speak();
           //下面写法将引起编译错误错误“PetShop.Speaker”不包含“Speak”的定义；
           // Speaker s = new Speaker();
           // s.Speak();
        }
}

结论：
隐示实现对象声明为接口和类都可以访问到其行为，显示实现只有声明为接口可以访问。

如果两个接口中有相同的方法名，那么同时实现这两个接口的类，就会出现不确定的情形，在编写方法时，也不知道实现哪个接口的方法了。为解决这一问题，C#提供了显示接口实现技术，就是在方法名前加接口名称，用接口名称来限定成员。用“接口名.方法名()”来区分实现的是哪一个接口。

注意：显示接口实现时，在方法名前不能加任何访问修饰符。这种方式和普通方法不同，普通方法前不加访问修饰符，默认为私有的，而显式接口实现时方法前不加任何修饰符，默认为公有的，如果前面加上修饰符，会出现编译错误。

调用显示接口实现的正确方式是通过接口引用，通过接口引用来确定要调用的版本。

下面我们看一下完整实例：

using System;
public interface IPerson
{
　　string Name
　　{
    　　get;
    　　set;
　　}
　　void Show(string name);
}

public interface IStudent
{
　　string StudentId
　　{
    　　get;
    　　set;
　　}
　　void Show(string studentid);
}

public class Student: IPerson, IStudent
{
　　private string _name;
　　public string Name
　　{
    　　get
    　　{
      　　return _name;
    　　}
    　　set
    　　{
      　　_name = value;
    　　}
　　}

　　private string _studentid;
　　public string StudentId
　　{
    　　get
    　　{
      　　return _studentid;
    　　}
    　　set
    　　{
      　　_studentid = value;
    　　}
　　}

　　void IPerson.Show(string name)
　　{
    　　Console.WriteLine("姓名为{0}", name);
　　}

　　void IStudent.Show(string studentid)
　　{
    　　Console.WriteLine("学号为{0}", studentid);
　　}
}

class Program
{
　　static void Main()
　　{
    　　Student s = new Student();
    　　Console.WriteLine("输入姓名");
    　　s.Name = Console.ReadLine();
    　　Console.WriteLine("输入学号");
    　　s.StudentId = Console.ReadLine();
    　　IPerson per = s;
    　　per.Show(s.Name);
    　　IStudent stu = s;
    　　stu.Show(s.StudentId);
　　}
}

转载：https://www.cnblogs.com/zpx1986/archive/2016/06/16/5590797.html

转载：https://www.cnblogs.com/wwwbdabc/p/11652183.html