(04)基础强化:接口,类型转换cast/convert,异常处理,传参params/ref/out,判断同一对象

一、复习

   1、New的截断是指什么？

       new除了新开空间创建初始化对象外，还有一个隐藏父类同名方法的作用。

       当子类想要隐藏父类同名的方法时用new，用了new后父类同名方法将到此为止，后面
       继承的子类，将再也继承不到父类的同名方法，相当于由此截断，断子绝孙。


   2、参数传递有几种，有什么区别？

       参数传递有两种：值传递与引用传递

       值传递：栈中内容的副本拷贝。
       引用传递：传递的是栈本身的地址，相当于给变量起了一个别名。都表示同一个变量。

       注意：
           out比较特别，它只能传出不能传入。传出用的引用传递。


   3、把接口当作参数传递是什么个回事？
       后面马上讲


   4、方法重载overload与方法重写override，及以隐藏new的区别是什么？

       重载overload: 至少两个及以上方法，方法名相同，但参数个数或类型或顺序等不同。
                   根据同名的不同函数签名调用对应不同的同名函数。
                   在程序编译的时候已经确定它一定调用对应的同名方法。

       重写override: 改写父类继承过来的同名函数。必须与abstract与virtual成双出现。
                   主要用在多态上。
                   在程序编译的时候无法确定它到底调用那个，因为父类由动态的子类来
                   赋值，子类在运行时才能确定到底是哪一个子类。

       隐藏new: 隐藏父类继承过来的同名函数，从此截断，不再继承下去。
                   new可以和abstract或virtual进行联合修饰，但不能和override联合

       判断：方法重载与重写都是实现多态的有效方式？
           有些人认为：重载是编译器多态，重写是运行时多态。
           有些人认为：多态是面向对象的概念，所以重写是多态，而重载不能算是多态。

