第十一单元面向对象三：继承与多态

假设老师类设计如下：

class 老师类
{
    属性：姓名，性别，生日，工资
    行为：吃饭，跑步，教学
}

学生类设计如下：

class 老师类
{
    属性：姓名，性别，生日，班级
    行为：吃饭，跑步，学习
}

我们秉承着，让最简洁的代码，实现最最强大的功能原则，能否让上述案例中的重复代码进行优化呢？我们能否将学生类与老师类再进行抽象，得到一个人类？这章节学习继承与多态。

1. 继承

继承是面向对象程序设计中最重要的概念之一。继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。

当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类，这个新的类被称为派生类。

继承的思想实现了 属于（IS-A） 关系。例如，哺乳动物 属于（IS-A） 动物，狗 属于（IS-A） 哺乳动物，因此狗 属于（IS-A） 动物。

基类和派生类

一个类可以派生自多个类或接口，这意味着它可以从多个基类或接口继承数据和函数。

C# 中创建派生类的语法如下：

<访问修饰符> class <基类>
{
 ...
}
class <派生类> : <基类>
{
 ...
}

现在我们将上述学生类，老师类案例使用继承，进行代码优化：

// 把公共的属性与方法提取出来，封装成父类
public class Person
{
    public string Name { get; set; }
    public string Sex { get; set; }
    public DateTime Birthday { get; set; }
    
    public void Eat()
    {
        ....
    }
    
    public void Run()
    {
        
    }
}

// 老师类设计如下：
public class Teacher : Person // 继承Person
{
    public int Salary { get; set;}
    
    // 教学方法
    public void Teach()
    {
        ...
    }
}

// 学生类设计如下
public class Student : Person
{
    public string ClassName { get; set; }
    
    // 学习方法
    public void Study()
    {
        ...
    }
}

基类的初始化

派生类继承了基类的成员变量和成员方法。因此父类对象应在子类对象创建之前被创建。您可以在成员初始化列表中进行父类的初始化。

下面的程序演示了这点：

