C#核心7——继承

1.继承中的构造函数

1.基本概念

特点

当申明一个子类对象时

先执行父类的构造函数

再执行子类的构造函数

注意：

1. 父类的无参构造 很重要
2. 子类可以通过base关键字 代表父类 调用父类构造

2.继承中构造函数的执行顺序

父类的父类的构造——>。。。父类构造——>。。。——>子类构造

    class GameObject
    {
        public GameObject()
        {
            Console.WriteLine("GameObject的构造函数");
        }
    }
    class Player : GameObject
    {
        public Player()
        {
            Console.WriteLine("Player的构造函数");
        }
    }
    class MainPlayer : Player
    {
        public MainPlayer()
        {
            Console.WriteLine("MainPlayer的构造函数");
        }
    }

3.父类的无参构造很重要

子类实例化时，默认自动调用的 是父类的无参构造 所以如果父类无参构造被顶掉 会报错

    class Father
    {
        public Father()
        {
            
        }
        public Father(int i)
        {
            Console.WriteLine("Father构造");
        }
    }
    class Son : Father
    {
    }

4.通过base调用指定父类构造 

    class Son : Father
    {
        public Son(int i):base(i)
        {
            Console.WriteLine("Son的一个参数的构造");
        }
 
        public Son(int i, string str) : this(i)
        {
            Console.WriteLine("Son的两个参数的构造");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MainPlayer mp = new MainPlayer();
 
            Son s = new Son(1,"123");
        }
    }

5.总结

继承中的构造函数

特点

执行顺序 是先执行父类的构造函数 再执行子类的

父类中的无参构造函数 很重要

如果被顶掉 子类中就无法默认调用无参构造了

解决方法：

1. 始终保持申明一个无参构造
2. 通过base关键字 调用指定父类的构造

注意：区分this和base的区别

this是代表自己的另一个构造函数

base是代表父类的另一个构造函数

2.万物之父和装箱拆箱

1.万物之父

关键字：object

概念：object是所有类型的基类，它是一个类（引用类型）

作用：

1. 可以利用里氏替换原则，用object容器装所有对象
2. 可以用来表示不确定类型，作为函数参数类型

2.万物之父的使用

    class Program
    {
        static void Main(string[] args)
        {
            Father f = new Son();
            if (f is Son)
            {
                (f as Son).Speak();
            }
 
            //引用类型
            object o = new Son();
 
            //用is as 来判断和转换即可
            if (o is Son)
            {
                (o as Son).Speak();
            }
 
            //值类型
            object o2 = 1;
 
            //用强转
            float fl = (float)o2;
 
            //特殊的string类型
            object str = "123123";
            string str2 = str as string;

            object arr = new int[10];
            int[] ar = arr as int[];
        }
    }

3.装箱拆箱

发生条件：

        用object存值类型（装箱）

        再把object转为值类型（拆箱）

装箱

        把值类型用引用类型存储

        栈内存会迁移到堆内存中

拆箱

        把引用类型存储的值类型取出来

        堆内存会迁移到栈内存中

好处：不确定类型时可以方便参数的存储和传递

坏处：存在内存迁移，增加性能消耗

            //装箱
            object v = 3;
            //拆箱
            int intValue = (int)v;
 
            TestFun(1, 2, 3, 4f, "123456789", new Son());

总结

万物之父：object

        基于里氏替换原则的 可以用object容器装载一切类型的变量

        它是所有类型的基类

装箱拆箱

        用object存值类型（装箱）

        把object里面存的值 转换出来(拆箱)

好处

        不去定类型时可以用 方便参数存储和传递

坏处

        存在内存的迁移 增加了性能消耗

        不是不用，尽量少用

3.密封类

1.基本概念

密封类 是使用 sealed密封关键字修饰的类

作用：让类无法再被继承

2.实例

    sealed class Father
    {
        
    }
    /*class Son : Father
    {
        
    }*/
    //父类有sealed关键字，不可被继承

3.作用

在面向对象程序的设计中，密封类的主要作用就是不允许最底层子类被继承

可以保证程序的规范性、安全性

目前对于大家来说 可能用处不大

随着大家的成长，以后制作复杂系统或者程序框架时 便能慢慢体会到密封的作用

4.总结

关键字：sealed

作用：让类无法再被继承

意义： 加强面向对象程序设计的 规范性、结构性、安全性