二、怎么实现多态2-接口

   1、什么是接口?

       接口就是一种规范,协议(*)，约定好遵守某种规范就可以写通用的代码。

       定义了一组具有各种功能的方法。
       (只是一种能力，没有具体实现，像抽象方法一样，“光说不做”)

       接口既是代码的规范，也是人力资源的规范。
           在代码上，对功能进行修改封闭，大家都知道有这个接口，具体怎么实现不知道。
           反正简便使用这个接口功能即可，无需了解很多。而修改的人反正有了接口，放
           心进行功能修改和优化即可。接口通过约束与规范，就把写与用两方面的人有机
           结合起来。

           另一方法是人力资源的规范。分配工作时，先确定有这个接口，然后分配人力，
           A组用写好的接口去实现他们的具体功能，而B组则去写那些写好但没有具体的代
           码的接口，可以提高工作效率。同时底层与应用层逻辑界限清晰。

           简单地说就是：对修改封闭，对扩展开发。

       当买优盘时，不用担心大小和能否能用？
           因为所有电脑都留下了一个USB接口，电脑只管这个大小的USB口和读写方法。而
           U盘只须按对应的USB接口进行制作，至于存储的大小和速度可以随意，但接口尺
           寸和读写方法是确定好的。

           通过接口规范了电脑与U盘相互必须遵守，这样极大地方便使用。

           同理，内存条也可以放心插入到电脑主板中，不用担心能否使用的问题。

       思考：
           那么上面U盘与内存条情况，谁是接口？谁是实现接口的类？如何实现了多态？

           内存条：内存条规范如ddr3标准是接口。内存条是实现接口的类，每一根内存
                   条都在具体地实现这个接口。在电脑类使用这个接口(实现接口)进行
                   了多态，它只管统一的插口、电压、读写，至于什么样的具体品牌、
                   大小等的内存条(动态子类）无关，随便来个内存条都可以使用。

           U盘：U盘规范标准如USB2.0是接口，U盘是实现接口的类，不同的U盘内部用不
               同的实现。电脑类统一的插口来适应不同品牌、大小等以便多态，只要是。
               U盘就可以接入使用。

       总结：
           接口光说不做（就是规范，就是标准，就是文档，抽象的）
           多态：统一的接口，适应不同的优盘。


   2、接口存在的意义:多态。

       多态的意义: 程序可扩展性。最终->节省成本，提高效率。

       接口解决了类的多继承的问题
       接口解决了类继承以后体积庞大的问题，
       接口之间可以实现多继承


       先从语法角度看一下接口，与抽象类类似。


   3、定义接口

       用interface，一般以I开头命名，以示这是一个接口。
                       以able结尾，以示一种能力、方法。

       接口里面只能包含方法。接口中可以有属性、方法、索引器等 (其实都是方法) ，
       但不能有字段。
           属性也是方法(get,set)
           索引器（名叫Item的属性，也是方法）
           事件也是属性，也是一个方法。

            public interface IFlyable
            {
                void SayHi();//不能有修饰符和实现体

                string Name { get; set; }//只能写能"自动属性"样式

                //string ID//错误属性，不以有实现体
                //{
                //    get { }
                //    set { }
                //}
            }

           注意：
               属性只能写成“自动属性”样式，它不表示自动属性，只表示这是一个未实
           现的属性

           同样索引器：也只能写成简写方法，不能有实现体。

            public interface IFlyable
            {
                void SayHi();//不能有修饰符和实现体

                string this[int index] { get; set; }//正确，索引器简写

                //string this[int index]//错误索引器。不能有实现体
                //{
                //    get { }
                //    set { }
                //}
            }

       接口中的成员不能显式有访问修饰符（默认隐式公开public）

       接口中的成员必须不能有实现，接口不能实例化。
           （它是规范、标准，类似抽象类不能有实现）

       接口中的所有成员"必须"被子类中全部实现。
           除非子类是抽象类，把接口中的成员标记为抽象的。


   4、接口的关键处：

       同一段代码，只要能赋值到接口，那么接口就能调用它们。实现多态。
       下面f.fly()一直不变，但被赋值的"子类"变化，结果也就不一样了，所以此句关键。

        internal class Program
        {
            private static void Main(string[] args)
            {
                IFlyable f = new Bird();
                f.Fly();    //关键，同一代码不同情况不同结果，多态。
                f = new Plane();
                f.Fly();
                Console.ReadKey();
            }
        }

        public interface IFlyable
        {
            void Fly();
        }

        public class Bird : IFlyable
        {
            public void Fly()
            {
                Console.WriteLine("鸟会飞"); ;
            }
        }

        public class Plane : IFlyable
        {
            public void Fly()
            {
                Console.WriteLine("飞机会飞");
            }
        }

   5、抽象类与接口的区别

       既然能用抽象类实现多态，为什么还要用接口来实现多态呢？两者相似度很高。

       1）通过父类来多态时，必须继承父类。由于单根性，只能继承一个父类，如果有多
           个“父类”需要继承时，就没有办法继承了。但如果通过接口，接口可以多继承，
           可以随意实现n个接口继承，就突破了单根性的局限。

       2）突破“面向对象”概念的限制。例如：飞的能力，鸟会飞，飞机会飞，风筝会飞，
           它们不属于同一范畴的类，用共同的父类来强行归类很勉强。又如鱼会游，船
           会游，船和鱼很难归为一类，很难找到共同父类等等。但是，如果用一种能力，
           能容易就附着到别的类中，不必强行归类，不影响面向编程概念，逻辑又清晰。

           简单地说：
               接口可以“实现”多继承，多实现；
               解决了不同类之间的多态问题。

               上面两个类是做不到的、

       两者解决的目的(多态）是一样的，但两者概念和实现过程不同。
           抽象类的验证是通过类is a来验证。（鱼是动物,动物是父类）
           接口的验证是通过can do来验证。 (鱼能游泳，游泳是接口）


       接口可以实现“多继承”（接口一般称多实现，而不称多继承）
           一个类只能继承一个父类，但可以实现多个接口。



   子类继承抽象类，实现接口

三、案例分析

   1、鸟-麻雀sparrow,鸵鸟ostrich,企鹅penguin,鹦鹉parrot,鸟能飞,鸵鸟,企鹅不能飞...
       你怎么办?

       分析：都继承了一个类：鸟，有些能飞，有些不能飞。飞是一种能力。在继承的同时
               加入接口（能力）

        internal class Program
        {
            private static void Main(string[] args)
            {
                IFlyable f = new Sparrow();
                f.Fly();
                //f=new Penguin();//没有这个接口，所以写法是错误的
                Console.ReadKey();
            }
        }

        public interface IFlyable
        {
            void Fly();
        }

        public class Bird
        {
            public void Bark()
            {
                Console.WriteLine("鸟会叫");
            }
        }

        public class Sparrow : Bird, IFlyable
        {
            public void Fly()
            {
                Console.WriteLine("麻雀能飞");
            }
        }

        public class Ostrich : Bird
        {
        }

        public class Penguin : Bird
        {
        }

        public class Parrot : Bird, IFlyable
        {
            public void Fly()
            {
                Console.WriteLine("鹦鹉能飞");
            }
        }

       注意：
           继承的类必须写在第一个，后面跟接口，用逗号间隔各接口。
           鹦鹉会说话可以写成接口，但这里无须说话成多态，故无须接口可写在鹦鹉类中。

           因此，是否写接口，取决于是否要多态，多态则写成接口，否则直接写在本类中。


   2、从学生，老师，校长类中抽象出人的类，学生和老师都有收作业的方法，但是校长不
       会收作业

        internal class Program
        {
            private static void Main(string[] args)
            {
                ICollectable c = new Student();
                c.Collect();
                c = new Teacher();
                c.Collect();
                //c = new Master();//错误，无此接口
                Console.ReadKey();
            }
        }

        public interface ICollectable
        {
            void Collect();
        }

        public class Person
        {
            public string Name { get; set; }
        }

        public class Student : Person, ICollectable
        {
            public void Collect()
            {
                Console.WriteLine("学生收作业");
            }
        }

        public class Teacher : Person, ICollectable
        {
            public void Collect()
            {
                Console.WriteLine("老师收作业");
            }
        }

        public class Master : Person
        {
        }

   3、海关登记：中国人，美国人，德国人等进行登记，这可以提炼出一个共同的人类来进行
       登记。这个登记方法可以用一个方法，接收一个父类人类来写这个方法。但是，如果
       是汽车，就相异于人类，如果是化学物品，也相异于人类，如果强制把它们写成继承
       自人类，那么这个化学物品的年龄是多少？身份证是多少？身高是多少？无论逻辑还
       是语意上不通。
           因此，此时应把他们的登记信息作为一个接口。这样在共享的登记方法时，只需
       要这个共同的接口参数即可，每个东西实现每个东西的信息，从而多态。

        internal class Program
        {
            private static void Main(string[] args)
            {
                IDengJiInfoable dj = new Chinese();
                DengJi(dj);
                DengJi(new Car());
                DengJi(new American());
                Console.ReadKey();
            }

            public static void DengJi(IDengJiInfoable dengJi)
            {
                dengJi.Show();
            }
        }

        public interface IDengJiInfoable
        {
            void Show();
        }

        //public abstract class Person//不必用抽象父类，全部用接口
        //{
        //    public string Name { get; set; }
        //    public abstract void Show();
        //}
        public class Chinese : IDengJiInfoable
        {
            public void Show()
            {
                Console.WriteLine("中国人");
            }
        }

        public class American : IDengJiInfoable
        {
            public void Show()
            {
                Console.WriteLine("美国人");
            }
        }

        public class German : IDengJiInfoable
        {
            public void Show()
            {
                Console.WriteLine("德国人");
            }
        }

        public class Car : IDengJiInfoable
        {
            public void Show()
            {
                Console.WriteLine("轿车");
            }
        }

       提示：反复说接口，并不是练接口怎么写。而是怎么从问题中找出接口、抽象类。
           以及最终怎么实现多态。

       技巧：
           vs2022中上面代码行号的左侧有一个蓝色的小图标，同时附加了一个小箭头。
       鼠标指向它，会提示“已继承...”,说明在接口中可以用“继承”这个用语。
           右击蓝色图标，如果是接口，则会显示具体的哪些类实现了接口/成员。如果
       是类则显示实现自哪个接口/成员。


   4、橡皮rubber鸭子、木wood鸭子、真实的鸭子realduck。三个鸭子都会游泳，而橡皮鸭
       子和真实的鸭子都会叫，只是叫声不一样。橡皮鸭子“唧唧”叫，真实地鸭子“嘎嘎”
       叫，木鸭子不会叫.把抽象类变成接口。

        internal class Program
        {
            private static void Main(string[] args)
            {
                IBarkable[] b = new IBarkable[] { new RubberDuck(), new RealDuck() };
                b[0].Bark();
                b[1].Bark();

                Console.ReadKey();
            }
        }

        public interface IBarkable
        {
            void Bark();
        }

        public class Duck
        {
            public void Swim()
            {
                Console.WriteLine("会游泳");
            }
        }

        public class RubberDuck : Duck, IBarkable
        {
            public void Bark()
            {
                Console.WriteLine("橡皮鸭子唧唧叫...");
            }
        }

        public class WoodDuck : Duck
        {
        }

        public class RealDuck : Duck, IBarkable
        {
            public void Bark()
            {
                Console.WriteLine("真实鸭子嘎嘎叫...");
            }
        }

       注意：
           只有用到了多态，我们才写出对应的接口，否则没有必要写接口。
           另外，接口的多态不能用虚方法或抽象类的多态。
           各自的方法用各自的多态，这里接口所以用IBarkable接口类多态。
           如果是抽象类，那就应用写成abstrack的抽象类来多态。

四、显式实现接口

   1、为什么要显式实现接口？

       方法重名后的解决办法。

       假定一个类实现了两个接口，但每个接口都有一个Fly()的方法，那么方法名重名后
       怎么实现，到底实现的是哪一个的接口Fly()方法呢？

        internal class Program
        {
            private static void Main(string[] args)
            {
                IFlyable1 f1 = new Student();
                f1.Fly();
                IFlyable2 f2 = new Student();
                f2.Fly(); //原意调用f2的，结果显示的是f1的
                Console.WriteLine("---------");

                Teacher t = new Teacher();
                t.Fly();     //正常的接口,1。显式无法调用为private
                IFlyable1 t1 = new Teacher();
                t1.Fly();    //正常的接口,1
                IFlyable2 t2 = new Teacher();
                t2.Fly();    //显式的接口，不再是正常的接口，2.
                Console.WriteLine("---------");

                Master m = new Master();
                m.Fly();
                IFlyable1 m1 = new Master();//用两个不同的接口去访问
                m1.Fly();
                IFlyable2 m2 = new Master();
                m2.Fly();

                Console.ReadKey();
            }
        }

        public interface IFlyable1
        {
            void Fly();
        }

        internal interface IFlyable2
        {
            void Fly();
        }

        internal class Student : IFlyable1, IFlyable2
        {
            public void Fly()
            {
                Console.WriteLine("实现1中的Fly()");
            }
        }

        internal class Teacher : IFlyable1, IFlyable2
        {
            public void Fly()
            {
                Console.WriteLine("实现1中的Fly()");
            }

            void IFlyable2.Fly()//明确告诉用的是IFlyable2中的
            {//不能有访问修饰符
                Console.WriteLine("实现2中的Fly()");
            }
        }

        internal class Master : IFlyable1, IFlyable2
        {
            public void Fly() //只能Master对象调用
            {
                Console.WriteLine("正常接口成员Fly()");
            }

            void IFlyable1.Fly() //只能接口IFlayabel1中对象调用
            {
                Console.WriteLine("1中成员Fly()");
            }

            void IFlyable2.Fly() //只能接口IFlayabel2中对象调用
            {
                Console.WriteLine("2中成员fly()");
            }
        }

       提示：
           vs2022中，对于接口，智能提示时，它的小图标是两个圆圈（一大一小）用一根
       线连接在一起，表示接口。这个小图标下面若有一个白色的心形形状，表示访问修饰
       的是程序集内部(internal)，若把接口改为public，则这个白色形状消失。


   2、显式实现接口后，只能通过接口来调用。

       不能通过类对象本身来调用(显式实现的接口，查看IL是private,防止通过类来调用)
       尽管类中是private，无法通过这个类的对象来调用。但是，它是通过接口的对象来
       调用，而接口的方法默认隐式公开public，所以是能够访问的。
           t2.Fly();//上例中通过t2接口来访问

       对于Master类中，public void Fly()能过本类的对象来访问。
           而后面的两个显示的接口方法，只能仅限对应的接口对象来进行访问。


   3、为什么要有显式实现接口？
       可以解决重名方法的问题。


   4、什么是显式实现接口？

       实现接口中的方法时用：
           接口名.方法名(),并且没有访问修饰符,默认为private，只能通过接口来调用。


   5、显式实现接口后怎么调用？

       只能通过接口变量来调用，因为显式实现接口在类中默认为private.
       只有接口中默认public.

       疑惑：
           在输入要实现接口的类名后，按Alt+Shift+F10，会提示“实现接口”，这样创建
       类时会直接把实现的接口一起写出。
           但是，这个快捷键并不会提示“显式实现接口”。无论怎么折腾，就是不出现显式
       实现接口。猜测原因有：
           1）显式实现接口的情况比较少，所以不需要这样的快捷键。
           2）一般不推荐使用显式接口实现？？？


   6、接口小结

       接口是一种规范。为了多态。
       接口不能被实例化。

       接口中的成员不能加“访问修饰符”。默认为public，不能修改。
       接口的成员不能实现->光说不做。

       接口不能用字段，只能是方法：方法，属性，索引器，事件。
           不能有委托，委托就是字段了。
           因为接口是抽象的、规范的，不能有具体或实现，而字段是具体实现。

       接口与接口之间可以继承，并且多继承。

       实现接口的子类必须实现该接口的全部成员。
       一个类可同时继承一个类并实现多个接口。此时类必须写在最前，因为类为单继承。

       当一个抽象类实现接口的时候，若不想把接口的成员实现，可以把该成员实现
           为abstract。（抽象类也能实现接口，用abstract标记)

       显式实现的接口，只能通过接口变量来调用（因为显示实现接口的成员这private)

       下面说明接口多继承：

        internal class Program
        {
            private static void Main(string[] args)
            {
                ISuperMan s = new SharpMan();
                s.Fly();
                SharpMan s1 = new SharpMan();
                s1.Fly();
                Console.ReadKey();
            }
        }

        internal interface IF1
        {
            void Swim();
        }

        internal interface IF2
        {
            void Fly();
        }

        internal interface IF3
        {
            void Jump();
        }

        internal interface ISuperMan : IF1, IF2, IF3 //超人继承前面三个接口
        {
            void Fly(string s);
        }

        internal class SharpMan : ISuperMan
        {
            public void Fly()
            {
                Console.WriteLine("能飞");
            }

            public void Fly(string s)
            {
                Console.WriteLine("字串能飞");
            }

            public void Jump()
            {
                Console.WriteLine("能跳");
            }

            public void Swim()
            {
                Console.WriteLine("能游");
            }
        }

       说明：
           接口ISuperMan多继承前面三个接口。加上本接口，共有四个方法，因此后面类
       SharpMan必须全部实现接口的四个方法。（fly实现了重载）
           同时还说明了SharpMan类的fly,jump,swim可以由类来访问也可由接口来访问。

五、使用接口的建议

   1、面向抽象编程，使用抽象（父类，抽象类，接口）不使用具体。
       简言之：向上转型。（尽量向上、向父类、向抽象方向进行考虑）


   2、在编程时：

       接口->抽象类->父类->具体类（接口最优先，抽象类其次，具体类最后）
           (在定义方法参数、返回值、声明变量的时候，能用抽象就不要用具体。）

       能使用接口就不用抽象类，能使用抽象类就不用类，能用父类就不用子类。

       避免定义“体积庞大的接口”，“多功能接口”，会造成“接口污染”。
           只把相关联的一组成员定义到一个接口中（尽量在接口中少定义成员）。

       单一职责原则：
           定义多个职责单一的接口（小接口）（组合使用）。
           印刷术与活字印刷术：古代最开始印刷是把整个版本刻成文字，若这一版有一个
               文字出错，则整个版本报废。活字印刷就是把整个版本分成一个一个单一的
               文字，每个文字可以取下、可以安装上。这样如果有一个错误，不需要整个
               版本报废，只需要把这个错误字取下，用正确的字代替即可。
           接口也一样，不要大而全。按照单一职责原则，分成多个单一职责的小接口，调
               试与维护方便，编写逻辑清晰。


   3、如果父类已经实现了接口，子类是否还实现接口？(书籍《改善程序的50个建议》)

           不必了，子类将继承父类接口的实现。所以子类不必再加上接口再实现。
           但是，微软类库文档中，子类继承已实现接口的父类，往往会再一次加上接口，但
       是它并不在子类内再写一次。这是因为转型效率原因，子类接口会直接调用实现，如果
       子类不写接口，在内部它会再较型到父类，再调用父类实现的接口方法，多了一次转换。

       internal class Program
        {
            private static void Main(string[] args)
            {
                IFlyable s = new Student();//子类用new
                s.Fly();//1
                Console.ReadKey();
            }
        }

        internal interface IFlyable
        {
            void Fly();
        }

        internal class Person : IFlyable
        {
            public string Name { get; set; }

            public void Fly() // 2
            {
                Console.WriteLine("父类接口飞...");
            }
        }

        internal class Student : Person, IFlyable //3
        {
            //public new void Fly()// 4  正确，有意隐藏父类飞
            //{//父类接口被隐藏。此Fly可由Student及其对应接口访问,但不是父类继承来的接口
            //    Console.WriteLine("子类接口飞...");
            //    base.Fly();// 6 此处是父类接口
            //}

            //public override void Fly()// 5  错误,override只能与abstract,virtual配对
            //{
            //    Console.WriteLine("错误飞...");
            //}
        }

       说明：
           2处父类Person实现了接口。继承到子类Student时，3处无须再写IFlyable，子
       类也将继承由父类实现的接口方法Fly()。但为了效率，3处可以直接调用方法Fly(),
       不必内部再转Person再调用Fly()，故3处这里再次写上IFlyable。
           5处是错误的，原意要重写由父类过来的接口实现Fly()，但override不能直接单
       独使用。
           4处去注释后是正确的。它隐藏父类过来的Fly，会有警告，正式的写法是前面
       应加new起到显式隐藏父类同名方法。这样子类类外无再这样调用父类同名方法，但
       子类Student类内仍然可以用6处的base.Fly()进行调用父类Fly().
           1处运行时，会显示父类接口飞。如果把4处的注释去掉，运行时，4处将重写父
       类Fly，而显示子类接口飞。

       注意：
           3处的接口IFlyable可以去掉，1处的去处结果不会发生变化。3处加上这个接口
       一是为了效率。二是为了显式多态，父类群诸如Person等可以通过IFlyable多态，子
       类群诸如Student等也可以多态，但查看时需要从Student向上再去看父类，不方便，
       同时也不灵活。在子类中直接写上接口IFlyable而不必实现，一眼就可以看出可实现
       多态，而且还可以直接在子类重写，实现同等级父类，与诸多子类的多态。
           上面1处用子类Student多态时，显示是父类接口内容。但如果4处重写了，用子类
       Student多态时，就显示的是子类接口内容。

       提示：
           父类中用了接口，就必须实现，不能等到子类进行实现。上面中Person必须实现，
       否则出错。除非父类是一个抽象类，把这个接口在抽象类中写成抽象方法。


   4、如果接口有AB两个方法，父类实现A方法，子类实现B方法，是否可以？

           不可以！只要实现接口，就必须把这个接口全部实现。必须在父类中把AB两个方
       法全部实现，否则出错。除非父类是一个抽象类。
           抽象类中可以实现接口也可不实现接口，但不实现时须注明抽象方法。

        internal class Program
        {
            private static void Main(string[] args)
            {
                IFlyable s = new Student();
                s.Fly();
                s.Swim();
                Console.ReadKey();
            }
        }

        internal interface IFlyable
        {
            void Fly();

            void Swim();
        }

        internal abstract class Person : IFlyable
        {
            public string Name { get; set; }

            public void Fly()//实现接口中的一个方法
            {
                Console.WriteLine("父类接口飞...");
            }

            public abstract void Swim();//接口方法，不实现，须写成抽象方法
        }

        internal class Student : Person, IFlyable 
        {
            public override void Swim()//子类中重写，并实现接口方法
            {
                Console.WriteLine("子类游...");
            }
        }

   5、同一个接口能在一个类中写两次么？如下面：

        Internal Class Student:IFlyable,IFlyable

       不能！编译器会报错：已经实现接口。

六、复习

   (一)抽象类复习、简单工厂设计模式复习

   1、抽象类：

       不能被实例化，需要被继承。多态
       子类必须重写父类中的所有的抽象成员，除非: 子类也是一个抽象类

       抽象成员在父类中不能有任何实现。
       抽象类中可以有实例成员。

       抽象成员的访问修饰符不能是private
       抽象成员只能写在抽象类中。


   2、作业: 通过案例笔记本电脑的选择。笔记本电脑父类NoteBook、不同品牌的笔记本产
       品。(继承+简单工厂)

        internal class Program
        {
            private static void Main(string[] args)
            {
                string s = "联想";
                NoteBook b = GetCumputer(s);
                b.Show();
                Console.ReadKey();
            }

            private static NoteBook GetCumputer(string s)
            {
                switch (s)
                {
                    case "联想":
                        return new Lenovo();

                    case "三星":
                        return new Suming();

                    default:
                        return new Dell();
                }
            }
        }

        internal abstract class NoteBook
        {
            public abstract void Show();
        }

        internal class Dell : NoteBook
        {
            public override void Show()
            {
                Console.WriteLine("戴尔电脑");
            }
        }

        internal class Suming : NoteBook
        {
            public override void Show()
            {
                Console.WriteLine("三星电脑");
            }
        }

        internal class Lenovo : NoteBook
        {
            public override void Show()
            {
                Console.WriteLine("联想电脑");
            }
        }

   （二）接口复习
       定义接口的语法(interface)
       接口中只能包含方法、属性、索引器、事件。不能包含字段。
           见备注1 (貌似事件像一个字段?其实是两个方法。reflector查看源码)

       接口中的成员不能有任何的实现
           (真正的“光说不做”。思考这样做的意义。联想抽象类中的抽象方法。)
       接口中的成员不能写访问修饰符。

       使用接口的语法
           一个类可以实现多个接口。实现接口的类，必须把接口中的所有成员都实现。

       子类实现接口中的成员时，不能修改成员的访问修饰符、参数列表、方法名等。
           (与方法重写一样)

七、面试题

   提示：除了回答正确外，表达是否清晰，语气是否紧张也是加分项。
       回答是对本类问题尽量多说，但外展尽量少说（会无穷追问无关项，累)。
       把面试当作一个平等的交流，不是一问一答。

   1.如何使用virtual和override ?
       Person per = new Student();
       per.SayHI();//调用的子类重写的SayHi方法(语法、应用-多态)

       答：virtual与override是虚方法中的配对使用。虚方法是父类中必须实现，子类
       中可以不实现。父类中方法用虚方法时加virtual，对应的子类同名方法重写时用
       override。有virtual时不一定有override,有overide时父类必须有abstract或
       virtual。虚方法主要用于多态。


   2.如何使用abstract和override?

       答：abstract与override是抽象方法配对使用。父类中的方法前加abstract时，父
       类必须也是abstract(抽象方法只能存于抽象类中），同时抽象方法在父类中不允许
       实现，只能在子类（除非子类又是抽象类）中实现。有abstract必须有override，
       有override则必须有abstract或virtual出现。抽象方法主要用于多态，比虚方法更
       常见。


   3.“方法重载overload”、“方法重写override"、"隐藏new"是同个概念吗?

       答：重载是同名但函数签名不同的多个方法共存时，依据不同签名选择对应方法，
       它相当于编译器多态。重写是父类同名方法在子类中改写的情况，override只能是
       有virtual或abstract时进行重写父类同名方法。重写override父类必须有virtual
       或abstract，主要用于多态。隐藏new，用于子类中要隐藏父类类继承过来的同名
       方法，使用new后，父类方法隐藏，且不再继续向下继承，意同sealed.


   4.抽象类和接口的区别?

       答：抽象类适用于同一系列，并且有需要继承的成员。有清晰的群类关系。
           接口适用于不同系列的类具有相同的动作(行为、动作、方法)。
           对于不是相同的系列，但具有相同的行为，这个就考虑使用接口。
           接口解决了类不能多继承问题。

八、类型转换

   （一）类型转换：CAST

   1、隐式类型转换

       数字类由小到大可以直接赋值，称之为隐式转换。如:byte->int->float->double

            byte b = 23;
            int n = b;
            float f = n;
            double d = f;
            Console.WriteLine(d);

注意下面:

            char c = '王';//c='z';
            int n = c;
            Console.WriteLine(c);

       char在内存显示的数字ASC码，在显示时转为字符。它是2个字节，int是4个字节，
       因此int可以隐式容纳char.

            Console.WriteLine(sizeof(byte));//1
            Console.WriteLine(sizeof(bool));//1
            Console.WriteLine(sizeof(char));//2
            Console.WriteLine(sizeof(short));//2
            Console.WriteLine(sizeof(long));//  8
            Console.WriteLine(sizeof(int));//4
            Console.WriteLine(sizeof(float));//4
            Console.WriteLine(sizeof(double));//8
            Console.WriteLine(sizeof(decimal));//16

       注意：
           sizeof()：确定给定类型的内存需求（占用的字节数）。
           由于sizeof参数是一个非托管类型的名称，因此需要在不安全的上下文中运行。
       但微软确认下面不需要“不安全”:
           byte,short,int,long,char,float,double,decimal,bool

           包括枚举与结构，都不需要在不安全的上下文运行，但指针需要：

            internal enum Person
            {
                name1,
                name2,
                name3,
                name4
            }

            private static void Main(string[] args)
            {
                unsafe
                {//指针只能在unsafe括号内运行，否则出错。
                    Console.WriteLine(sizeof(byte*));//4
                    Console.WriteLine(sizeof(int*));//4
                }
                Console.WriteLine(sizeof(Person));//4
                Console.ReadKey();
            }

           上述代码需要设置允许不安全代码：右击当前项目->点击属性->点击左侧生
       成->勾选右侧"允许不安全代码"。(vs2022)


   2、显示类型转换

       由大到小转换可能有误，需要显式转换以确认转换。double->float->int->byte

        double d = 23;
        float f = (float)d;
        int n = (int)f;
        byte b = (byte)n;
        Console.WriteLine(b);

   3、引用类型

       学生类Student继承于父类Person.
       把学生转换为人是隐式转换，把人转换为学生则是显式转换(强制转换)

        Student s = new Student(); 
        Person p =s;//隐式类型转换
        Student stu =(Student)p;//显式类型转换

       obj as 类型 //成功返回类型，失败返回null.

       只有在内存存储上存在交集的类型之间才能进行隐式转换。

       不能用Cast转换string->int，只能用Convert。
           Convert.Tolnt32/Convert.ToString


   4、类型转换Cast是在内存级别上的转换。内存中的数据没有变化，只是观看的视角不
       同而已。


   5、什么情况下会发生隐式类型转换?

       1）把子类类型赋值给父类类型的时候，会发生隐式类型转换。
       2）将占用字节数小的数据类型，赋值给占用字节数大的数据类型，
           可以发生隐式类型转换(前提是这两种数据类型兼容，在内存的同一个区域)

       注意：

            Math.Round();/四舍五入
            Convert.ToInt32();//四舍五入

   6、结构类型占内存多大？

       结构类型不是微软预定义的类型，只能在不安全代码中运行。
       它的大小由内部成员确定，并根据字节对齐或优化的情况进行计算。
       特别的：string的大小不固定，sizeof表示它的指针大小。

        private struct Person
        {
            private string Name ;//1
            private int age;//2

            private string ID;//3
            private char BloodType;//4
        }

        private static void Main(string[] args)
        {
            unsafe
            {//结构大小只能在不安全上运行
                Console.WriteLine(sizeof(Person));//16
                Console.WriteLine(sizeof(String));//4  没有预定义不能在括号外运行。
            }

            Console.ReadKey();
        }

       说明：
           sizeof(String)是4个字节，只能在unsafe中运行。
           结构按最大字节4的成员进行对齐，每个都是4字节，故为4*4=16字节。
           注释掉1处，结果12;
           注释掉1、2处，结果8; 都按最大4字节对齐
           注释掉1、2、3处，结果2; 只有一个成员无须再对齐，就是char本身2个字节。
           注释掉1、2、3、4处，结果1.

           如果把age的int改为double，结果为20。说明按4*3+8=20进行对齐和优化。




   （二）类型转换：Convert

   1、Convert考虑数据意义的转换。 Convert是一个加工、改造的过程。

       若要进行其它类型的转换可以使用Convert.Tolnt32，Convert.ToString等。

       Convert可以把object类型转换为其它类型

        string str = null;
        int num;
        num = Convert.ToInt32(str);
        Console.Write(num + "\r\n");
        //num = Int32.Parse(str);//不能为null，否则异常
        //Console.Write(num + "\r\n");
        Int32.TryParse(str, out num);
        Console.Write(num + "\r\n");

   2、(int),Int32.Parse(),Int32.TryParse(),Convert.ToInt32()的区别


   3、将字符串转换成“数值类型”(int、foat、double)

        int.Parse(string str);
        int.TryParse(string str,out int n);//很常用，推荐。
        
        double.Parse(string str);
        double.TryParse(string str,out double d)
        ......

       Parse()转换失败报异常，
       TryParse()转换失败不报异常。


   4、再说as与直接类型转换: (*)

       如果用is a来进行类型判断后，再进行类型转换：
           if(p is Student)
           {
               Student stu=(Student)p;
           }
       那么，CLR会进行两次类型检查：
           if(检查一次)
           {
               //再检查一次
           }
       所这种情况效率比较低，推荐直接用as，成功返回对象，失败返回null。
           Student stu=p as student;
           //推荐，效率高于第一种，如果转换失败返回null,而不会报异常。


   5、类型提取

       GetType()：获取当前实例的 Type。 GetType()不允许重写。
       BaseType：获取当前 Type 直接从中继承的类型

       所有数组类型继承于Array，所有类型继承于Object。
       Object没有基类(父类),再次提取BaseType时为null.

        string[] s = new string[] { "李世明", "雍正", "孙中山" };
        Console.WriteLine(s.GetType().ToString()); //System.String[]
        Console.WriteLine(s.GetType().BaseType.ToString());//System.Array
        Console.WriteLine(s.GetType().BaseType.BaseType.ToString());//System.Object
        Console.WriteLine(s.GetType().BaseType.BaseType.BaseType.ToString()); //对象为null,异常

       技巧：
           一般中断或异常后，鼠标指向某变量或对象或数组等，会有值的提示。
           但是如果用点号取成员很长时，不会有提示，不知道是哪一级成员出问题。

           可以使用快速监视或添加监视来看：
           在指定可能问题处中断，或异常时，在多级成员处，先选择短的成员，例如
       s.GetType()，然后右击选择快速监视(Ctrl+F9)，或者添加监视，这样就可查看
       值的情况。以此类推，选择s.GetType().BaseType再监视，如此，直到查看到问
       题所在。

6、将任意类型转换成字符串:ToString()

7、技巧：
当遇到类型转换的时候不知道该怎么转，可以去Convert中找找

九、异常处理

   1、什么是异常?

       程序运行时发生的错误。

       错误的出现并不总是程序员人的原因，有时应用程序会因为最终用户或运行代码
       的环境改变而发生错误。比如:

           1）连接数据库时数据库服务器停电了，
           2）操作文件时文件没了、权限不足等，
           3）计算器用户输入的被除数是0;
           4）使用对象时对象为null，等等。

       .net为我们把“发现错误(try)”的代码与“处理错误(catch)”的代码分离开来。


   2、异常处理的一般代码模式:

        try
        {
            //1可能发生异常的代码
        }
        catch (Exception)
        {
            //2对异常的处理
        }
        finally
        {
            //3无论是否发生异常、是否捕获异常都会执行的代码
        }

       try块: 可能出问题的代码。当遇到异常时，后续代码不执行。
       catch块: 对异常的处理。记录日志(log4net)，继续向上抛出等操作。
               (只有发生了异常，才会执行。)
       finally块: 代码清理、资源释放等。无论是否发生异常都会执行。

       重要：finally可以省略。catch块可能有多个，以便捕获不同异常。

       注意：
           除非必须用try...catch...，一般尽量不要用。
           因为try...catch会监视try执行的代码，影响程序执行的效率。

       技巧：
           vs2022中，由于当前解决方案有多个项目，如何一次性关闭它们？
           右击（主IDE界面中）代码窗上面的标签，选择“关闭所有选项卡”，或者选择
           “除此之外全部关闭”，可快速关闭其它项目或全部项目的标签。
               也可以在菜单上的“窗口”菜单里进行操作，只是有点不习惯。


   3、案例:

            try
            {
                int x = 5;
                int y = 0;
                int z = x / y;
            }
            catch
            {
                Console.WriteLine("除数不能为0");
            }

           程序运行运行时出错，后续的内容无法运行程序一旦有一个功能发生异常，整
       个程序崩溃其它功能也无法正常运行

       技巧：
           vs2022中，如何快速添加try语句块？
           1）选中可能出问题的语句块，按Ctrl+k，Ctrl+s后，在弹出小窗口中选择try。
           2）选中可能出问题的语句块，右击->片段->外侧代码->选择try

       提示:
           catch(Exception ex)后面的参数可加可不加。
           加上参数后，可以看出问题的相关信息。例如：

        internal class Program
        {
            private static void Main(string[] args)
            {
                Person p = new Person();
                p = null;  //p被释放，不再指向任何对象
                try
                {
                    p.Name = "Test";//1
                    Console.WriteLine(p.Name);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
                Console.ReadKey();
            }
        }

        internal class Person
        {
            public string Name { get; set; }
        }

       注意：
           尽管上面用了try,但并不能捕获。仍然会在1处抛出异常。
           原因：Debug与Release两个模式中的try-catch运行情况是不同的。Debug模式
       并不能捕捉此类异常。（Debug调试模式，Release发布模式)
           解决方法：运行上面代码，抛出异常后，在异常小窗口中选择最下面“打开异
       常设置”，在“异常设置”小窗体中的右上输入null进行搜索，去掉System.NullRefe
       renceException的勾选即可。

           再次运行，就会捕捉到，将异常信息ex.Message显示：
               未将对象引用设置到对象实例。

           同理前一个案例除以0的，若带异常参数信息，则显示：
               尝试除以零。


   4、异常处理代码的其他几种形式:

       1）一个catch,捕获所有异常:不带参

            private static void Main(string[] args)
            {
                int x = 5, y = 0;
                try
                {
                    int z = x / y;
                }
                catch //无参，捕获所有异常
                {
                    Console.WriteLine("发生异常了");
                }
                finally
                {
                    Console.WriteLine("finally块");
                }
                Console.ReadKey();
            }

           上面可捕获所有异常，但无法获取异常信息。

       2）一个catch,捕获所有异常:带参（可获取异常信息）

            private static void Main(string[] args)
            {
                int x = 5, y = 0;
                try
                {
                    int z = x / y;
                }
                catch (Exception e)//带参，可获取异常相关信息
                {
                    Console.WriteLine(e.Message);//异常信息
                    Console.WriteLine(e.Source);//异常源（程序或对象）
                    Console.WriteLine(e.StackTrace);//栈上跟踪信息
                    Console.WriteLine(e.TargetSite);//引发异常所在的方法（地点）
                }
                finally
                {
                    Console.WriteLine("finally块");
                }
                Console.ReadKey();
            }

       3）多个catch块单独针对可能异常捕获，只要有一个捕获，其余catch将不再捕获。
           一般最后写一个总的捕获，这样前面捕获不到时，由最后的总的捕获处理。

            private static void Main(string[] args)
            {
                int x = 5, y = 0;
                try
                {
                    int z = x / y;
                }
                catch (NullReferenceException e)//1空指针异常
                {
                    Console.WriteLine("空指针异常，{0}", e.Message);
                }
                catch (ArgumentException e)//2参数异常
                {
                    Console.WriteLine($"参数异常，{e.StackTrace}");
                }
                catch (DivideByZeroException e)//3除数为零异常
                {
                    Console.WriteLine($"除数为零，{e.StackTrace}");
                }
                catch (Exception e)//4其余异常,不能写在最前面
                {
                    Console.WriteLine($"异常信息{e.Message}");
                }

                Console.ReadKey();
            }

           注意：
               怎么知道分别出现哪些异常种类，以便分别写出catch?
               1）靠经验与推测，每次出现异常时，看看异常小窗体中的信息，有印象
               2）注释掉上面1到4的信息，运行则报出异常的种类。
               3）可以在.Net Reflector中搜索System.Excepton，查看异常信息.

           为什么要分别catch处理？
               主要是编程上的逻辑清晰，功能分类。也可以不分别处理，直接在一个总
           的异常中用switch或if进行判断处理。

       4）没有catch块,只有try-finally。（catch与finally可以两者现，也可现其一)
           由于没有catch所以不会捕获，同平时一样会抛出异常。
           不同的是，有了一个finally可以最终处理一下。

   5、强调

       1）既然finally最后都是执行，那直接把finally去掉行不行？
               不行。finally是无论异常否，都必须执行。哪怕try或catch中有return，
           这个语句块也必须执行。
               另外，finally后面代码在异常后是不能执行的，那么一些无论异常否都
           得处理的后尾问题，就可以放在finally中进行扫尾工作。比如：catch没有
           捕获到，那么finally后面代码是不能执行的，程序可能崩溃，而finally必
           须执行就可以在里面添加一些处理代码。
               或者catch块中又有异常，finally就是最终应对方式。

               由此可见finally并不是可有可无的。

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

            private static void Main(string[] args)
            {
                try
                {
                    string s = null;
                    ProcessString(s);
                }
                catch (ArgumentNullException e)
                {
                    Console.WriteLine("{0}Fist exception caught.", e);
                    return;
                }
                catch (Exception e)
                {
                    Console.WriteLine("{0}Second exception caught.", e);
                    return;
                }
                finally
                {
                    Console.WriteLine("必须执行");
                    //return;//错误
                    Console.ReadKey();
                }
                Console.WriteLine("末尾");
                Console.ReadKey();
            }

            private static void ProcessString(string s)
            {
                if (s == null)
                {
                    throw new ArgumentNullException();
                }
            }

           为什么finally里面不能有return?
               因为finally块无论如何里面代码都必须执行。如果里面有了return,
           那么有可能直接返回，有些代码就执行不了。所以不能有return.

           上面代码还可以看出，方法体写在try中，对整个方法也会捕捉。


       2）throw

           除了电脑抛出异常，也可以人为手工抛出异常。

            string s = "k";
            if (s == "k")
            {
                throw new Exception("异常");
            }

               Exception是所有异常的基类。new Exception("")创建一个新异常对象.
               程序一般不人为抛出异常，因为它浪费资源。上述代码，一般判断后直接
           给出提示或者处理办法。

           有时直接使用throw; 后面不加参数直接分号。
               它仅限于在catch块中使用。表示将当前的异常继续向上抛出。
               类似低级人员逐级上报给上一级的领导，有一个throw;就报上报一次。

            private static void Main(string[] args)
            {
                try
                {
                    Console.WriteLine("9999");
                    M1();
                    Console.WriteLine("aaaa");
                }
                catch
                {
                    Console.WriteLine("bbbb");
                    throw;//3
                }
                Console.ReadKey();
            }

            private static void M1()
            {
                try
                {
                    Console.WriteLine("1111");
                    M2();
                    Console.WriteLine("2222");
                }
                catch (Exception)
                {
                    Console.WriteLine("8888");
                    throw;//2
                }
            }

            private static void M2()
            {
                int x = 5, y = 0;
                try
                {
                    Console.WriteLine("3333");
                    int n = x / y;   // 4
                    Console.WriteLine("4444");
                }
                catch
                {
                    Console.WriteLine("5555");
                    //n = 3;// 3 try块中n是局部变量，不能在catch块中使用
                    throw;//1
                    Console.WriteLine("6666");//throw后面的代码不再执行
                }
                finally
                {
                    Console.WriteLine("7777");
                }
                 Console.WriteLine("xxxx");//5
            }

           注意：
               1)各块中局部变量不能跨越使用。例如上面4处的变量n，不能在3处使用.
               2)throw;仅在catch中使用，且逐级上报。1处的异常来自于4处的同一个
                   异常，4处把异常转交给1处，1处throw向上抛给上级M1报告，在M1
                   中捕获后，在2处继续向上级Main()上报，主函数捕获后，在catch中
                   继续上报（谁呢？但程序这里没出错），到此时，这个异常就抛出来
                   了，直接由这个“报告”查找到异常的原产地1处。
                   （这里本身的n=x/y异常已经转交给了1处的throw）
                   所以执行顺序9->1->3->5->7->8->b
               3）throw是手工抛出，所以最终还是显示为同平常抛出异常一致。
                   如果注释掉3处，则相当于高层处理了这个异常“报告”,不再抛出。
                   如果注释掉3处和2处，同上。只是最后有a无b，因为没有异常了。
                   如果只注释掉2处，则3处异常不会抛出，相当于中级官员已经把上报的
                       异常“报告”处理了，所以顺序为9->1->3->5->7->8->a(无异常无b)

                   throw是抛异常，所以如果M1()与M2()的finally块的后面有代码，将不
                   执行。（例如5处的x不会显示）

       3)异常信息

           Exception 类主要属性: Message、StackTrace、InnerException (当前异常的实例)
           扔出自己的异常。扔: throw，抓住: catch

           建议:
               通过逻辑判断(if-else)减少异常发生的可能性!
               尽量避免使用“异常处理”。

           在多级方法嵌套调用的时候，如果发生了异常，则会终止所有相关方法的调用，
               并释放相关的资源