class Rectangle
{
    // 成员变量
    protected double length;
    protected double width;
    public Rectangle(double l, double w)
    {
        length = l;
        width = w;
    }
    public double GetArea()
    {
        return length * width;
    }
    public void Display()
    {
        Console.WriteLine("长度： {0}", length);
        Console.WriteLine("宽度： {0}", width);
        Console.WriteLine("面积： {0}", GetArea());
    }
}//end class Rectangle  
class Tabletop : Rectangle
{
    private double cost;
    public Tabletop(double l, double w) : base(l, w)
    { }
    public double GetCost()
    {
        double cost;
        cost = GetArea() * 70;
        return cost;
    }
    public void Display()
    {
        base.Display();
        Console.WriteLine("成本： {0}", GetCost());
    }
}
class Program
{
    static void Main(string[] args)
    {
        Tabletop t = new Tabletop(4.5, 7.5);
        t.Display();
        Console.ReadLine();
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

长度： 4.5
宽度： 7.5
面积： 33.75
成本： 2362.5

注意

C# 中不支持多继承基类：一个类只能继承一个直接父类。
继承需要满足什么样的设计规范？
- 子类们相同特征（共性属性，共性方法）放在父类中定义。
- 子类独有的的属性和行为应该定义在子类自己里面。
所有的类都是Object类的子类。
子类可以继承父类的属性和行为（除静态属性和静态方法外），但是子类不能继承父类的构造器（如果非要继承，需要额外的写代码）。

2. 方法重写

什么是重写？

“重写”父类方法就是修改它的实现方式或者说在子类中对它进行重新编写。

为什么要重写父类的方法

通常，子类继承父类的方法，在调用对象继承方法的时候，调用和执行的是父类的实现。但是，有时候需要对子类中的继承方法有不同的实现方式。例如，假设动物存在“跑”的方法，从中继承有狗类和马类两个子类，狗与马的奔跑速度或者动作都不太一样。

如何重写

重写父类的方法要用到override关键字(具有override关键字修饰的方法是对父类中同名方法的新实现)
要重写父类的方法，前提是父类中该要被重写的方法必须声明为virtual或者是abstract类型。给父类中要被重写的方法添加virtual关键字表示可以在子类中重写它的实现。(注意：C#中的方法默认并不是virtual类型的因此要添加virtual关键字才能够被重写)
virtual关键字用于将方法定义为支持多态，有virtual关键字修饰的方法称为“虚拟方法”

声明虚方法

[访问修饰符] virtual [返回类型] 方法名（参数列表）

{

	//虚拟方法的实现，该方法可以被子类重写

}

class Employee
{
    public virtual void EmpInfo()
    {
        Console.WriteLine("用virtual关键字修饰的方法是虚拟方法");
    }
}
class DervEmployee : Employee
{
    public override void EmpInfo()
    {
        base.EmpInfo();//base关键字将在下面拓展中提到
        Console.WriteLine("该方法重写base方法");
    }
}
class Program
{
    static void Main(string[] args)
    {
        DervEmployee objDervEmployee = new DervEmployee();
        objDervEmployee.EmpInfo();
        //注意：objDervEmployee派生类的实例是赋给Employee类的objEmployee的引用，
        // 所以objEmployee引用调用EmpInfo()方法时 还是调用DervEmployee类的方法
        Employee objEmployee = objDervEmployee;
        objEmployee.EmpInfo();
    }
}

base关键字用于从子类中访问父类成员。即使父类的方法在子类中重写，仍可以使用base关键字调用。

而且，在创建子类实例时，可以使用base关键字调用父类的构造函数。使用base关键字只能访问父类的构造函数、实例方法或实例属性，而不能访问基类的静态方法。

隐藏父类方法

如果父类与子类具有相同的方法，然后父方法并没有加virtual 关键字修饰。此时，子类需要用 new 关键字进行隐藏父类的方法.

3. 抽象类

使用 abstract 关键字可以创建不完整且必须在派生类中实现的类和 class 成员。

public abstract class A
{
    // Class members here.
}

抽象类不能实例化。抽象类的用途是提供一个可供多个派生类共享的通用基类定义。例如，类库可以定义一个抽象类，将其用作多个类库函数的参数，并要求使用该库的程序员通过创建派生类来提供自己的类实现。

抽象类也可以定义抽象方法。方法是将关键字 abstract 添加到方法的返回类型的前面。例如：

public abstract class A
{
    public abstract void DoWork(int i);
}

抽象方法没有实现，所以方法定义后面是分号，而不是常规的方法块。抽象类的派生类必须实现所有抽象方法。当抽象类从基类继承虚方法时，抽象类可以使用抽象方法重写该虚方法。例如：

public class D
{
    public virtual void DoWork(int i)
    {
        // Original implementation.
    }
}

public abstract class E : D
{
    public abstract override void DoWork(int i);
}

public class F : E
{
    public override void DoWork(int i)
    {
        // New implementation.
    }
}

如果将 virtual 方法声明为 abstract，则该方法对于从抽象类继承的所有类而言仍然是虚方法。继承抽象方法的类无法访问方法的原始实现，因此在上一示例中，类 F 上的 DoWork 无法调用类 D 上的 DoWork。通过这种方式，抽象类可强制派生类向虚拟方法提供新的方法实现。

4. 密封类

使用 sealed 关键字可以防止继承以前标记为 virtual 的类或某些类成员。

public sealed class D
{
    // Class members here.
}

密封类不能用作基类。因此，它也不能是抽象类。密封类禁止派生。由于密封类从不用作基类，所以有些运行时优化可以略微提高密封类成员的调用速度。

在对基类的虚成员进行重写的派生类上，方法、索引器、属性或事件可以将该成员声明为密封成员。在用于以后的派生类时，这将取消成员的虚效果。方法是在类成员声明中将 sealed 关键字置于 sealed 关键字前面。例如：

public class D : C
{
    public sealed override void DoWork() { }
}

5. 接口

接口定义了所有类继承接口时应遵循的语法合同。接口定义了语法合同 "是什么" 部分，派生类定义了语法合同 "怎么做" 部分。

接口定义了属性、方法和事件，这些都是接口的成员。接口只包含了成员的声明（c#8.0以外，接口也可以有默认实现）。成员的定义是派生类的责任。接口提供了派生类应遵循的标准结构。

接口使得实现接口的类或结构在形式上保持一致。

抽象类在某种程度上与接口类似，但是，它们大多只是用在当只有少数方法由基类声明由派生类实现时。

接口本身并不实现任何功能，它只是和声明实现该接口的对象订立一个必须实现哪些行为的契约。

抽象类不能直接实例化，但允许派生出具体的，具有实际功能的类。

高内聚，低耦合：尽量依赖于接口，不依赖于实现，正所谓面向接口编程。说白了，就是为了解耦。

定义接口

接口使用 interface 关键字声明，它与类的声明类似。接口声明默认是 public 的。下面是一个接口声明的实例：

interface IMyInterface
{
    void MethodToImplement();
}

以上代码定义了接口 IMyInterface。通常接口命令以 I 字母开头，这个接口只有一个方MethodToImplement()，没有参数和返回值，当然我们可以按照需求设置参数和返回值。值得注意的是，该方法并没有具体的实现。

实现接口

class InterfaceImplementer : IMyInterface
{
    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }
}

class Program
{
     static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
    }
}

InterfaceImplementer类实现了 IMyInterface 接口，接口的实现与类的继承语法格式类似：

class InterfaceImplementer : IMyInterface

继承接口后，我们需要实现接口的方法 MethodToImplement(), 方法名必须与接口定义的方法名一致。

接口继承

以下实例定义了两个接口 IMyInterface 和 IParentInterface。

如果一个接口继承其他接口，那么实现类或结构就需要实现所有接口的成员。

以下实例IMyInterface 继承了 IParentInterface 接口，因此接口实现类必须实现 MethodToImplement()和 ParentInterfaceMethod()方法：

interface IParentInterface
{
    void ParentInterfaceMethod();
}

interface IMyInterface : IParentInterface
{
    void MethodToImplement();
}

class InterfaceImplementer : IMyInterface
{
    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }

