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

你可能感兴趣的:(C#)