十、代码观察

1、下面try块中发生异常与不发生异常时的输出结果分别是什么?

        private static void Main(string[] args)
        {
            T1();
            Console.ReadKey();
        }

        private static void T1()
        {
            try
            {
                Console.WriteLine("1111");
                ---引发异常代码开始---
                //int x = 10, y = 0;
                //Console.WriteLine(x / y);
                ---引发异常代码结束---
                Console.WriteLine("2222");
                return;
                Console.WriteLine("3333");
            }
            catch (Exception)

            {
                Console.WriteLine("4444");
            }
            finally
            {
                Console.WriteLine("5555");
            }
        }

       1)不引发异常时：
           1->2->5
           因不异常catch不执行，到return时退出方法，3执行不到。
       2)引发异常时(去掉注释）：
           1->4->5
           因异常try块后续代码不执行，直接到4，最后必须finally里的5.


   2、下面try块中发生异常与不发生异常时的输出结果以及方法的返回值是什么?

        private static void Main(string[] args)
        {
            int r = GetNumber();
            Console.WriteLine(r);
            Console.ReadKey();
        }

        private static int GetNumber()
        {
            try
            {
                int n1 = 10, n2 = 0;
                ---引发异常代码---
                // int n3 = n1 / n2;
                ---引发异常代码---
                return 100;
            }
            catch (Exception ex)
            {
                Console.WriteLine("1111");
                return 200;
            }
            finally
            {
                Console.WriteLine("2222");
            }
        }

       1)不异常时：
           输出2，返回100.主程序r输出100
       2)异常时(去掉注释)：
           输出1->2,返回200.主程序r输出200


   3、下面try块中发生异常与不发生异常时fnally块中的代码是否被执行了? 该方法
       的返回值又分别是多少?

        private static void Main(string[] args)
        {
            int n = M1();
            Console.WriteLine(n);//a
            Console.ReadKey();
        }

        private static int M1()
        {
            int result = 100;
            try
            {
                result += 1;
                ---引发异常代码---
                //int x = 10, y = 0;
                //Console.WriteLine(x / y);
                ---引发异常代码---
                return result;
            }
            catch (Exception ex)
            {
                result += 1;
                return result;
            }
            finally
            {
                result += 1;
            }
        }

       1)不异常时：
           返回result是101,主程序a处输出101.
           原因：先生成执行文件，用.Net Reflector反编译查看，上面的M1方法：

           可以看到在方法M1中另外生成了一个变量num2，专用于返回值。就类似
       我们传参数到另一个方法时，会创建形参来保存传过来的实参。同样，在返
       回时，会同样单独另外创建一个参数(num2)来保存返回值.
           因此，不异常时，num2保存101后，尽管在finally里num++成102，但为
       返回值创建的变量num2仍然是101，所以返回值仍然是101.

           是不是只有try-catch才单独创建一个变量用于返回值呢？
           不是！！只要方法有返回值，就会单独创建一个用于返回值的临时变化，
       没有返回值的方法是不会创建的。下面测试一下：

           为上面代码添加两个方法：

        private static int T1()
        {
            int n = 100;
            n++;
            return n;
        }

        private static int T2()
        {
            return 1;
        }

