C#面向对象OOP之二

一.继承

1.C#中不可以多重继承，即一个派生类不可以有多个基类

2.virtual 虚方法、虚类

基类的virtual可以在派生类中用override重写，也可以不重写

注意：static方法不能override，基类的private方法不可以override

3.abstract 抽象方法、抽象类

抽象方法只能写在抽象类中

抽象类可以包含抽象方法和非抽象方法，但至少要声明一个抽象方法

派生类必须override抽象类？？

抽象类不能被实例化，不可以有函数体，必须通过派生类去实例化，函数在派生类中override

4.sealed 密闭方法、密闭类

sealed类不允许被继承

sealed方法不能够被派生类override

5.继承构造实例化时的顺序

    class Program
    {
        static void Main(string[] args)
        {
            Dog dog = new Dog();
            Console.ReadLine();
        }
    }

    class Animal
    {
       public Animal()
        {
            Console.WriteLine("Aniaml Constructor");
        }
    }

    sealed class Dog : Animal
    {
        public Dog()
        {
            Console.WriteLine("Dog Constructor");
        }
    }

运行结果

即，一个子类的实例化，先调用父类的构造函数去实例化，再调用子类的构造函数去实例化

6.父类含有多个构造函数，子类继承时会调用哪个

    class Program
    {
        static void Main(string[] args)
        {
            Dog dog = new Dog();
            Dog oldDog = new Dog(10);

            Console.ReadLine();
        }
    }

    class Animal
    {
       public int Age;
       public Animal()
        {
            Console.WriteLine("Aniaml Constructor");
        }
        public Animal(int age)
        {
            Console.WriteLine("Old Aniaml");
            this.Age = age;
        }
    }

    sealed class Dog : Animal
    {
        public Dog()
        {
            Console.WriteLine("Dog Constructor");
        }
        public Dog(int age)
        {
            Console.WriteLine("Old Dog");
            this.Age = age;
        }
    }

运行结果

即，调用子类构造函数，会先调用父类的默认构造函数，再调用子类的具体构造函数

如果代码改成 base

    class Program
    {
        static void Main(string[] args)
        {
            Dog dog = new Dog();
            Dog oldDog = new Dog(10);

            Console.ReadLine();
        }
    }

    class Animal
    {
       public int Age;
       public Animal()
        {
            Console.WriteLine("Aniaml Constructor");
        }
        public Animal(int age)
        {
            Console.WriteLine("Old Aniaml");
            this.Age = age;
        }
    }

    sealed class Dog : Animal
    {
        public Dog()
        {
            Console.WriteLine("Dog Constructor");
        }
        public Dog(int age):base(age)
        {
            Console.WriteLine("Old Dog");
            this.Age = age;
        }
    }

运行结果

即，先调用父类的具体构造函数，再调用子类的具体构造函数

7.在两个构造函数之间互相引用 this

    class Program
    {
        static void Main(string[] args)
        {
            Dog dog = new Dog();
            Dog oldDog = new Dog(10);

            Console.ReadLine();
        }
    }

    class Animal
    {
       public int Age;
       public Animal()
        {
            Console.WriteLine("Aniaml Constructor");
        }
        public Animal(int age)
        {
            Console.WriteLine("Old Aniaml");
            this.Age = age;
        }
    }

    sealed class Dog : Animal
    {
        public Dog()
        {
            Console.WriteLine("Dog Constructor");
        }
        public Dog(int age):this()
        {
            Console.WriteLine("Old Dog");
            this.Age = age;
        }
    }

运行结果

即，先调用父类的默认构造函数，再调用自己的默认构造函数，最后调用自己的构造函数

8.继承中new和override的区别

    class Program
    {
        static void Main(string[] args)
        {
            Animal dog = new Dog();
            dog.Bite();
            Console.ReadLine();
        }
    }

    class Animal
    {
       public int Age;
       public Animal()
        {
            Console.WriteLine("Aniaml Constructor");
        }
        public Animal(int age)
        {
            Console.WriteLine("Old Aniaml");
            this.Age = age;
        }
        public virtual void Bite()
        {
            Console.WriteLine("Animal bite man");
        }
    }

    sealed class Dog : Animal
    {
        public Dog()
        {
            Console.WriteLine("Dog Constructor");
        }
        public Dog(int age):this()
        {
            Console.WriteLine("Old Dog");
            this.Age = age;
        }
        public override void Bite()
        {
            Console.WriteLine("Dog bite");
        }
    }

运行结果

如果代码改为

    class Program
    {
        static void Main(string[] args)
        {
            Animal dog = new Dog();
            dog.Bite();
            dog.BiteMan();
            Console.ReadLine();
        }
    }

    class Animal
    {
       public int Age;
       public Animal()
        {
            Console.WriteLine("Aniaml Constructor");
        }
        public Animal(int age)
        {
            Console.WriteLine("Old Aniaml");
            this.Age = age;
        }
        public virtual void Bite()
        {
            Console.WriteLine("Animal bite man");
        }
        public void BiteMan()
        {
            Console.WriteLine("Aniaml bite man");
        }
    }

    sealed class Dog : Animal
    {
        public Dog()
        {
            Console.WriteLine("Dog Constructor");
        }
        public Dog(int age):this()
        {
            Console.WriteLine("Old Dog");
            this.Age = age;
        }
        public override void Bite()
        {
            Console.WriteLine("Dog bite");
        }
        public new void BiteMan()
        {
            Console.WriteLine("Dog bite man");
        }
    }

运行结果

即，调用父类的BiteMan函数。

因为在父类中声明一个变量，具体实例化一个子类，如果override，即父类中的Bite重写了，就直接调用了子类的Bite

如果new，即在子类中隐藏掉了父类中的BiteMan，但是并没有重写父类中的BiteMan，如果是animal类的变量，调用方法就是调用父类中的方法

如果代码改为

    class Program
    {
        static void Main(string[] args)
        {
            Animal dog = new Dog();
            dog.Bite();
            ((Dog)dog).BiteMan();
            Console.ReadLine();
        }
    }

    class Animal
    {
       public int Age;
       public Animal()
        {
            Console.WriteLine("Aniaml Constructor");
        }
        public Animal(int age)
        {
            Console.WriteLine("Old Aniaml");
            this.Age = age;
        }
        public virtual void Bite()
        {
            Console.WriteLine("Animal bite man");
        }
        public void BiteMan()
        {
            Console.WriteLine("Aniaml bite man");
        }
    }

    sealed class Dog : Animal
    {
        public Dog()
        {
            Console.WriteLine("Dog Constructor");
        }
        public Dog(int age):this()
        {
            Console.WriteLine("Old Dog");
            this.Age = age;
        }
        public override void Bite()
        {
            Console.WriteLine("Dog bite");
        }
        public new void BiteMan()
        {
            Console.WriteLine("Dog bite man");
        }
    }

运行结果

即，强制类型转换后，调用子类中的方法