标签：Animal 面向对象编程 C# 子类 class 继承 Learning 基类 public

目前除C#外流行的面向对象编程的几个语言分别是:Java, C++等;

面向对象的语言都具有以下特征:

封装 - 将客观事物封装成类, 并将类内部的实现隐藏,以保证数据的完整性;
继承 - 子类通过继承可以复用父类的代码;
多态 - 允许将子对象赋值给父对象的一种能力.

5.1 封装

封装指的是把类内部的数据隐藏起来，不让对象实例直接对其操作。C#中提供了属性机制来对类内部的状态进行操作。在C#中，封装可以通过public 、private 、protected 和internal 等关键字来体现。

为什么要将类内部的数据封装起来呢？下面通过一个例子来解释其必要性，具体的代码如下。

// 不使用封装特性来定义一个Person类
public class Person
{
    public string _name;
    public int _age;
}

当把字段定义为公共类型时，外部对象可以对类内部的数据进行任意的操作，很可能导致当前值不符合系统的业务逻辑。下面的代码演示了公共数据存在的问题。

class Program
{
    static void Main(string[] args)
    {
        Person p = new Person();
        p._name = "Learning Hard";

        // -5赋给age字段显然是不符合业务逻辑的，因为人的年龄不可能为负数
        p._age = -5;
    }
}

在以上代码中，尽管把-5 赋给Person 的_age 属性没有引起编译错误，但这并不符合业务逻辑，因为在现实生活中，人的年龄不可能为负值。当我们把类的字段定义为公共类型时，外部对象可以直接对类内部的数据进行操作，此时无法对这些操作进行一些逻辑判断，这就是公共数据的问题所在。

面向对象编程中的封装特性，是一种保护状态数据完整性的方法，在面向对象编程中，应更多地定义私有数据字段。C#提供属性机制来对这种私有字段数据进行间接的操作，并且可以在属性的定义中加入更多的逻辑判断。利用封装技术，我们可以有效地对外部隐藏类内部的数据，从而避免数据损坏。

下面的代码演示了在C#中，使用封装技术后类的定义过程。

public class Person
{
    private string _name;
    private int _age;

    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }

    public int Age
    {
        get { return _age; }
        set
        {
            // 在属性定义中，可以根据系统的业务逻辑添加逻辑代码
            if (value < 0 || value > 120)
            {
                throw (new ArgumentOutOfRangeException("AgeIntPropery", value, "年龄必须在0-120之间"));
            }
        _age=valuel;
        }
    }
}

使用了封装技术之后，外部数据只能对属性进行操作。如果把不符合逻辑的值赋给属性Age ，就会在运行时抛出异常，客户端调用可以通过捕获该异常，进行相关的错误处理操作。

简而言之, 封装是为了更好地将代码与现实业务结合.

5.2 继承

在C#中，一个类可以继承另外一个已有的类（密封类除外），被继承的类称为基类（或父类），继承的类称为派生类（或子类），子类将获得基类除构造函数和析构函数以外的所有成员。此外，静态类是密封的，也不能被继承。

例如，牛、羊、马等都是动物，但它们是不同种类的动物，除了具有动物的共性外，它们还具有各自的特点，如不同的用途、不同的发声方式等。我们可以把动物定义为牛、羊、马的父类，这样子类不但继承了基类除构造函数和析构函数以外的所有成员，还可以添加自己特有的成员。

通过继承，程序可实现对父类代码的复用。因为子类可继承父类的所有成员，父类中定义的代码便不需要在子类中进行重复定义了。

5.2.1 CSharp中的继承

C#与C++不同，C#仅支持派生于一个基类，而C++则支持多重继承。但C#可以继承多个接口，接口的内容会在第6章中介绍。

下面的代码演示了C#中继承的使用方法。

class Program
{
    static void Main(string[] args)
    {
        Horse horse = new Horse();
        horse.Age = 2;
        Console.WriteLine("马的年龄为：{0}", horse.Age);

        Sheep sheep = new Sheep();
        sheep.Age = 1;
        Console.WriteLine("羊的年龄为：{0}", sheep.Age);
        Console.Read();
    }
}

// 基类
public class Animal
{
    private int _age;
    public int Age
    {
        get { return _age; }
        set
        {
            // 这里假设牛的寿命为10年
            if (value < 0 || value > 10)
            {
                throw (new ArgumentOutOfRangeException("AgeIntPropery", value, "年龄必须在0-10之间"));
            }

            _age = value;
        }
    }
}

// 马 (子类)
public class Horse:Animal
{
}

// 羊 (子类)
public class Sheep:Animal
{
}