再次生成反编译查看T1：

发现并没有另一个变量出现。切换到IL（中间语言）查看：

       可以看一T1()方法出现了另一个变量num2,并且在返回之前加载了索引为1的变量
       也就是num2。
       同样的对于T2()在C#反编译时没有看到变量，但切换到IL可以看到：

       T2()进去后就单独生成了一个变量num（索引为0），在返回之前加载索引为0的
       变量即num。

           这里面涉及IL操作比较艰深，有反汇编基础的可以了解一下。参考：
           https://www.cnblogs.com/cc299/p/14539782.html

       结论：
           进入任何有返回值的方法后，都会为返回值创建一个单独的临时变量，用它来
       存储返回值。即：
               临时变量=返回值;
               return 临时变量;
           若无返回值，这个变量不会单独创建（可自行试验）

       注意：
           平时无须关心有返回值时，单独创建的另一个变量。只有finally强制必须执
       行时，前面try或catch有return时，才考虑返回值发生变化的情况。

       2)有异常时（去掉注释）：
           返回值是102，a处输出为102.
           由1）知道finally块中并不能影响try与catch块中的return的值，故为102.


   4、下面当调用该方法时，返回的Person对象的Age属性在try块中发生异常与不发生
       异常时输出结果分别是多少?

        internal class Program
        {
            private static void Main(string[] args)
            {
                Person p = GetPerson();
                Console.WriteLine(p.Age);
                Console.ReadKey();
            }

            private static Person GetPerson()
            {
                Person p = new Person();
                p.Age = 100;
                try
                {
                    p.Age += 1;
                    ---引发异常代码---
                    //int x = 10, y = 0;
                    //Console.WriteLine(x / y);
                    ---引发异常代码---
                    return p;
                }
                catch (Exception)
                {
                    p.Age++;
                    return p;
                }
                finally
                {
                    p.Age++;
                }
            }
        }

        internal class Person
        {
            public int Age { get; set; }
        }

       1）不引发异常时：
           102
           原因：实际与上面一样，会为返回值创建一个单独的临时变量Person2：

           仍然一样进行了赋值person2=person，finally也进行了person.Age++，但
           是person2与person是引用类型，指向同一个对象，任何一个更改时，另一
           个同样随之改变。所以person.Age++同样影响person2，再次加1，结果102.
       2）引发异常时(去掉注释）:
           103
           由于是引用类型，连续三次加1都会影响person，故为103.

十一、函数返回值(函数参数前的修饰符)

   1、params 可变参数

       1）无论有几个参数，必须出现在参数列表的最后。

       2）可以为可变参数直接传递一个对应类型的数组

       3）可变参数可以传递参数，甚至可以为null(无对象)。
           也可以不传递参数，则形参为长度为0的数组。

        private static void Main(string[] args)
        {
            GetLength("aaaa", 1, 2, 3, 4);//aaaa-4
            GetLength("bbbb", null);//空对象 bbbb
            GetLength("cccc");      //有对象长度为0，cccc-0
            int[] n = { 1, 2, 3 };
            GetLength("dddd", n);    //dddd-3
            //GetLength("eeee", 1, n);//错误 无法转换
            //GetLength("ffff", n, 1);//错误 无法转换
            Console.ReadKey();
        }

        private static void GetLength(string s, params int[] n)
        {
            if (n != null)
            {
                Console.WriteLine(s + "----" + n.Length);
            }
            else
            {
                Console.WriteLine(s);
            }
        }

   2、ref 引用传递

       仅仅是一个地址，，可以把值传递强制改为引用传递

   3、out 让函数可以输出多个值

       1.在方法中必须为out参数赋值（才能使用）

       2.out参数的变量在传递之前不需要赋值，即使赋值了也不能在方法中使用。
           (赋值没意义，甚至只须在参数中声明类型即可)

       out参数如同布施乞丐一样，钱只能付出去，不能从乞丐碗中取出。
           而且必须把钱布施出去。所以见到out就当做功德吧。

        private static void Main(string[] args)
        {
            int m = 200;
            int n, z;
            T1(out m);
            T1(out int y);//此处int y作用区与T1的作用区一样，所以最后可以输出y=101

            //T2(out n);//n传入前不必赋值
            //T3(out m);

            //T(ref int a);//不能象out一样在实参时声明
            //T(ref 222);//错误，因为要用变量别名，传地址，不能用常量
            //T(ref z);//错误，不能象out一样使用前不赋值
            z = 1;
            T(ref z);
            Console.WriteLine(z);//101
            Console.WriteLine(y);//101
            Console.ReadKey();
        }

        private static void T(ref int x)
        {
            x = 100;
            x++;
        }

        private static void T1(out int x)
        {
            x = 100;
            x++;
        }

        //private static void T2(out int x)
        //{//错误out必须带出，不能带入，此方法内x未同赋值，语法错误
        //    Console.WriteLine(x);//错误
        //    x++;
        //}

        //private static void T3(out int x)//错误。空方法也必须赋值x。必须布施
        //{
        //}

       上面基本覆盖了out与ref的使用情况。

       ref与out的区别：
           ref:参数在传递之前必须赋值
           在方法中可以不为ref参数赋值，可以直接使用


   4、既然有了ref可以引用传递，为什么还要设置一个out来作为参数呢？

       ref应用场景用于内部对外部的值进行改变，
       out则是内部为外部变量赋值，out一般用在函数有多个返回值的场所。

       这样要需要多个返回值时，可以考虑out

        private static void Main(string[] args)
        {
            int m = 1000;
            JianJin(ref m);
            KouKuan(ref m);
            Console.WriteLine(m);

            //获取年龄的同时，传回多个参数：姓名，身高
            int age = GetAge(out string name, out int height);
            Console.WriteLine(age + "---" + name + ":" + height);

            //int.TryParse中的out
            string s = "abc";
            int result;
            bool b = int.TryParse(s, out result);
            if (b)
            {
                Console.WriteLine("成功:" + result);
            }
            else
            {
                Console.WriteLine("失败:" + result);
            }
            Console.ReadKey();
        }

        private static int GetAge(out string n, out int h)
        {
            n = "黄林";
            h = 180;
            return 1000;
        }

        private static void JianJin(ref int m)
        {
            m += 300;
        }

        private static void KouKuan(ref int m)
        {
            m -= 30;
        }

   5、out参数方法中能否用params?

       不能！
       params主要的应对场景是传参前的多个不定数目的同类参数。针对传参前的变化。
       而out跟传参前基本无关，只须声明甚至连赋值都省略了。重点是传参后的返回。
       所以应用的场景不同，不能连用。

十二、ref与out的案例练习

1、案例1: 两个int变量的交换,用方法做。ref ? out

        private static void Main(string[] args)
        {
            int m = 10, n = 20;
            //Swap(ref m, ref n);//方法一
            Swap1(m, n, out m, out n);//方法二
            Console.WriteLine(m + "---" + n);
            Console.ReadKey();
        }

        private static void Swap1(int m1, int n1, out int m2, out int n2)
        {
            m2 = n1;
            n2 = m1;
        }

        private static void Swap(ref int m, ref int n)
        {
            int temp = m;
            m = n;
            n = temp;
        }

   2、案例2: 模拟登陆，返回登陆是否成功(bool)，如果登陆失败，提示用户是用户名
       错误还是密码错误。admin、888888
       [两个返回值，一个bool，一个string] ref ? out

        private static void Main(string[] args)
        {
            Console.WriteLine("请输入用户名：");
            string name = Console.ReadLine();
            Console.WriteLine("请输入密码：");
            string password = Console.ReadLine();
            if (Login(name, password, out string result))
            {
                Console.WriteLine("登陆成功!");
            }
            else
            {
                Console.WriteLine(result);
            }
            Console.ReadKey();
        }

        private static bool Login(string name, string password, out string result)
        {
            if (name != "admin")
            {
                result = "用户名错误";
                return false;
            }
            if (password != "888888")
            {
                result = "密码错误";
                return false;
            }
            else
            {
                result = "用户名密码正确";
                return true;
            }
        }

       上面用否定判断，只要三种情况。
       如果用肯定就多了：
           1)name="admin" && password="888888" //完全正确
           2)name="admin" //密码错误
           3)password="888888" //用户名错误
           4)else //两者都错

