c#学习历程4

内容主要包括两大主题：接口和委托

一.接口

接口定义：把一组方法声明进行统一的命名，但是这些方法没有实现（和纯虚函数类似，只声明方法，不能实例，只能被继承）

格式：interface 接口名字

  {

    声明方法

  }

注意：1.接口不需访问权限，默认为公有

           2.使用时不能单独使用，只能被继承（可由类或结构体实现）
         3.接口没有字段,运算符重载，实例构造函数，析构函数，只有方法(  属性 事件  索引器)

           4.接口不能给你使用static关键值，方法只能是普通方法不能加static

    interface MyInterface{
    //只能被重写 不能被调用 类似抽象方法  不需写访问权限  默认为公有
        void print();
    }

    interface Interface
    {
        void print();
    }

继承接口：如果想继承接口那么必须实现接口中定义的所有方法

class MyClass:MyInterface
    {
        
        public void print()
        {
            Console.WriteLine ("MyClass");
        }

     }

多继承的问题

当多个接口包含相同方法的时候，如果都实现的话，就会发生冲突，系统不知道调用哪一个

解决方法：1.同时实现多个方法（隐式实现） 2.加上对象.来区分开方法（显式的实现）

1.只写一个方法实现来实现所有接口的方法

class MyClass:MyInterface,Interface
    {
        // 不加访问权限  默认为私有
        //当多个接口有共同的方法时
        //不分开隐式实现（推荐）(2个接口方法  同时实现)

        public void print()
        {
            Console.WriteLine ("MyClass");
        }

2.

class MyClass:MyInterface,Interface
   

//分开的显示实现（还需要强制类型转换）不加任何访问修饰符 默认为私有
        void MyInterface.print()
        {
            Console.WriteLine ("MyInterface");
        }

        void Interface.print()
        {
            Console.WriteLine ("Interface");
        }

使用显式接口实现方式时,需要注意几个问题

1.若显式实现接口,方法不能使用任何访问修饰符。

  显式实现的成员默认为私有。

2.显式实现的成员默认是私有的,所以这些成员不能通过对象

  直接访问。此时正确的访问方式就是把对象显式的转换为对应的接口,通过接口来调用该方法。

  MyClass mc = new MyClass();

  MyInterface mc1 = (MyInterface)mc;
  mc1.print ();

3.当类实现单个接口时,通常使用隐式接口方式,因为对象可以直接访问接口方法。

4.实现多个接口时候,一般推荐使用显式的方式。 

接口经常与抽象类一起使用,共同服务于面向对象的编程

简单分析一下区别: 

1.抽象类使用abstract关键字进行定义,接口使用interface进

  行定义,它们都不能实例化

2.抽象类可以包含虚方法、非抽象方法和静态成员;但接口不

  能包含虚方法和任何静态成员,并且接口中只能定义方法,不能有具
  体实现。

3.抽象类不能实现多继承,接口支持多继承。

4:抽象类本质是一个类;接口只是代表实现类具有接口声明的方法,是一种CAN—DO关系。 

二.委托

委托就是把一些方法包装成了一个对象来使用

委托的步骤：1.定义委托类型 2.声明委托变量 3.实例化委托 4.作为参数传递 5.调用委托

1.有一个方法的委托

class MainClass
{


//1:
声明委托
delegate void MyDelegate(int para1,int para2);


public static void Main (string[] args)


{

  //2:
定义委托变量

  MyDelegate d;


  //3:
实例化委托（添加方法）

  d = new MyDelegate (new MainClass().Add);


  //4:
调用

  MyMethod (d);

  Console.WriteLine ("Hello World!");


}

void Add(int a,int b)


{

  int sum = a + b;


  Console.WriteLine (""+sum);

}


private static void MyMethod(MyDelegate myDelegate)

{
 

  //5:
方法中调用委托

  myDelegate (1,2);


}


}
 

委托的优点：

引入委托之后,我们可以把函数作为参数传递给另外一个方法了。委托可以提高方法扩展性。


 

2.委托链

class MainClass
    {
        public delegate void delegateTest();

        private static void method1(){
            Console.WriteLine ("这是静态方法1");
        }
        private void method2(){
            Console.WriteLine ("这是实例方法2");
        }
        private void method3(){
            Console.WriteLine ("这是实例方法3");
        }
        static void Main(string[] args){
            MainClass p=new MainClass();
            delegateTest d1 = new delegateTest (MainClass.method1);
//          delegateTest d1 = MainClass.method1;//简写
            delegateTest d2 = new delegateTest (p.method2);
            delegateTest d3 = p.method3;//简写
            delegateTest delechain = null;
            delechain += d1;
            delechain += d2;
            delechain += d3;
            //移除委托
            delechain -= d1;
            delechain ();

特别注意 ：  //转向直接发生改变，直接指向d3
            delechain = d3;//只输出为d3的方法
            delechain ();

        }
    }