在以上代码中，虽然各个子类并没有定义Age 属性，但由于它们都继承自基类Animal ，基类中又定义了Age 属性，所以子类也就继承了父类中的Age 。通过继承，避免了在子类中重复定义Age ，从而达到代码复用的目的。

需要注意的是，子类并不能对父类的私有成员进行直接访问，它只可对保护成员和公有成员进行访问。如果把上面代码中的Age 属性定义为私有属性，Main 函数就不能对该属性进行赋值操作了。私有成员也会被子类继承，但子类不能直接访问私有成员，子类可以通过调用公有或保护方法来间接地对私有成员进行访问。

5.2.2 密封类

密封类不可以被另一个类继承, 强行继承编译会产生错误.

作用:

防止继承：密封类不能被其他类继承，这样可以防止其他类对该类进行修改或继承并重写其方法，确保类的完整性和稳定性。
提高性能：由于密封类不能被继承，编译器可以对其进行一些优化，提高代码的执行效率。
安全性：密封类可以防止其他类通过继承和重写方法来篡改其内部逻辑，增强了代码的安全性。

应用场景:

工具类：一些工具类不需要被继承或修改，可以将其定义为密封类，以确保其功能的完整性和稳定性。
不可变类：一些不可变类，如字符串类，不希望被继承或修改，可以将其定义为密封类，以确保其不被修改。
性能敏感类：对于一些性能关键的类，如数学计算类，为了提高性能，可以将其定义为密封类，以允许编译器进行优化。

5.2.3 子类的初始化顺序

子类继承父类之后, 当我们初始化子类时, 除了会调用子类的构造函数外，同时也会调用基类的构造函数。

子类的初始化顺序如下:

初始化类的实例字段；
调用基类的构造函数，如果没有指明基类，则调用System.Object 的构造函数；
调用子类的构造函数。

下面例子演示了子类的初始化顺序.

class Program
{
    static void Main(string[] args)
    {
        // 初始化子类实例
        ChildA child = new ChildA();
        child.Print();
        Console.Read();
    }
}

public class Parent
{
    // ②调用基类构造函数
    public Parent()
    {
        Console.WriteLine("基类构造函数被调用");
    }
}

public class ChildA : Parent
{
    // 创建一个ChildA对象时，
    // ①初始化它的实例字段
    private int FieldA = 3;

    // ③调用子类构造函数
    public ChildA()
    {
        Console.WriteLine("子类构造函数被调用");
    }

    public void Print()
    {
        Console.WriteLine(FieldA);
    }
}

输出结果如下:

基类构造函数被调用
子类构造函数被调用
3

5.3 多态

由于可以继承基类的所有成员，子类就都有了相同的行为，但是有时子类的某些行为需要相互区别，子类需要覆写父类中的方法来实现子类特有的行为，这样的技术在面向对象的编程中就是多态。多态即相同类型的对象调用相同的方法却表现出不同行为的现象。

5.3.1 使用virtual 和override 关键字实现方法重写

只有基类成员声明为virtual 或abstract 时，才能被派生类重写；而如果子类想改变虚方法的实现行为，则必须使用override 关键字。下面的代码演示了C#对多态的支持：

class Program
{
    static void Main(string[] args)
    {
        Animal horse = new Horse();
        horse.Voice();

        Animal sheep = new Sheep();
        // 相同类型的对象调用相同的方法表现出不同的行为
        sheep.Voice();
        Console.Read();
    }
}
// 动物基类
public class Animal
{
    private int _age;
    public int Age
    {
        get { return _age; }
        set
        {
            // 这里假设牛的寿命为10年
            if (value < 0 || value > 10)
            {
                throw (new ArgumentOutOfRangeException("AgeIntPropery", value, "年龄必须在0-10之间"));
            }

            _age = value;
        }
    }

    // 几乎所有动物都具有发出声音的能力
    // 但是对于动物的子类来说，每个子类发出的声音都是不一样的
    public virtual void Voice()
    {
        Console.WriteLine("动物开始发出声音");
    }
}

// 马 (子类)，子类应重写基类的方法，以实现自己特有的行为
public class Horse : Animal
{
    // 通过override关键字来重写父类方法
    public override void Voice()
    {
        // 调用基类的方法
        base.Voice();
        Console.WriteLine("马发出嘶……嘶……嘶……的声音");
    }
}

// 羊 (子类)
public class Sheep : Animal
{
    // 重写父类方法
    public override void Voice()
    {
        // 通过base语句来调用父类的方法
        base.Voice();
        Console.WriteLine("羊发出咩……咩……咩……的声音");
    }
}