十三、out与ref的方法重载。

   1、方法重载要要点：
       1）方法名称相同
       2）方法签名不同

       签名指：
       参数类型、个数、(顺序)
       参数的修饰符 (ref、out、 params）
       但不包含方法返回值。


   2、out与ref

       ref与out形成机制类似，都有点引用味道。但out更为特殊点一点，只输出。
       相当于ref是一个成品，out是一个半成品。所以一般不说out是引用参数。

       因此，在重载时，ref与out是不能相见的。
       也即ref与out不能形成重载。

        private static void M1(int n)//1
        {
        }

        private static void M1(string s)//2
        {
        }

        //static void M1(out int n)//3
        //{
        //    n = 0;
        //}
        //static void M1(out string s)//4
        //{
        //    s = "";
        //}
        private static void M1(ref int n)//5
        {
        }

        private static void M1(ref string s)//6
        {
        }

       1)上面1,2,5或1,2,5,6可以形成重载。
       2)上面1,2,3或1,2,3,4可以形成重载。
       3）但是out与ref不能混入相见，即：
           3,4之一或两者，不能与5,6之一或两者，混合不能形成重载，报错。
           比如1,2,3,5错误。报错：不能定义在参数修饰符ref与out上存在区别重载。

           说明：ref与out在重载时，若后面参数一样时，编译器不能区别出ref与out的
               的区别。也即两者函数签名是一样的。所以不能混合在一起。

               除非在后面参数上再变化一下，进行区别，编译器才认出两者重载：

        private static void M1(out string s)//4
        {
            s = "";
        }

        private static void M1(ref string s, int a)//6
        {
        }

       上面两者是可以重载的。
       M1(out string s)与M1(ref string s)是不能重载，但在后面参数多一个，变化
       一下，就可以重载了。


   3、结论：

       重载时，编译器会把out与ref看作同一个辨识符，不会区别。

