C#基础加强1

1.在winForm程序中事件的方法如下：

      private void btnJianDao_Click(object sender, EventArgs e)
        {
            Button button = (Button)sender;//把触发事件的源头转化成Button类
           
        }

在该代码中sender表示是谁触发这个事件，e表示和当前事件触发以后各种相关的数据：比如鼠标的位置等等。

2.属性和索引器

  新建一个类，代码如下：

    class Person
    {
        private string name;
        public string Name
        {
            get;
            set;
        }
        public int Age { get; set; }//没有显示的定义一个字段，但是这个方法里边当进行编译以后，会分配一个字段来存储内容
        public string Email { get; set; }
        public string this[int index]
        {
            set
            {
                switch (index)
                {
                    case 1:
                        this.name = value;
                        break;
                    case 2:
                        this.Age = int.Parse(value);
                        break;
                    case 3:
                        this.Email = value;
                        break;
                }
            }
            get
            {
                string result = "";
                switch (index)
                {
                    case 1:
                        result = this.name;
                        break;
                    case 2:
                        result = this.Age.ToString();
                        break;
                    case 3:
                        result = this.Email;
                        break;
                }
                return result;
            }
            
        }
        public string this[string index]
        {
            set
            {
                switch (index)
                {
                    case "Name":
                        this.name = value;
                        break;
                    case "Age":
                        this.Age = int.Parse(value);
                        break;
                    case "Email":
                        this.Email = value;
                        break;
                }
            }
            get
            {
                string result = "";
                switch (index)
                {
                    case "Name":
                        result = this.name;
                        break;
                    case "Age":
                        result = this.Age.ToString();
                        break;
                    case "Email":
                        result = this.Email;
                        break;
                }
                return result;

            }
        }
    }‘

属性是一个函数成员，它本身没有任何存储。属性就是特殊的方法，里边的set和get实际上是两个方法（用反编译器查看）。

索引和属性一样不用分配内存来存储：属性通常访问单独的数据成员；索引通常访问多个数据成员。索引总是实例成员，因此，索引不能被声明为static，以上代码实现了索引的重载。

3.所有的类都派生自object类。一个类声明的基类规格说明中只能有一个单独的类，称之为类的单根性；虽然类只能直接继承一个基类，但是继承的层次没有限制。也就是说，作为基类的类可以派生自另外一个类，而它又派生自另外一个类，一直下去，直到最终到达object，称之为继承的传递性，但是如果一个类前边有sealed关键字，则该类不能再被继承。继承的优点是为了实现多态。构造函数不能被继承，当new一个子类的对象时，默认情况下先会调用父类的无参构造函数，然后才会调用子类里边自己的构造函数。 解决办法1：在父类中始终拥有一个无参的构造函数；解决办法2：在子类中手动指定调用父类的某个构造函数 通过：base（）在子类中明确指定要调用父类的哪个构造函数。

   class Father
    {
        public Father(string name, int age, string email)
        {
            this.Name = name;
            this.Age = age;
            this.Email = email;

        }
        public string Name { get; set; }
        public int Age { get; set; }
        public string Email { get; set; }
    }
    class Son : Father
    {
        public Son(string name, int age, string email, string leg)
            : base(name, age, email)
        {
            this.Leg = "不知道";
        }
        public string Leg { get; set; }
    }

：this()调用本类中的其他构造函数，这样可以使程序简单，不用每一个字段写构造函数，就像在大街上让别人填信息，有的人可能只填姓名和性别，有的人可能只填身份证号等等，会有好多种组合，在程序中实现的时候就得写好多构造函数来出初始化字段，为了避免此情况发生,则在本类中通过this()来调用本类的其他构造函数代码如下：

 class Chinese
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public string Email { get; set; }
        public Chinese(string name,int age,string email)
        {
            this.Name = name;
            this.Age = age;
            this.Email = email;
        }
        public Chinese(string name):this(name,0,null)
        {

        }
    }

4.实现多态的手段1--虚方法