上面的代码通过使用virtual 关键字，把基类中需要在子类中表现为不同行为的方法定义为虚方法，然后在子类中使用override 关键字对基类方法进行重写。这样，每个基类在调用相同的方法时将表现出不同的行为，这段代码正是C#中多态的实现。

如果子类还想继续访问基类定义的方法，则可使用base 关键字来完成调用。

代码运行结果如下:

动物开始发出声音
马发出嘶...嘶..嘶...的声音
动物开始发出声音
羊发出咩...咩...咩...的声音

从上面的运行结果可以看出，相同类型的对象调用相同的方法确实表现了不同的行为，这就是多态的精髓所在。

但是，上面的代码还存在一个问题：我们可以通过new 操作符创建Animal 基类的实例，可Animal 基类的作用是为所有子类提供公共成员，它是一个抽象的概念，在实际的系统中我们希望能避免创建该类的实例。该怎么办呢？

对于C#，可以使用abstract 关键字来防止在代码中直接创建这样类的实例，正如下面的代码所示：

public abstract class Animal
{
    …
}

如果尝试创建Animal 实例, 则会报错:无法创建抽象类或接☐"_4_6.Animal"的实例

5.3.2 阻止派生类重写虚成员

前面曾介绍到，用sealed 关键字可以防止一个类被其他类继承。同样，也可以使用sealed 关键字来阻止派生类重写虚成员。例如，我们希望Horse 的继承类不再具有扩展Voice 方法的行为，则可以使用sealed 关键字来停止虚拟继承，如以下代码所示：

public class Horse : Animal
{
    // 通过override关键字来重写父类方法
    public sealed override void Voice()
    {
        // 调用基类的方法
        base.Voice();
        Console.WriteLine("马发出嘶……嘶……嘶……的声音");
    }
}

尝试在Horse 的派生类中重写Voice 方法，则会收到“无法对密封成员进行复写”的错误信息。

5.3.3 使用新成员隐藏基类成员

如果想在派生类中定义与基类成员同名的成员，则可以使用new 关键字把基类成员隐藏起来。

public class Animal
{
    public void Eat()
    {
        Console.WriteLine("动物吃方法");
    }
}

public class Horse : Animal
{
    // 想在派生类中也定义一个Eat方法，则会收到一个警告信息
    public void Eat()
    {
        Console.WriteLine("马吃的方法");
    }
}

如果不使用new 关键字，在派生类中定义一个与基类成员同名的成员，编译器将产生警告信息。

Horse.Eat0将隐藏继承的成员”Animal.Eat()",若要使当前成员重写该实现，请添动加关键字override,否则,添加关键字new.

在实际的软件系统中，若确实需要添加某个方法，但是该方法又与基类的方法同名，那么可以使用new 关键字把基类成员隐藏。下面的代码演示了使用new 关键字来隐藏基类成员的方法：

public class Horse : Animal
{
    // 使用new关键字进行修饰，从而隐藏了基类中同名成员
    public new void Eat()
    {
        Console.WriteLine("马吃的方法");
    }
}

如果此时仍然想访问基类的成员，则可使用强制类型转换，把子类强制转换成基类类型，从而访问隐藏的基类成员（类型转换的内容将在第10章中介绍）。具体的实现代码如下：

class Program
{
    static void Main(string[] args)
    {
        // 调用Horse中Eat方法
        Horse horse = new Horse();
        horse.Eat();

        // 调用基类的Eat方法
        ((Animal)horse).Eat();
        Console.Read();
    }
}

5.4 所有类的父类:System.Object

在C#中，所有的类都派生自System.Object 类。如果定义的类没有指定任何基类，编译器就会自动把Object 类当作它的基类。和其他类一样，System.Object 类也定义了一组共有的成员，其定义如下：

public class Object
{
    // 方法
    // 构造函数
    public Object();

    // 虚成员，子类可以重写这些方法
    public virtual bool Equals(object obj);
    protected virtual void Finalize();
    public virtual int GetHashCode();
    public virtual string ToString();

    // 实例成员
    public Type GetType();
    protected object MemberwiseClone();

    // 静态成员
    public static bool Equals(object objA, object objB);
    public static bool ReferenceEquals(object objA, object objB);
}

本章详细介绍了C#中面向对象的3个特性——封装、继承和多态。通过这些内容，我们了解了将字段定义为私有的原因，学习了如何去继承一个类，以及如何去覆写和隐藏基类成员。最后，本章还简单地介绍了.NET中所有类的父类——System.Object 。

标签：Animal,面向对象编程,C#,子类,class,继承,Learning,基类,public
From： https://www.cnblogs.com/cogito/p/LearningHardCSharpStudyNote_5.html

Learning Hard C# 学习笔记: 5.C#中的面向对象编程