十四、比较两个对象是否为同一个对象

   1、判断两个对象是否为同一个对象的方法有哪些？

       Equals、==、ReferenceEquals


   2、什么是同一个对象?

       如果两个对象指向堆中同一块内存地址，则这两个对象是同一个对象。

        private static void Main(string[] args)
        {
            Person p1 = new Person();
            p1.Name = "林则徐";

            Person p2 = new Person() { Name = "林则徐" };

            Person p3 = p1;
            
            Console.ReadKey();//a处
        }

        private class Person
        {
            public string Name { get; set; }
        }

       上面p1,p2分别各自在堆中开辟空间创建对象，是不同对象。
       p1与p3指向同一个对象，所以是同一个对象。

       在a处下断点，运行(F5)，中断后，打开即时窗口(菜单中调试->窗口->即时)
       输入&p1，回车，显示p1存储在栈的地址，但没有显示这个栈中地址内容，这个内
           容就应该是堆中对象的地址，可惜vs2022加强了托管，不再显示看不到了。
       同理再输入&p2，回车，&p3回车.
           这样可以看到&p1,&p2,&p3的值，实际上就是它们入栈后的地址，相隔4个字节。

       本想用GetHashCode来验证。但msdn上说：
               对象相同则哈希码一样，但反推不一定。
           也就是说哈希码一样，却不能证明是同一个对象，那你微软创造这个函数做
       毛线？
           网上查了一下，有一个用代码取得对象地址的方法，可以去尝试一下：
           https://www.cnblogs.com/xiaoyaodijun/p/6605070.html


   3、比较两个对象是否为同一个对象?

       1）现象1：

            private static void Main(string[] args)
            {
                Person p1 = new Person();
                p1.Name = "林则徐";

                Person p2 = new Person() { Name = "林则徐" };

                Person p3 = p1;

                Console.WriteLine(object.ReferenceEquals(p1, p2));//false
                Console.WriteLine(object.ReferenceEquals(p1, p3));//true

                Console.WriteLine(p1.Equals(p2));//false
                Console.WriteLine(p1.Equals(p3));//true

                Console.WriteLine(p1 == p2);//false
                Console.WriteLine(p1 == p3);//true
                Console.ReadKey();
            }

            private class Person
            {
                public string Name { get; set; }
            }

           上面对于类来说，比较它们的对象三个方法都得出一致的结果。


       2）现象2：

            private static void Main(string[] args)
            {
                //string s1 = "abc", s2 = "abc";//TTT 同一对象

                string s1 = new string(new char[] { 'a', 'b', 'c' });
                string s2 = new string(new char[] { 'a', 'b', 'c' }); //TTF

                Console.WriteLine(s1 == s2);
                Console.WriteLine(s1.Equals(s2));
                Console.WriteLine(object.ReferenceEquals(s1, s2));

                Console.ReadKey();
            }

           ReferenceEquals()仍能准确判断是否是同一个对象。

           当是字符串时，==与Equals的结果是一致的。
           而ReferenceEquals()在常量确认是；
               在new时则因在不同内存创建，是不同对象。这点与==与Equals结论相反。
               因为此时==与Equal还要比较内容，只要内容一样也认为一样。

           原因：
               打开.Net reflector，搜索string,查看Equals(string)。如图:

               在两对象ReferenceEquals()为真时，返回真。否则继续向下比较（并不
           是直接返false)，在遇到两者的内容一样时，它继续返回真，否则返回假。
               注意里面的代码，说明Equals(string)有两种情况返回真：
               1）确实是两个对象时[相当于ReferenceEquals()];
               2）即使不是是同一对象，只要里面内容一样，也返回真。

               再次查看一下==号操作符重载是怎么比较的：
                   operator ==(string a, string b)
               发现它直接就调用了Equals(string)，也就是说：
               在参数是string时：==与Equals的比较方法是一样的。所以结论一致。

               此时Equals(string)是重载。
               另一个比较Equals(object)则是重写，它的比较方法与Equals(string)
               相同。

                [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail), __DynamicallyInvokable]
                public override bool Equals(object obj)
                {
                    if (this == null)
                    {
                        throw new NullReferenceException();
                    }
                    string strB = obj as string;
                    return ((strB != null) ? (!ReferenceEquals(this, obj) ? ((this.Length == strB.Length) ? EqualsHelper(this, strB) : false) : true) : false);
                }

               Equals(object)来源于object类中的虚方法，在string类中进行了重写


               也就是说,字符串的类中有两个判断方法：
                   1）重载Equals(string)
                   2）重写由object而来的Equals(object)

                   两者与重载的==，它们的比较方法都是一样的，结果也是一样的。
                   因此，这三个方法返回的结果都是真，就有以下两个情况：
                   1）确实是一个对象；
                   2）不是一个对象，但里面的内容一样。


       3）结论：

           比较两个对象推荐使用object.ReferenceEquase(object o1,object o2)。

           不推荐用Equals()与==，因为他们在内容相同时也会认为是同一个对象。


       4）问题：只要不是字符串,其它情况就可以用Equal与==来判断两者是否相等？

           答：不推荐。
               因为Equals或==可以被再次重载或重写，调用者还要花精力考虑它们
               是否被重载或重写。
           而object.ReferenceEquals(o1,o2)是静态方法，不能重写重载，非常保险。

            internal class Program
            {
                private static void Main(string[] args)
                {
                    Person p1 = new Person() { Name = "武则天" };
                    Person p2 = new Person() { Name = "武则天" };

                    Console.WriteLine(p1 == p2);
                    Console.WriteLine(p1.Equals(p2));
                    Console.WriteLine(object.ReferenceEquals(p1, p2));

                    Console.ReadKey();
                }
            }

            internal class Person
            {
                public string Name { get; set; }

                public override bool Equals(object obj)
                {
                    Person p = obj as Person;
                    if (p == null) return false;
                    if (this.Name == p.Name) return true;
                    return object.ReferenceEquals(this, p);
                }
            }

           原本判断不是同一个对象，三个皆为false.
           但Person类中进行了重写Equals，导致结果变量：false,true,fasle


       5）为什么字符串的Equals和别的不一样?

           答: 原本object中的Equals方法是判断对象的地址是否相同。
               但到了string类时，该方法被重写(见2)分析)
           string类中Equals方法还会判断字符串的内容是否相同，相同也为同一对象。