    public void ParentInterfaceMethod()
    {
        Console.WriteLine("ParentInterfaceMethod() called.");
    }
}

class Program
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
        iImp.ParentInterfaceMethod();
    }
}

显式接口实现

如果一个类实现的两个接口包含签名相同的成员，则在该类上实现此成员会导致这两个接口将此成员用作其实现。如下示例中，所有对 Paint 的调用皆调用同一方法。第一个示例定义类型：

public interface IControl
{
    void Paint();
}
public interface ISurface
{
    void Paint();
}
public class SampleClass : IControl, ISurface
{
    // Both ISurface.Paint and IControl.Paint call this method.
    public void Paint()
    {
        Console.WriteLine("Paint method in SampleClass");
    }
}
class Program
{
    static void Main(string[] args)
    {
        SampleClass sample = new SampleClass();
        IControl control = sample;
        ISurface surface = sample;

        // The following lines all call the same method.
        sample.Paint();
        control.Paint();
        surface.Paint();
    }
}

输入结果如下：

Paint method in SampleClass
Paint method in SampleClass
Paint method in SampleClass

但你可能不希望为这两个接口都调用相同的实现。若要调用不同的实现，根据所使用的接口，可以显式实现接口成员。显式接口实现是一个类成员，只通过指定接口进行调用。通过在类成员前面加上接口名称和句点可命名该类成员。例如：

public class SampleClass : IControl, ISurface
{
    void IControl.Paint()
    {
        System.Console.WriteLine("IControl.Paint");
    }
    void ISurface.Paint()
    {
        System.Console.WriteLine("ISurface.Paint");
    }
}

class Program
{
    static void Main(string[] args)
    {
        SampleClass sample = new SampleClass();
        IControl control = sample;
        ISurface surface = sample;

       
        // sample.Paint(); // 此行报错，因为显示接口实现的方法不能直接通过类调用
        control.Paint();
        surface.Paint(); // 显示接口实现，只能通过接口调用方法
    }
}

输入结果：

IControl.Paint
ISurface.Paint

从 C# 8.0 开始，你可以为在接口中声明的成员定义一个实现。如果类从接口继承方法实现，则只能通过接口类型的引用访问该方法。继承的成员不会显示为公共接口的一部分。下面的示例定义接口方法的默认实现：

interface IAnimal
{
    void Roar()
    {
        Console.WriteLine("动物在叫");
    }
}
class Tigger : IAnimal
{
    // 因为Roar()已经有默认实现，则可以不必强制实现，如果实现了，则接口默认实现失效
    //public void Roar()
    //{
    //    Console.WriteLine("老虎在吼");
    //}
}
class Program
{
    static void Main(string[] args)
    {
        IAnimal animal = new Tigger();

        animal.Roar();
    }
}

6. 多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。

多态性可以是静态的或动态的。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的。

在 C# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 Object。

多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

现实中，比如我们按下 F1 键这个动作：

如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；

如果当前在 Word 下弹出的就是 Word 帮助；

在 Windows 下弹出的就是 Windows 帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

静态多态性

在编译时，函数和对象的连接机制被称为早期绑定，也被称为静态绑定。C# 提供了两种技术来实现静态多态性。分别为：

方法重载
运算符重载

运算符重载基本上用不上，本教案中不给予讲解。

方法重载

您可以在同一个范围内对相同的函数名有多个定义。函数的定义必须彼此不同，可以是参数列表中的参数类型不同，也可以是参数个数不同。不能重载只有返回类型不同的函数声明。

