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

Posted 誉尚学教育

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了第十一单元 面向对象三:继承与多态相关的知识,希望对你有一定的参考价值。

假设老师类设计如下:

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

注意

  1. C# 中 不支持多继承基类:一个类只能继承一个直接父类。

  2. 继承需要满足什么样的设计规范?

    • 子类们相同特征(共性属性,共性方法)放在父类中定义。

    • 子类独有的的属性和行为应该定义在子类自己里面。

  3. 所有的类都是Object类的子类。

  4. 子类可以继承父类的属性和行为(除静态属性和静态方法外),但是子类不能继承父类的构造器(如果非要继承,需要额外的写代码)。

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. 作业

  1. 定义一个接口或者抽象类 MyMath(计算器类), 声明一个方法 Calculator()

  2. 分别创建五个子类(加、减、乘,除,求余 五个子类),用于实现MyMath 接口

  3. 在Main方法 定义两个变量,并提示从控制台输入运算符(+,-,*,/,%),实现输入不同的运算符调用不能的实现子类。

   

 

二 面向对象三大特性

一 继承与派生

  一、继承定义

  二、继承与抽象的关系

  三、继承与重用性

  四、派生

  五、组合与重用性

  六、接口与归一化设计

  七、抽象类

  八、继承实现的原理

  九、子类中调用父类的方法

二 多态与多态性

  一、多态

  二、多态性

三 封装

  一、封装定义

  二、特性(property)

  三、封装与扩展性

 

一 继承与派生

一、继承定义

什么是继承

继承是一种创建新类的方式,新建的类可以继承一个或多个父类(python支持多继承),父类又可称为基类或超类,新建的类称为派生类或子类。

子类会“”遗传”父类的属性,从而解决代码重用问题(比如练习7中Garen与Riven类有很多冗余的代码)

python中类的继承分为:单继承和多继承

 

 1 class ParentClass1: #定义父类
 2     pass
 3 
 4 class ParentClass2: #定义父类
 5     pass
 6 
 7 class SubClass1(ParentClass1): #单继承,基类是ParentClass1,派生类是SubClass
 8     pass
 9 
10 class SubClass2(ParentClass1,ParentClass2): #python支持多继承,用逗号分隔开多个继承的类
11     pass

查看继承

1 >>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类,__bases__则是查看所有继承的父类
2 (<class __main__.ParentClass1>,)
3 >>> SubClass2.__bases__
4 (<class __main__.ParentClass1>, <class __main__.ParentClass2>)

经典类与新式类

1.只有在python2中才分新式类和经典类,python3中统一都是新式类
2.在python2中,没有显式的继承object类的类,以及该类的子类,都是经典类
3.在python2中,显式地声明继承object的类,以及该类的子类,都是新式类
3.在python3中,无论是否继承object,都默认继承object,即python3中所有类均为新式类
#关于新式类与经典类的区别,我们稍后讨论

提示:如果没有指定基类,python的类会默认继承object类,object是所有python类的基类,它提供了一些常见方法(如__str__)的实现。

1 >>> ParentClass1.__bases__
2 (<class object>,)
3 >>> ParentClass2.__bases__
4 (<class object>,)

 

以上是关于第十一单元 面向对象三:继承与多态的主要内容,如果未能解决你的问题,请参考以下文章

python第三十一天-----类的封装继承,多态.....

第十篇 面向对象的程序设计

二 面向对象三大特性

第十二周周总结 多态

面向对象基础

面向对象三要素:封装,继承,多态