C#继承

c#继承
继承使用符号“：”来表示继承
实例化子类，系统先调用父类的构造函数，然后调用 子类构造函数
1.继承具有层次结构，子类继承父类的状态和方法，通过子类后加：父类名字，如Child : Father
子类继承父类的所有关键字可以直接调用,父类需要添加public关键字（会出现基类可访问性低的问题）

//子类
using System;
public class Child : Father
{
    public Child()
    {
    }
    public static void Main(string[] args)
    {
        Child chiObj = new Child();
        chiObj.Speak();
        Console.WriteLine("父类的字段显示 Height={0}", chiObj.Height);
    }


//父类
using System;
public class Father
{
    public int Height;
    public int Weight;

    public Father()
    {
        Height = 180;
        Weight = 90;
    }
    public void Speak()
    {
        Console.WriteLine("Hello World!");
    }
    
}
}

2.方法覆盖：如果子类和父类有同样的方法，子类的方法会把父类相同的的方法覆盖掉
如果子类和父类有同样的方法，但是这个需要通过base.父类方法来实现（注意this和base不能再静态方法中使用）

using System;

public class Child : Father
{
    public Child()
    {
    }
    public void Speak()
    {
        Console.WriteLine("孩子说话");
    }
    public void Display()
    {
        base.Speak();
        this.Speak();
    }
    public static void Main(string[] args)
    {
        Child chiObj = new Child();
        chiObj.Display();
        Console.WriteLine("父类的字段显示 Height={0}", chiObj.Height);
    }
}


using System;


public class Father
{
    public int Height;
    public int Weight;

    public Father()
    {
        Height = 180;
        Weight = 90;
    }
    public void Speak()
    {
        Console.WriteLine("父亲说话");
    }
    
}

this始终调用本类的变量和方法
base始终调用父类的变量和方法
主要用于在父类和子类之间调用相同的方法

3.继承关系中的构造函数应用
1：父子继承关系中实例化对象的时候，首先调用父类的构造函数再调用子类的构造函数，
2.集成关系中构造函数的应用：父子继承关系中，实例化对象的时候，首先调用父类的构造函数在调用子类的构造函数。在子类的构造函数后面加：base（）
3.在实例化的时候就可以传参

using System;


public class Father
{
    public int Height;
    public int Weight;

    public Father()
    {
        Height = 180;
        Weight = 90;
        Console.WriteLine("父类的构造函数");
    }
    public void Speak()
    {
        Console.WriteLine("父亲说话");
    }
    
}



using System;

public class Child : Father
{
    public Child()
    {
        Console.WriteLine("子类的构造函数");
    }
    public void Speak()
    {
        Console.WriteLine("孩子说话");
    }
    public void Display()
    {
        base.Speak();
        this.Speak();
    }
    public static void Main(string[] args)
    {
        Child chiObj = new Child();
        chiObj.Display();
        Console.WriteLine("父类的字段显示 Height={0}", chiObj.Height);
    }
}

3.在实例化的时候就可以传参
显示的调用父类的构造函数，如果父类的构造函数带参数的话，必须使用base。结构是base.(父类构造函数中的参数)，派生类在调用构造函数的时候最好是使用基类的构造函数

using System;


public class Father
{
    public int Height;
    public int Weight;

    public Father()
    {
        Console.WriteLine("父类的构造函数");
    }
    public Father(int height,int weight)//带参数的构造函数
    {
        Height = height;
        Weight = weight;
    }
    public void Speak()
    {
        Console.WriteLine("父亲说话");
    }
    
}
using System;

public class Child : Father
{
    public Child()
    {
        Console.WriteLine("子类的构造函数");
    }
    public Child(int height,int weight):base(height,weight)//在实例化的时候对父类的构造函数传参
    {

    }
    public void Speak()
    {
        Console.WriteLine("孩子说话");
    }
    public void Display()
    {
        base.Speak();
        this.Speak();
        Console.WriteLine("Height={0}", base.Height);
        Console.WriteLine("Height={0}", base.Height);
    }
    public static void Main(string[] args)
    {
        //演示bese关键字在调用函数的应用
        Child chiObj = new Child(170,50);
        chiObj.Display();
        
       
    }
}

关于字段、方法的默认访问符是private（私有的）
关于类的默认访问修饰符是internal（局部的）
父类私有的字段不能访问

4.构造函数和析构函数
构造函数在是在执行的时候运行的函数，析构函数是在消失的时候又系统自动调用的函数。
不能再结构里面定义析构函数，只能对类定义析构函数，一个类只能由一个析构函数，无法继承或重载析构函数，无法调用析构函数，他们是被系统调用的，析构函数既没有修饰符，也没有参数。

5.命名空间
namespace 定义了命名空间，作用是可以是不同命名空间下的类名相同
当类名相同的时候可以通过不同的命名空间在区分，一下是全路径命名，通过 命名空间.类名

using System;
namespace damo1
{
    public class test1
    {
        public test1()
        {
        }
        public void Displayinfo()
        {
            Console.WriteLine("我是damo1里面的text1");
        }
    }
}

using System;
namespace damo2
{
    public class text1
    {
        public text1()
        {
        }
        public static void Main(string[] args)
        {
            damo1.test1 obj = new damo1.test1();
            obj.Displayinfo();


        }
    }
}

引入命名空间
可以通过引入命名空间的方式来调用命名空间里面的类变量和方法

using System;
//using的作用就是引入命名空间，避免复杂来的全路径
using damo1;

namespace damo2
{
    public class text2
    {
        public text2()
        {
        }
        public static void Main(string[] args)
        {

            test1 obj = new test1();
            obj.Displayinfo();

        }
    }
}

6.protected和internal
protected 所属类和派生类的类型可以访问，如果是有继承关系是可以访问的，如果没有继承关系就不能访问

using System;

namespace damo5
{
    public class father
    {

        public int Height = 180;
        //受保护类型的
        protected void  Speak()
        {
            Console.WriteLine("父亲说话");
        }
       
    }
}

using System;
namespace damo5
{
    public class son:father
    {
        private  void SonPlay()
        {
            Console.WriteLine("son玩耍");
        }
        public son()
        {
        }
        public static void Main(string[] args)
        {
            son obj = new son();
            obj.SonPlay();//自己的方法
            obj.Speak();//父类的说话方法
        }
    }
}

如果子类和父类没有继承关系则
internal 当前程序集可以访问,一个项目就是一个程序集，internal定义的字段和方法在同一个项目里面可以访问，如果跨程序集就必须用public，如果是在一个项目里面internal和public是一样的。
如果要跨程序集访问需要在访问项目中的引用中添加被反问项目的命名空间。如果在damo6里面想访问damo7里面的内容需要在引用里面添加damo7的命名空间才可以访问。





7.访问了类型优先级排序
public>internal>protected>private