下面的实例演示了几个相同的函数 Add()，用于对不同个数参数进行相加处理：

public class MyMath  
{  
    public int Add(int a, int b, int c)  
    {  
        return a + b + c;  
    }  
    public int Add(int a, int b)  
    {  
        return a + b;  
    }  
}  
class Program  
{  
    static void Main(string[] args)  
    {  
        MyMath dataClass = new MyMath();
        int add1 = dataClass.Add(1, 2);  
        int add2 = dataClass.Add(1, 2, 3);

        Console.WriteLine("add1 :" + add1);
        Console.WriteLine("add2 :" + add2);  
    }  
}

下面的实例演示了几个相同的函数 print()，用于打印不同的数据类型：

class Printdata
{
    void print(int i)
    {
        Console.WriteLine("输出整型: {0}", i );
    }

    void print(double f)
    {
        Console.WriteLine("输出浮点型: {0}" , f);
    }

    void print(string s)
    {
        Console.WriteLine("输出字符串: {0}", s);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Printdata p = new Printdata();
        // 调用 print 来打印整数
        p.print(1);
        // 调用 print 来打印浮点数
        p.print(1.23);
        // 调用 print 来打印字符串
        p.print("Hello Runoob");
        Console.ReadKey();
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

输出整型: 1
输出浮点型: 1.23
输出字符串: Hello Runoob

动态多态性

动态多态性是通过 抽象类 / 接口 和 虚方法 实现的。

语法：

父类类型 对象名称 = new 子类构造器;
接口    对象名称 = new 实现类构造器;

多态中成员访问特点

方法调用：编译看左边，运行看右边。
变量调用：编译看左边，运行也看左边。（多态侧重行为多态）

多态的前提

有继承/实现关系；有父类引用指向子类对象；有方法重写。

优势

在多态形式下，右边对象可以实现解耦合，便于扩展和维护。

Animal a = new Dog();
a.run(); // 后续业务行为随对象而变，后续代码无需修改

定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的一切子类对象，体现出多态的扩展性与便利。

多态下会产生的一个问题:

多态下不能使用子类的独有功能

以下实例创建了 Shape 基类，并创建派生类 Circle、 Rectangle、Triangle， Shape 类提供一个名为 Draw 的虚拟方法，在每个派生类中重写该方法以绘制该类的指定形状。

public class Shape
{
    public int X { get; private set; }
    public int Y { get; private set; }
    public int Height { get; set; }
    public int Width { get; set; }
   
    // 虚方法
    public virtual void Draw()
    {
        Console.WriteLine("执行基类的画图任务");
    }
}

class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("画一个圆形");
        base.Draw();
    }
}
class Rectangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("画一个长方形");
        base.Draw();
    }
}
class Triangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("画一个三角形");
        base.Draw();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 创建一个 List<Shape> 对象，并向该对象添加 Circle、Triangle 和 Rectangle
        var shapes = new List<Shape>
        {
            new Rectangle(),
            new Triangle(),
            new Circle()
        };

        // 使用 foreach 循环对该列表的派生类进行循环访问，并对其中的每个 Shape 对象调用 Draw 方法
        foreach (var shape in shapes)
        {
            shape.Draw();
        }

        Console.WriteLine("按下任意键退出。");
        Console.ReadKey();
    }

}

当上面的代码被编译和执行时，它会产生下列结果：

画一个长方形
执行基类的画图任务
画一个三角形
执行基类的画图任务
画一个圆形
执行基类的画图任务
按下任意键退出。

7. 作业

定义一个接口或者抽象类 MyMath（计算器类）, 声明一个方法 Calculator()
分别创建五个子类(加、减、乘，除，求余五个子类)，用于实现MyMath 接口
在Main方法定义两个变量，并提示从控制台输入运算符（+，-，*，/,%），实现输入不同的运算符调用不能的实现子类。

视频教程：

C#入门到精通 - 网易云课堂 (163.com)

posted @ 2023-05-30 13:42 誉尚学教育阅读(168) 评论(0) 编辑收藏举报

刷新页面返回顶部

誉尚学教育

海阔凭鱼跃，天高任我行

第十一单元 面向对象三：继承与多态

1. 继承

基类和派生类

基类的初始化

注意

2. 方法重写

隐藏父类方法

3. 抽象类

4. 密封类

5. 接口

定义接口

实现接口

接口继承

显式接口实现

6. 多态

静态多态性

方法重载

动态多态性

7. 作业

第十一单元面向对象三：继承与多态