面对对象之继承，密封

继承概念

在C#中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有的类被称作父类，子类会自动拥有父类除构造方法和析构方法以外的所有成员。
继承关系的相关语法：
class 子类：父类
{

}

对于继承父类的子类来说，子类可以使用父类中公有的成员。

对于C#来说，子类单继承一个父类，也就是说，C#继承具有单一性。
多个类可以同时继承同一个父类。

在C#中，多层继承是可以的，即一个类的父类可以再去继承其他类，例如C类继承自B类，B类又继承自A类，这时，C类也可称作A类的子类。
子类都继承了父类哪些内容？

公有的字段是可以被继承的
公有的属性是可以被继承的
公有的方法可以被继承
构造方法是不可以被继承的
【注意】所有公有的方法是可以被继承的 说法是错误的，因为公有的构造方法是不能被继承的
base关键字

父子类之间构造方法执行的顺序

装箱拆箱操作

在实际开发过程中，某些方法的参数类型为引用类型，但是如果调用时传入的是值类型，此时需要进行装箱操作。同样当一个方法的返回值类型为值类型，但实际方法返回值为引用类型，那么就需要进行拆箱操作。简单来说，装箱就是将值类型转换为引用类型，拆箱就是将引用类型转换为值类型
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 装箱拆箱操作
{
class Program
{
static void Main(string[] args)
{
//装箱拆箱操作是在值类型和引用类型之间进行转化
int num1 = 100;
//装箱操作
//将值类型转化成引用类型
object obj1 = num1;

        object obj2 = 12;
        //拆箱操作
        //将引用类型转化成值类型
        int num2 = (int)obj2;
    }
}

}
装箱和拆箱过程本质上是数据存储在栈与堆之间变更，因此频繁的装箱、拆箱操作会影响运算效率，所以要尽量减少相关操作
里氏转换原则

子类：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 里氏转换原则
{
class Dog:Animal
{

    public Dog()
    {

    }
    public Dog(string name, int age, char gender):base(name,age,gender)
    {

    }

    public void Bark()
    {
        Console.WriteLine("吠");
    }


}

}
父类：
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace 里氏转换原则
{
class Animal
{
private string name;
private int age;
private char gender;

    public string Name
    {
        get
        {
            return name;
        }

        set
        {
            name = value;
        }
    }

    public int Age
    {
        get
        {
            return age;
        }

        set
        {
            age = value;
        }
    }

    public char Gender
    {
        get
        {
            return gender;
        }

        set
        {
            gender = value;
        }
    }

    public Animal()
    {

    }
    public Animal(string name, int age, char gender)
    {
        this.Name = name;
        this.Age = age;
        this.Gender = gender;
    }

    public void Eat()
    {
        Console.WriteLine("吃");
    }
}

}
Program类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 里氏转换原则
{
class Program
{
static void Main(string[] args)
{

        //里氏转换原则  是在父子类之间进行转化
        //向上转型 类似隐式类型转换
        Animal anial = new Dog();
        anial.Eat();
        //向下转型 类似强制类型转换
        Dog dog = (Dog)anial;
        dog.Eat();
        dog.Bark();
    }
}

}
is和as的区别
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace is和as的区别
{
class Program
{
static void Main(string[] args)
{
Animal[] animals = new Animal[5];
animals[0] = new Dog(“小黑”,1,’公’);
animals[1] = new Cat(“小白”, 1, ‘母’);
animals[2] = new Dog(“小灰”, 1, ‘母’);
animals[3] = new Cat(“小花”, 1, ‘公’);
animals[4] = new Dog(“小纯”, 1, ‘母’);

        for (int i = 0; i < animals.Length; i++)
        {
            //is关键字
            //is不会讲对象直接进行转化 会在转化之前 进行一次判断 如果类型匹配则返回true  类型不匹配 则返回false  然后需要根据返回值进行适当操作
            //bool ret = animals[i] is Dog;
            //if (ret)
            //{
            //    ((Dog)animals[i]).Bark();
            //}
            //else
            //{
            //    ((Cat)animals[i]).Bark();
            //}

            //as  
            //as 可以将animals[i]直接转化  转化成功  返回一个Dog实例  否则返回null

            Dog dog = animals[i] as Dog;
            if (dog !=null)
            {
                dog.Bark();
            }

            Cat cat = animals[i] as Cat;
            if (cat != null)
            {
                cat.Bark();
            }
        }
    }
}

}
对父类的公有字段、方法、属性进行隐藏

子类在继承父类时可以对父类的成员进行扩展，如果子类中出现与父类同名的方法，那么在调用该方法时程序就不能明确该方法是属于父类还是子类，这时编译器就会提示使用new关键字隐藏基类方法。

在子类的字段、属性、方法的访问修饰符(一般是public)之后添加new即可
密封类：

在C#中，使用sealed关键字修饰的类不可以被继承，也就是说不能派生子类，这样的类通常被称作密封类。
我们经常使用的string类型就是一个密封类