新建一个类Persons,并且Chinese、American、Japanese继承Persons类，代码如下：

  class Persons
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public string Email { get; set; }
        public virtual void ShowNationality()
        {
            Console.WriteLine("国籍不明");
        }
    }
    class American : Persons
    {
        public override void ShowNationality()
        {
            Console.WriteLine("我是美国人");
        }
    }
    class Japanese : Persons
    {
        public override void ShowNationality()
        {
            Console.WriteLine("我是日本人");
        }
    }
    class Chinese : Persons
    {
        public override void ShowNationality()
        {
            Console.WriteLine("我是中国人");
        }
    }

在Main函数中写如下代码：

 //Persons[] persons = { new Chinese(),new Japanese(),new American()};
            //foreach (Persons person in persons)
            //{
            //    person.ShowNationality();
                
            //}
            Persons person = new Chinese();
            //if (person is Japanese) 
            //{
            //    Japanese j = (Japanese)person;
            //    j.ShowNationality();
            //}
            Chinese c = person as Chinese;
            if (c != null)
            {
                c.ShowNationality();
            }

以上代码中用is和as实现类型的转换，is就是对出于对类型的判断，返回true和false。如果一个对象是某个类型或是其福类型的话就返回为true,否则的话就返回为false，另外is操作符永远都不会抛出异常。但是他的效率比较低，首先CLR对对象类型检查了两次：is操作首先检查person所引用的对象是不是和Chinese类型兼容，如果兼容，那么在if语句内CLR在执行转换时又会检查person是否为一个Chinese引用。而as操作符只进行了一次类型检查，所以提高了性能，如果类型相同就返回一个非空的引用，否则就返回一个空引用。

虚方法子类可以重写也可以不重写，sealed可以不让子类重写此方法。虚方法可以实现方法的重载。子类重写父类的方法时，必须与父类保持一致的方法签名与返回值类型。访问修饰符也得一致。

      public virtual void ShowNationality()
        {
            Console.WriteLine("国籍不明");
        }
        public virtual void ShowNationality(int foodnum)
        {
            Console.WriteLine("你到底吃多少");
        }

4.实现多态的手段2--抽象

抽象类不能被实例化。抽象类中可以有普通成员。

抽象类存在的意义：抽象类不能被实例化，只能被其他类继承；继承抽象类的子类必须把抽象类中的所有抽象成员都重写（s实现）（除非子类也是抽象类）；抽象类就是为了实现多态（代码重用）；抽象类中可以有实例成员也可以由抽象成员。

什么是抽象类（光说不做）：不能被实例化的类

新建一个类Person1，代码如下：

  abstract  class Person1
    {
       public abstract void SayHello();
       public abstract void Stand();
       public virtual void Nihao()
       {
           Console.WriteLine("你好");
       }
    }
   class Teacher : Person1
   {
       public override void SayHello()
       {
           Console.WriteLine("同学们好");
       }
       public override void Stand()
       {
           Console.WriteLine("同学们请坐");
       }
       public override void Nihao()
       {
           Console.WriteLine("我是老师");
       }
   }
   class Student : Person1
   {

       public override void SayHello()
       {
           Console.WriteLine("老师好");
       }

       public override void Stand()
       {
           Console.WriteLine("同学们请起立");
       }
   }

在Mian函数中写如下代码：

            Person1[] persons = { new Teacher(),new Student()};
            foreach (Person1 person in persons)
            {
                person.SayHello();
                person.Stand();
                person.Nihao();
            }

 抽象方法和虚方法的区别：虚方法必须有实现，抽象方法没有实现；抽象方法必须在抽象类中声明，虚方法可以出现在抽象类中；抽象方法必须在子类中重写，虚方法可以被重写。

什么时候用虚方法？

（1）父类本身需要被实例化（2）这个方法在父类中有实现的意义

什么时候用抽象方法？

（1）在当前系统中，父类绝对不会被实例化（2）在父类中不知道如何去实现这个方法（没有默认的实现）

虚方法：

（1）父类中必须有实现（2）子类中可以不重写（3）虚方法可以再普通类中

抽象方法：

（1）父类中不能有任何实现（2）子类中必须重写（除非：子类也是一个抽象类）（3）抽象方法 必须在抽象类中。

5.多态：为了程序的可扩展性。开放封闭原则（对修改封闭，对扩展开放）。多态就是指不同对象收到相同消息是，会产生不同的行为，同一个类在不同的场合下表现出不同的行为特征。

多态的作用：把不同的子类对象都当做父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

 6.静态类的本质是abstract+sealed