六-继承

一、基类和派生类
仅支持单重继承，主要用于解决代码的重用问题；继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。
当创建一个类时，我们不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类，这个新的类被称为派生类。
C# 继承的特点

• 派生类是对基类的扩展，派生类可以添加新的成员，但不能移除已经继承的成员的定义。
• 继承是可以传递的。如果 C 从 B 中派生，B 又从 A 中派生，那么 C 不仅继承了 B 中声明的成员，同样也继承了 A 中声明的成员。
• 构造函数和析构函数不能被继承，除此之外其他成员能被继承。基类中成员的访问方式只能决定派生类能否访问它们。
• 派生类如果定义了与继承而来的成员同名的新成员，那么就可以覆盖已继承的成员，但这并不是删除了这些成员，只是不能再访问这些成员。
• 类可以定义虚方法、虚属性及虚索引指示器，它的派生类能够重载这些成员，从而使类可以展示出多态性。
• 派生类只能从一个类中继承，可以通过接口来实现多重继承。

二、Object类简介
Object 类是 C# 语言中最原始、最重要的类，是所有类的“祖先”，每个 C# 类都是它的子类，它实现了每个类都必须具有的基本方法。
这里指的“所有类”，即不管是 C# 系统所提供的标准类，还是用户自行編写的类，都是从Object类直接或间接继承而来，它是类层次结构中的顶级类，即 C# 树型类层次结构的“根”。
Object 类中的属性和方法可以被用到任何类。
当編程者定义一个类时没有使用关键字 Extends 指明它的父类，则編译器认为该类从 Object 类继承而来。
在 Object 类中提供了 4 个常用的方法，即 Equals、GetHashCode、GetType 以及 ToString 方法。这 4 个方法也可以被任何类使用或重写

三、Equals [ˈiːkwəlz] 方法
主要用于比较两个对象是否相等，如果相等则返回 True,否则返回 False；主要用于比较两个对象是否相等，如果相等则返回 True,否则返回 False
Equals 方法提供了两个，一个是静态的，一个是非静态的

Equals (object ol, object o2); //静态方法
Equals (object o); //非静态方法

BookUtils stu1 = new BookUtils();
BookUtils stu2 = new BookUtils();
Console.WriteLine("stu1和stu2静态比较结果为{0}",Equals(stu1,stu2));//false
Console.WriteLine("stu1和stu2动态比较结果为{0}",stu1.Equals(stu2));//false

BookUtils stu3 = stu2;
Console.WriteLine("stu3和stu2静态比较结果为{0}", Equals(stu3, stu2));//true
Console.WriteLine("stu3和stu2动态比较结果为{0}", stu3.Equals(stu2));//true

四、GetHashCode 方法
GetHashCode 方法返回当前 System.Object 的哈希代码，每个对象的哈希值都是固定的。该方法不含有任何参数，并且不是静态方法，因此需要使用实例来调用该方法。由于该方法是在 Object 类中定义的，因此任何对象都可以直接调用该方法。

BookUtils stu3 = new BookUtils();
Console.WriteLine(stu3.GetHashCode());

五、GetType方法
GetType 方法用于获取当前实例的类型，返回值为 System.Type 类型；GetType 方法不含任何参数，是非静态方法；使用任何对象都能直接调用该方法。

int typeNum = 10;
string typeStr = "这是一个字符串";

Console.WriteLine(typeNum.GetType());
Console.writeLine(typeStr.GetType());
Console.WriteLine(stu3.GetType());

六、ToString方法
ToString 方法返回一个对象实例的字符串，在默认情况下将返回类类型的限定名；
c#中几乎所有的类型都派生自 Object，所以如果当前类型没有重写 ToString() 方法的情况下，调用 ToString() 方法，默认返回当前类型的名称。任何类都可以重写 ToString 方法，返回自定义的字符串。
对于其他的值类型，则为将值转换为字符串类型的值。

int typeNum = 10;
string typeStr = "这是一个字符串";

Console.WriteLine(typeNum.ToString());  //10
Console.WriteLine(typeStr.ToString()); //这是一个字符串
Console.WriteLine(stu3.ToString());  //ConsoleApp1.BookUtils

七、继承

访问修饰符  class  ClassA:ClassB
{
    //类成员
}

//class Test
class Test
{
    public int num1 { get; set; }
    public int num2 { get; set; }
    public int num3 { get; set; }
    public string str1 { get; set; }
    public string str2 { get; set; }
    public int fuc() {
        return num1 + num2 + num3;
    }
}
class TestEx : Test
{ 

}
//void main
TestEx testEX = new TestEx();
testEX.num1 = 10;
testEX.num2 = 20;
testEX.num3 = 30;
int aNum = testEX.fuc();
Console.WriteLine(aNum);

八、base关键字：调用父类成员方法
在继承的关系中，子类如果需要调用父类中的成员可以借助 base 关键字来完成，具体的用法如下。

base. 父类成员

在程序中会遇到 this 和 base 关键字，this 关键字代表的是当前类的对象，而 base 关键字代表的是父类中的对象。

九、virtual [ˈvɜːtʃuəl] 关键字详解
virtual 是虚拟的含义，默认情况下类中的成员都是非虚拟的，通常将类中的成员定义成虚拟的，表示这些成员将会在继承后重写其中的内容。virtual 关键字能修饰方法、属性、索引器以及事件等，用到父类的成员中。

//修饰属性
public  virtual  数据类型  属性名{get; set; }
//修饰方法
访问修饰符  virtual  返回值类型 方法名
{
    语句块；
}

