第 24、25 节 类的声明，继承和访问控制

类声明的全貌

在C#与Java里，声明既定义；但是，在C++里面声明和定义是分开的。

最简单的类声明

类成员的访问控制

类的继承

1. 类的继承（基类—派生类，父类—子类）
   继承：子类在完整接收父类的前提下，对父类进行的横向或纵向扩展。
   横向扩展指的是对类成员个数的扩充。
   纵向扩展指的是对类成员版本的更新（对类成员的重写）。
   1）类在功能上的扩展（extend）
   横向扩展：类成员在数量上的扩充；纵向扩展：对某个类成员或某些类成员的版本进行扩充。
   2）只能有一个基类，但可以实现多个基接口（派生自某个基类，实现了某些基接口）
   3）类访问级别对继承的影响
   子类的访问级别不能超过父类的访问级别，可以相同。
   4）sealed 类不能被继承
   若用 sealed关键字来修饰某个类的话，则这个类是封闭的，不能被当做基类来使用。

（1）利用编程证明 Car类 继承 Vehicle类

Type t = typeof(Car);
Type tb = t.BaseType;
Console.WriteLine(tb.FullName);

（2）是一个（is a）的概念

//派生类的实例，从语义上来说，也是基类的实例
//可以用父类的类型变量引用子类的实例
Car car = new Car();
//汽车是交通工具
Console.WriteLine(car is Vehicle);

Vehicle vehicle = new Vehicle();
//交通工具是一个对象
Object o1 = new Vehicle();
//汽车是一个对象
Object o2 = new Car();

2. 成员的继承与访问
   静态类型语言（C++、C#、Java），在继承时只能增加类成员，但是不能被削减。
   动态语言（Python、JavaScript）可以增减类成员。
   1）派生类对继承成员的访问
   2）派生类对基类成员的访问
   3）构造器的不可继承性

举例：
（1）父类的实例构造器是不被继承的

using System;

namespace HelloOOP
{
    class Program
    {
        static void Main(string[] args)
        {
            Car car = new Car("Sunnie");
            Console.WriteLine(car.Owner);
        }
    }

    class Vehicle
    {
        public string Owner { get; set; }
        public Vehicle(string owner)
        {
            this.Owner = owner;
        }
    }

    class Car:Vehicle
    {

        //在基类构造器里面已经把Owner的值设置为owner参数的值了，
        //就不需要在Car构造器里面再设置一遍
        public Car(string owner):base(owner)
        {
            
        }

        public void ShowOwner()
        {
            //this 访问的是子类的对象
            //base 访问的是父类的对象，但是只能向上访问一级
            //此处，this和base指向的都是父类的对象，
            //this.Owner会和base.Owner均可以简化为Owner
            Console.WriteLine(this.Owner);            
            Console.WriteLine(base.Owner);
        }
    }
}

（2）protected 修饰符

using System;

namespace MyLib
{
    public class Vehicle
    {
        //protected修饰的内容可以跨程序集
        //protected internal（或 internal protected）修饰的成员
        //既可以被派生类所访问，又可以被程序集中所有其他的类所访问

        //private修饰的内容只能在类体里面使用
        //在继承类里面不能访问
        //一般实例的私有字段的命名以下划线（_）开头
        protected int _rpm;
        private int _fuel;

        public void Refuel()
        {
            _fuel = 100;
        }

        protected void Burn(int fuel)
        {
            _fuel -= fuel;
        }

        public void Accelerate()
        {
            Burn(1);
            _rpm += 1000;
        }

        //只读属性 Speed
        public int Speed { get { return _rpm / 100; } }
    }

    public class Car : Vehicle
    {
        public void TurboAccelerate()
        {
            Burn(2);
            _rpm += 3000;
        }
    }
}

using System;
using MyLib;

namespace HelloAccess
{
    class Program
    {
        static void Main(string[] args)
        {
            Bus bus = new Bus();
            bus.Refuel();
            bus.SlowAccelerate();
            Console.WriteLine(bus.Speed);
        }
    }

    class Bus : Vehicle
    {
        public void SlowAccelerate()
        {
            Burn(1);
            _rpm += 500;
        }
    }
}

3. 面向对象的实现风格
   1）Class-based（基于类）
   C#，C++，Java
   2）Prototype-based（基于原型）
   JavaScript语言

小技巧：
F12：查看定义
Ctrl + -（减号）：返回到原来的位置