类,继承

类主要成员

字段、属性、索引器、方法、构造函数、析构函数

字段：用来存储数据

属性：封装字段，控制字段读写属性

索引器：也叫有参属性，其参数是数组或者集合的下标，每个类中只能有一个索引器

方法：实现某种功能的代码段

构造函数：在类实例化时调用，构造函数可以重载（方法参数的类型和个数不同）

析构函数：只能有一个，在对象释放时调用

 

class MyClass { //构造函数，与类名相同,无返回值 public MyClass() { } //构造函数重载，接收一个int类型的参数 public MyClass(int a) { } //构造函数重载，接收一个string类型的参数 public MyClass(string a) { } //字段 int i=5; string name; //属性，用来封装字段name,并且设置nane的读写属性 public string Name { get { return name; } //读 set { name = value; } //写 } int[] myInt = new int[] { 2, 4, 5, 6 }; //索引器（或叫有参属性），参数为数组或集合的下标。一个类中只能有一个索引器 public int this[int i] { get { return myInt[i]; } set { myInt[i] = value; } } //析构函数 ~MyClass() { } static void Main(string[] args) { MyClass MyClassA = new MyClass(); Console.WriteLine(MyClassA.name); //直接用对象名调用索引器，MyClassA[3]，就是调用第4个数值 int a = MyClassA[3]; Console.WriteLine(a); Console.ReadLine();

 

 

 

类的访问修饰符

new  public  protected   internal  private  abstract（抽象） sealsd（密封） static(静态)

 

类定义中可以使用的访问修饰符和修饰符组合
none or internal
类只能在当前工程中访问

public
类可以在任何地方访问

abstract or internal abstract
类只能在当前工程中访问，不能实例化，只能继承

public abstract
类可以在任何地方访问，不能实例化，只能继承

sealed or internal sealed
类只能在当前工程中访问，不能派生，只能实例化

public sealed
类可以在任何地方访问，不能派生，只能实例化

 

static or internal static

类可以在当前工程访问，不能派生，不能实例化，访问其内部成员时用类名加点

 

静态类

不能继承，不能实例化

//静态类，其成员都应该是静态的，静态类不能被实例化，也不能被继承 internal static class StClass { //静态字段 public static string s="aaa"; //静态方法 public static void printStr() { Console.WriteLine(s); } } class MyClass { static void Main(string[] args) { //用类名加点访问静态类中的字段 Console.WriteLine(StClass.s); //类名加点访问静态类中的方法 StClass.printStr(); Console.ReadLine(); }  

 

抽象类

不能实例化，其成员可以是抽象的，也可以不是。抽象类主要用于被继承，让子类实现其含有的抽象方法。

abstract class AbClass { //抽象的成员要求不能有实现 abstract string name; //这是错误的，没有抽象字段，因为字段是默认为被实现的 string passWord;//这是可以的 //抽象方法不能有实现，下面是错误的写法 abstract public void print() { } //抽象方法正确的写法 abstract public void print(); //抽象属性 abstract public string Str { get; set; } }

 

密封类

不能被继承，可以实例化

 

 

继承

隐藏同名方法：

当子类中的方法和父类中的方法命名相同时候，实例化子类后，子类方法会将继承自父类的同名方法（隐式）隐藏，调用该方法时，始终是执行子类中的方法。这种情况下，在子类中定义与父类同名方法时，应该使用new关键字，显式隐藏继承自父类的同名方法。

class Father { public void F1() { Console.WriteLine("father F1"); } } class Child : Father { public void C1() { Console.WriteLine("child C1"); } //与父类方法同名 public new void F1()//使用new关键字，显式隐藏父类F1方法 { Console.WriteLine("child F1"); } } class MyClass { static void Main(string[] args) { Father F = new Father(); F.F1(); Child C = new Child(); C.F1();//将继承自父类的F1方法隐藏，执行子类的F1方法 C.C1(); //定义名为Cf的父类，用子类实例化父类Cf Father Cf = new Child(); Cf.F1();//执行父类中F1的方法，因为定义的为父类，且继承自父类的同名方法存在，只是被隐藏。 Console.ReadLine(); } }

 

覆盖同名方法：

父类方法必须为虚方法，使用关键字virtual，子类要覆盖继承自父类中同名的方法，则要使用override关键字。

桂素伟老师形象的把这两个关键字比喻为 呼叫（virtual） 和 应答(override)，有呼叫有应答正常，有呼叫没有应答正常，没呼叫有应答不正常。

 class Father { public virtual void F1()//定义的虚方法 { Console.WriteLine("father F1"); } } class Child : Father { public void C1() { Console.WriteLine("child C1"); } //与父类方法同名 public override void F1()//使用override关键字，覆盖继承自父类的F1方法 { Console.WriteLine("child F1"); } } class MyClass { static void Main(string[] args) { Father F = new Father(); F.F1(); Child C = new Child(); C.F1();//将继承自父类的F1方法覆盖，执行子类的F1方法 C.C1(); //定义名为Cf的父类，用子类实例化父类Cf Father Cf = new Child(); Cf.F1();//执行子类中F1的方法，因为虽然定义的是父类，但是继承自父类的同名方法被覆盖，不存在F1的方法 Console.ReadLine(); } }

 

抽象类的继承

abstract class Father { public virtual void F1() { Console.WriteLine("father F1"); } abstract public void F2(); abstract protected void F3();//正确，可以在子类中被访问，被实现 //abstract private void F4();//不正确，抽象成员不能私有 } class Child : Father { public void C1() { Console.WriteLine("child C1"); } //与父类方法同名 public override void F2()//使用override关键字，覆盖实现父类中的抽象方法F2 { Console.WriteLine("F2"); } //F3受保护，覆盖时，使用protected修饰符 protected override void F3() { Console.WriteLine("F3"); } }

 

继承过程中，构造函数问题

子类继承父类，实例化子类时候，就先实例化父类，如果父类构造函数中含有参数，而子类中构造函数没有参数，就会出现错误。

class Father { //父类构造函数需要参数 public Father(int i) { Console.WriteLine("father"+i); } } class Child : Father { //base是调用父类构造函数，满足其参数要求 public Child():base(2) { Console.WriteLine("Child"); } } class MyClass { static void Main(string[] args) { //实例化子类时候，现实执行父类的构造函数，然后执行子类的构造函数 Child C = new Child(); } }