Unity学习之C#基础21——继承、as用法、static静态

1.继承

子类可以使用父类的成员，父类不可以使用子类成员，只能使用自己的成员。

父类型的引用指向子类的对象，只能使用父类成员。如果需要访问子类成员需要强制转换。

  定义：
    class Gun
    {
        public string GunName { get; set; }
        public string GunAmmoType { get; set; }
        public int GunAmmoNum { get; set; }
        public decimal GunShotRange { get; set; }
        

    }

    class Rifle : Gun
    {
        private bool useGunstock;
        protected bool UseAccessories { get; set; }
        public bool UseGunstock
        {
            set { useGunstock = value; }
            get { return useGunstock; }
        }

        
    }
    [Flags]
    enum GunUse
    {
        FarMoreShot=0,
        AntiTank=2,
        AntiAir=4
    }
    class SniperGun : Rifle
    {
        public GunUse GunUseType { get; set; }

    }
调用：
            Gun M4A1 = new Gun();
            M4A1.GunName = "M4A1";
            Rifle M14 = new Rifle();
            M14.GunName = "M14";
            M14.UseGunstock = true;
            SniperGun AWP = new SniperGun();
            AWP.GunName = "AWP";
            AWP.GunUseType = GunUse.FarMoreShot;

2.as的用法：

当我们有两个不同的子类时，使用强制转换从一个子类变成另一个子类时，不会报错，但是运行时会抛出异常。

但是使用as可以避免异常，但是不会转换成功，下面看一个实例：

定义：

    class Rifle : Gun
    {
        private bool useGunstock;
        protected bool UseAccessories { get; set; }
        public bool UseGunstock
        {
            set { useGunstock = value; }
            get { return useGunstock; }
        }

        
    }
    class MachineGun : Gun
    {
        public GunUse GunUseType { get; set; }
    }

调用：

            Gun gun3 = new MachineGun();
            MachineGun gun4 = (MachineGun)gun3;
            Rifle gun5 = gun3 as Rifle;

3.static静态

static可以用于在不同实例对象中需要同时调用的值，具体含义我们看一个例子：

假设我们想要查看一个类我们实例化了几个实例对象，怎么做？看看下面的两个办法的区别：

类：
class Gun
    {
        public string GunName { get; set; }
        public string GunAmmoType { get; set; }
        public int GunAmmoNum { get; set; }
        public decimal GunShotRange { get; set; }

        public int dynamicNum;
        public static int staticNum;
        public Gun()
        {
            dynamicNum++;//这里我们增加动态计数
            staticNum++;//这里我们增加静态计数
        }
    }
调用：
static void Main()
        {
            Gun gun1 = new Gun();
            Gun gun2 = new Gun();
            Gun gun3 = new Gun();
            Gun gun4 = new Gun();
            Console.WriteLine(gun4.dynamicNum);//输出动态计数由0->1
            Console.WriteLine(Gun.staticNum);//使用类名调用静态变量由0->4

        }

当我们声明了一个静态的变量时，我们需要使用类型名来调用，而不是实例名。

当然静态的东西很多，具体如下：

静态成员变量：

• 这里就是为什么，我们实例的时候用实例来引用，而静态的时候，使用类来调用。
• 当我们类在声明而没有new的时候，就已经加载了静态的成员变量。

 静态构造函数：

• 不可以使用public、protected、private等来修饰静态构造函数。
• 静态构造函数，一般用于初始化类的静态数据成员。而我们之前讲的构造函数一般用于对实例对象的数据成员进行初始化。

 静态方法：

• 静态方法或者说静态代码块中我们只能访问静态成员。
• this的用法的含义也就是this这个实例对象中的某个成员变量，所以我们才会使用this。
• 为什么普通的方法就可以调用静态成员变量呢？因为，有了实例对象，该类必定被引用了。

 静态类：

 讲完上面所有的静态类型，我们来看看其适用性：