C#基础加强1

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

1       private void btnJianDao_Click(object sender, EventArgs e)

2         {

3             Button button = (Button)sender;//把触发事件的源头转化成Button类

4            

5         }

在该代码中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（）在子类中明确指定要调用父类的哪个构造函数。

 1    class Father

 2     {

 3         public Father(string name, int age, string email)

 4         {

 5             this.Name = name;

 6             this.Age = age;

 7             this.Email = email;

 8 

 9         }

10         public string Name { get; set; }

11         public int Age { get; set; }

12         public string Email { get; set; }

13     }

14     class Son : Father

15     {

16         public Son(string name, int age, string email, string leg)

17             : base(name, age, email)

18         {

19             this.Leg = "不知道";

20         }

21         public string Leg { get; set; }

22     }

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

 1  class Chinese

 2     {

 3         public string Name { get; set; }

 4         public int Age { get; set; }

 5         public string Email { get; set; }

 6         public Chinese(string name,int age,string email)

 7         {

 8             this.Name = name;

 9             this.Age = age;

10             this.Email = email;

11         }

12         public Chinese(string name):this(name,0,null)

13         {

14 

15         }

16     }

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

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

 1   class Persons

 2     {

 3         public string Name { get; set; }

 4         public int Age { get; set; }

 5         public string Email { get; set; }

 6         public virtual void ShowNationality()

 7         {

 8             Console.WriteLine("国籍不明");

 9         }

10     }

11     class American : Persons

12     {

13         public override void ShowNationality()

14         {

15             Console.WriteLine("我是美国人");

16         }

17     }

18     class Japanese : Persons

19     {

20         public override void ShowNationality()

21         {

22             Console.WriteLine("我是日本人");

23         }

24     }

25     class Chinese : Persons

26     {

27         public override void ShowNationality()

28         {

29             Console.WriteLine("我是中国人");

30         }

31     }

在Main函数中写如下代码：

 1  //Persons[] persons = { new Chinese(),new Japanese(),new American()};

 2             //foreach (Persons person in persons)

 3             //{

 4             //    person.ShowNationality();

 5                 

 6             //}

 7             Persons person = new Chinese();

 8             //if (person is Japanese) 

 9             //{

10             //    Japanese j = (Japanese)person;

11             //    j.ShowNationality();

12             //}

13             Chinese c = person as Chinese;

14             if (c != null)

15             {

16                 c.ShowNationality();

17             }

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

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

1       public virtual void ShowNationality()

2         {

3             Console.WriteLine("国籍不明");

4         }

5         public virtual void ShowNationality(int foodnum)

6         {

7             Console.WriteLine("你到底吃多少");

8         }

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

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

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

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

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

 1   abstract  class Person1

 2     {

 3        public abstract void SayHello();

 4        public abstract void Stand();

 5        public virtual void Nihao()

 6        {

 7            Console.WriteLine("你好");

 8        }

 9     }

10    class Teacher : Person1

11    {

12        public override void SayHello()

13        {

14            Console.WriteLine("同学们好");

15        }

16        public override void Stand()

17        {

18            Console.WriteLine("同学们请坐");

19        }

20        public override void Nihao()

21        {

22            Console.WriteLine("我是老师");

23        }

24    }

25    class Student : Person1

26    {

27 

28        public override void SayHello()

29        {

30            Console.WriteLine("老师好");

31        }

32 

33        public override void Stand()

34        {

35            Console.WriteLine("同学们请起立");

36        }

37    }

在Mian函数中写如下代码：

1             Person1[] persons = { new Teacher(),new Student()};

2             foreach (Person1 person in persons)

3             {

4                 person.SayHello();

5                 person.Stand();

6                 person.Nihao();

7             }

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

什么时候用虚方法？

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

什么时候用抽象方法？

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

虚方法：

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

抽象方法：

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

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

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

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