04Net基础加强第四天-接口与异常处理

接口
定义一个接口一定要以大写I开头
接口里面可以包含属性，方法，索引器，事件（其实都是方法，只能包含方法）
接口中的所有成员都不能显示的写访问修饰符（一定不能写），默认访问修饰符为public
接口不能被实例化
接口可以实现“多继承”（多实现），一个类只能继承自一个父类，但是可以实现多个接口
接口解决了不同类型之间的多态问题，比如鱼和船不是同一类型，但是都能在水里游泳，只是方式不一样，要对“游泳”实现多态，就只能考虑接口

 public interface Interface1
    {
        //接口不能被实例化
        string Name//属性里边的两个方法一定不能写实现，不能加访问修饰符（这里的属性不叫做自动属性，在类中才叫做自动属性）
        {
            get;
            set;
        }
        void SayHi();//定义方法不能写任何访问修饰符，也不能写任何实现
        string this[int index]//定义索引器，同样也不能写任何的访问修饰符
        {
            get;
            set;
        }
    }

显示实现接口
作用：就是为了解决方法重名的问题
显示实现接口没有访问修饰符，默认是私有的
显示实现接口的时候，在方法名称前加了“接口名”，形如：接口名.方法名

//接口1
 public  interface IFace1
    {
        void Fly();
    }

//接口2
 public interface IFace2
    {
        void Fly();
    }

Person2类，继承了IFace1和IFace2两个接口，并进行了显示

 public class Person2 : IFace1, IFace2
    {
        void IFace2.Fly()//显示实现接口不能加访问修饰符，并且方法名为“接口名.方法名”
        {
            MessageBox.Show("IFace2接口中的方法");
        }

        void IFace1.Fly()
        {
            MessageBox.Show("IFace1接口中的方法");
        }
    }

实例化并调用

            IFace1 p1 = new Person2();
            p1.Fly();
            IFace2 p2 = new Person2();
            p2.Fly();

接口总结
1.接口是一种规范。为了实现多态。
2.接口不能被实例化。
3.接口中的成员不能加访问修饰符，接口中的成员访问修饰符默认为public，不能手动进行修改。
4.接口中的成员不能有任何实现（“只说不做”，只是定义了一组未实现的成员）
5.接口中只能有方法，属性，索引器，事件，不能有“字段”。
6.接口与接口之间可以继承，并且可以多继承。
7.实现接口的子类必须实现该接口的全部成员。
8.一个类可以同时继承一个类并实现多个接口，如果一个子类同时继承了父类A，并实现了接口IA，那么语法上A必须写在IA的前面。
9.当一个抽象类实现接口的时候，如果不想把接口中的成员实现，可以把该成员实现为abstract。
10.“显示实现接口”，只能通过接口变量来吊调用（因为显示实现后访问权限为private）。
GetType()方法和BaseType()方法

            string s1 = "ahahah";
            //GetType()方法能够得到当前变量的数据类型
            MessageBox.Show(s1.GetType().ToString());
            //BaseType()方法能够得到该数据类型的父类类型
            MessageBox.Show(s1.GetType().BaseType.ToString());

异常捕获
如果希望代码无论如何都要被执行，则一定要将代码放在finally块中
1.当catch有无法捕获到的异常时，程序崩溃，但在崩溃之前会执行finally块中的代码，而finally块后的代码则由于程序崩溃了无法执行
2.如果在catch块中又引发了异常，则finally块中的代码也会在引发异常之前执行，但是finally块后的代码则不会执行
3.当catch块中有return语句时，finally块中的代码会在return之前执行，但是finally块后的代码不会执行

            try
            {
                int m = 10;
                int n = 0;
                int a = m / n;
            }
            catch(Exception ex)//这里还可以捕获特定类型的异常
            {
                MessageBox.Show(ex.Message);
            }
            finally//finally块中的代码无论有没有异常都会执行
            {
                MessageBox.Show("finally块中的代码执行了");
            }
            MessageBox.Show("最后的代码执行了");

ref和out的区别
ref是负责传入和传出，在方法外边就要给它赋值。
out是只负责传出，在方法里边一定要给它赋值。
比较两个对象是否是同一个对象的方法（引用类型对象在同一块堆内存上就是同一个对象）

            Person p1 = new Person();
            Person p2 = new Person();
            Person p3 = p1;
            //第一种比较方法
            bool b1 = p1.Equals(p3);
            MessageBox.Show(b1.ToString());
            //第二种比较方法
            b1 = object.ReferenceEquals(p1, p3);
            MessageBox.Show(b1.ToString());
            //第三种比较方法
            b1 = p1 == p3 ? true : false;
            MessageBox.Show(b1.ToString());

这三种方式在比较字符串对象的时候结果会出现差异：
双等号==比较的是字符串对象的每个字符是否一样
Equals()方法比较的也是字符串对象的每个字符是否一样
object.ReferenceEquals()方法比较的是字符串的对象在堆中的内存是否一样
所以，object.ReferenceEquals()方法是比较靠谱的

            string s1 = new string(new char[] { 'q', 'w', 'e' });
            string s2 = new string(new char[] { 'q', 'w', 'e' });
            bool b;
            //第一种比较方法
            b = s1 == s2 ? true : false;
            MessageBox.Show(b.ToString());//打印true
            b = s1.Equals(s2);
            MessageBox.Show(b.ToString());//打印true
            b = object.ReferenceEquals(s1, s2);
            MessageBox.Show(b.ToString());//打印false