virtual 关键字不能修饰使用 static 修饰的成员；virtual 关键字既可以添加到访问修饰符的后面，也可以添加到访问修饰符的前面，但实际应用中习惯将该关键字放到访问修饰符的后面。子类继承父类后能重写父类中的成员，重写的关键字是 override。所谓重写是指子类和父类的成员定义一致，仅在子类中增加了 override 关键字修饰成员。

//void main
A a1 = new B();
a1.Print();
A a2 = new C();
a2.Print();
//file class
class A
    {
        public virtual void Print()
        {
            Console.WriteLine("A");
            Console.WriteLine("A++");
        }
    }
class B : A
    {
        public new void Print()
        {
            Console.WriteLine("B");
        }
    }
class C : A
    {
        public override void Print()
        {
            Console.WriteLine("C");
        }
    }

十、abstract [ˈæbstrækt , æbˈstrækt] 声明抽象类或抽象方法
abstract 关键字代表的是抽象的，使用该关键字能修饰类和方法，修饰的方法被称为抽象方法、修饰的类被称为抽象类。
抽象方法定义后面的“;”符号是必须保留的。需要注意的是，抽象方法必须定义在抽象类中。
其中，当 abstract 用于修饰方法时，也可以将 abstract 放到访问修饰符的前面。
抽象方法定义后面的“;”符号是必须保留的。需要注意的是，抽象方法必须定义在抽象类中。

访问修饰符  abstract class  类名
{
    //类成员
    访问修饰符  abstract  方法返回值类型  方法名(参数列表);
}

在抽象类中可以定义抽象方法，也可以定义非抽象方法。
通常抽象类会被其他类继承，并重写其中的抽象方法或者虚方法。
抽象类中不能被实例化，也就是说不能使用 new 抽象类的名称()

//void main
B a1 = new B();
a1.Print();
C a2 = new C();
a2.Print();
//file class
abstract class A
    {
        public string name { get; set; }
        public int age { get; set; }
        public abstract void Print();
    }
class B : A
    {
        public override void Print()
        {
            Console.WriteLine("B");
        }
    }
class C : A
    {
        public override void Print()
        {
            Console.WriteLine("C");
        }
    }

十一、sealed [siːld] 声明密封类或密封方法
使用该关键字能修饰类或者类中的方法，修饰的类被称为密封类、修饰的方法被称为密封方法
但是密封方法必须出现在子类中，并且是子类重写的父类方法，即 sealed 关键字必须与 override 关键字一起使用。
密封类不能被继承，密封方法不能被重写。在实际应用中，在发布的软件产品里有些类或方法不希望再被继承或重写，可以将其定义为密封类或密封方法。

abstract class A
{
    public abstract void Area();
}
class B : A
    {
        public int width { get; set; }
        public int height { get; set; }
        public sealed override void Area()
        {
            Console.WriteLine("矩形的面积是：{0}",width*height);
        }
    }
sealed class C : A
    {
        public int r { get; set; }
        public override void Area()
        {
            Console.WriteLine("圆的面积是：{0}",r*3.14*3.14);
        }
    }
class D : B {
        public override void Area() //无法重写密封的方法
        {
            Console.WriteLine("矩形的面积是：E");
        }
    }
class E : C  //无法继承密封的类
    {
    }

十二、继承关系中构造器的关系

class A
    {
        public  A()
        {
            Console.WriteLine("这是A类,输入的名字叫");
        }
        public  A(string name) {
            Console.WriteLine("这是A类输入的名字叫{0}", name);
        }
    }

class B:A
    {
        public B()
        {
            Console.WriteLine("这是B类,输入的名字叫");
        }
        public B(string name):base(name)
        {
            Console.WriteLine("这是B类,输入的名字叫{0}",name);
        }
    }


B a1 = new B("b");
//控制台显示：
//这是A类输入的名字叫b
//这是B类,输入的名字叫b

在创建子类的实例时，先执行父类 A 中的无参构造器，再执行子类 B 中的无参构造器。
在子类中调用了带参数的构造器，也会先调用其父类中的无参构造器。
如果需要在子类中调用父类的构造器应该怎么办呢？直接在构造器后面使用“:base(参数)”的形式即可。
默认情况下，在子类的构造器中都会自动调用父类的无参构造器，如果需要调用父类中带参数的构造器才使用“:base(参数)”的形式。
在子类的构造器中使用“:base(参数)”的方式即可调用父类带参数的构造器，实际上这也是子类和父类中构造器的一种继承关系表示。

十三、多态
语言中多态称为运行时多态，也就是在程序运行时自动让父类的实例调用子类中重写的 方法，它并不是在程序编译阶段完成的。
使用继承实现多态，实际上是指子类在继承父类后，重写了父类的虚方法或抽象方法。
在创建父类的对象指向每一个子类的时候，根据调用的不同子类中重写的方法产生了不同的执行效果。
总而言之，使用继承实现多态必须满足以下两个条件。

• 子类在继承父类时必须有重写的父类的方法。
• 在调用重写的方法时，必须创建父类的对象指向子类(即子类转换成父类)。 ```csharp abstract class A {

    public int age { get; set; }
    public string name { get; set; }
    public abstract void Print();
  

  }

class B : A { public override void Print() { Console.WriteLine(“{0}的年龄是{1}”,name,age); } } class C : A { public override void Print() { Console.WriteLine(“{0} {1}”, name, age); } }

A b = new B(); b.age = 20; b.name = “张三”; b.Print(); //张三的年龄是20 A c = new C(); c.age = 25; c.name = “李四”; c.Print(); //李四 25 ```