继承的基本机制

代码重用归为两类：继承（is-a），包含/委托（has-a）
继承保护了封装。

is-a

C#要求一个类只能有一个直接基类。
sealed关键字：
如果我们将类标记为sealed，编译器将不会允许我们从这个类型派生。
C#结构总是隐式密封的。
如果对基类的虚函数【vritual/override修饰的】用sealed修饰，则，在此基类的派生类中，此虚函数不可以被override【即不允许派生类定义自己版本的实现】。

只要子类想访问由父类定义的公共或受保护的成员，就可以使用base关键字。

class A
{
    public A(int a)
    {...}
}
class B : A
{
    public B(int a, int b)
        :base(a)
    {}
}

private类型成员，只能在所属类内部实现中使用。
protected类型成员，可以在所属类和其派生类内部实现从使用。
public类型成员，可以在所属类和其派生类内部实现被使用，也可被类或其派生类对象通过点操作符访问。

has-a

包含/委托编程

class BenefitPackage
{
    public double ComputePayDeduction()
    {
        return 125.0;
    }
}

class Employee
{
    protected BenefitPackage empBenefits = new BenefitPackage();
}

如果要公开被包含对象的功能给外部世界，需要委托。
委托就是增加公共成员到包含类，以便使用被包含对象的功能。

嵌套类型：直接在类或结构作用域中定义类型【枚举，类，接口，结构或委托】。
被嵌套类型被认为是嵌套类的成员。可以像操作其它成员【字段，属性，方法，事件等】操作被嵌套类型。

public class OuterClass
{
    public class PublicInnerClass{}
    private class PrivateInnerClass{}
}

class Main
{
    static void Main()
    {
        OuterClass.PublicInnerClass inner = new OuterClass.PublicInnerClass();
    }
}

嵌套类型特征：
类型可用private修饰。
嵌套类型可以访问包含类的所有成员
嵌套类一般用作外部类的辅助设施。

多态

1.
多态为子类提供了一种方式，使其可以定义由基类定义的方法。
vritual用于修饰基类的虚方法
override用于修饰派生类重写的基类的虚方法

class Employee
{
    public virtual void GiveBonus(float amount)
    {
        Pay += amount;
    }
    ...
}

class SalesPerson : Employee
{
    public override void GiveBonus(float amount)// 
    {
        base.GiveBouns(amount);
        ...
    }
}

2.抽象基类
可以用abstract修饰类。不允许创建被abstract修饰类的对象。
抽象基类，可以定义抽象成员。
抽象成员：基类不提供默认实现，必须在派生类中提供实现。

abstract class Shape
{
    public Shape(string name = "NoName")
    {
        PetName = name;
    }

    public string PetName{get; set;};
    public virtual void Draw()
    {
        Console.WriteLine("Inside Shape.Draw()");
    }
}

class Circle : Shape
{
    public Circle(){}
    public Circle(string name)
        : base(name)
    {}
}

class Hexagon : Shape
{
    public Hexagon(){}
    public Hexagon(string name)
        : base(name)
    {}
    public override void Draw()
    {
        Console.WriteLine("Drawing {0} the Hexagon", PetName);
    }
}

只能在抽象基类中定义抽象成员

扫描二维码关注公众号，回复： 2993679 查看本文章

abstract class Shape
{
    public Shape(string name = "NoName")
    {
        PetName = name;
    }

    public string PetName{get; set;};
    // 抽象方法不提供实现
    public abstract void Draw();
}

如果基类中存在抽象方法，派生类要么对基类的抽象方法均进行override来提供具体实现。否则，派生类也将成为抽象类，且派生类需要用abstract修饰。

3.成员遮蔽
如果派生类定义的成员和定义在基类中的成员一致，派生类就遮蔽了父类的版本。

class Circle
{
    public void Draw()
    {}

    public virtual void Draw(int num)
    {...}
}
class ThreeDCircle : Circle
{
    // 在此类内部，此类实例或此类的名字通过点操作符，此类的派生类内部，此类派生类实例或此类派生类的名字通过点操作符 访问Draw时，访问的将是此类的Draw。要访问此类基类的Draw，需要将类型转换为基类再访问。
    // 编译时，会有警告。通过添加new修饰符可消除警告。
    // 对成员字段同样适用。
    public [new] void Draw()
    {
        ...
    }

    public override void Draw(int num)
    {...}
}

class Main
{
    static void Main()
    {
        ThreeDCricle o = new ThreeDCircle();
        // 执行ThreeDCricle::draw
        // 点操作符访问类成员，若成员不是虚成员，依据左边类型静态类型，决定名字查找起始作用域。
        // 若成员是虚成员，依据左边类型动态类型，决定名字查找起始作用域。
        o.draw();
        // 执行ThreeDCricle::draw
        o.draw(10);

        // 执行Circle::draw
        // 因为(Circle)o后，把(Circle)o整体的静态类型变成了Circle。动态类型仍然是ThreeDCricle
        ((Circle)o).Draw();
        // 执行ThreeDCricle::draw
        ((Circle)o).Draw(10);
    }
}

4.基类/派生类的转换规则
如果两个类通过is-a关系关联，在基类引用中保存派生类型总是安全的。
使用C#强制转换操作符进行显式的向下转换。

5.C#的as
强制转换在运行时，如果转换失败，会收到运行时异常。
使用as，就可以通过检查null返回值来检测兼容性
// frank可以转换为Hexagon类型时，返回转换后的Hexagon类型。不能时，返回null
Hexagon hex2 = frank as Hexagon;
if(hex2 == null)
…

6.C#的is
如果类型不兼容，is关键字就返回false，而不是null引用

static void GivePromotion(Employee emp)
{
    if(emp is Manager)
    {
        ((Manager)emp).xxx
    }
}

7.System.Object
查看.NET开源实现的地址：
https://referencesource.microsoft.com/

精通C#学习笔记---继承和多态

继承的基本机制

is-a

has-a

多态

猜你喜欢