第13天c#基础继承

导入其它DLL文件方法

如：创建一个类库 

生成dll文件，生成位置在解决方案文件夹下的Test/bin/Debug文件夹下

引用方法，需要的项目中右键点击引用

点击浏览

选中Test.dll的文件，点击添加

文件前打勾，点击确定，导入文件

导入后，在项目里引用

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Test;             //引用Test.dll文件

namespace _1202笔记
{
    class Program
    {
        static void Main(string[] args)
        {
            Class1 c = new Class1();            //实例化引入的Test.dll类库的Class1类
        }
    }
}

访问修饰符

public：公有的，访问不受限制

private：私有的，只能在本类中访问

protected：受保护的，只能在派生类和本类中访问

internal：同一程序集中任何代码都可以访问（同一程序,只同一个exe文件或者dll文件内）

上面导入的dll文件中如果Class1的修饰符为internal

那么就无法再创建实例对象了

继承的使用

1.子类继承父类所有成员但子类中仅可以访问父类的公有与保护成员：

2.子类继承父类所有成员，可以通过子类对象访问父类的公共成员

3.子类继承父类所有成员，但子类中可以有自己独有的成员

构造函数的执行顺序

当创建一个子类对象时会调用子类与所有父类的构造函数，构造函数的执行顺序：父类构造函数->.....->子类构造函数

namespace 构造函数执行顺序
{
    class Program
    {
        static void Main(string[] args)
        {
            Son s = new Son();

            Console.ReadKey();
        }
    }
    class People
    {
        private string name;
        public People()
        {
            Console.WriteLine("这是People的无参构造函数");
        }

        public People(int num)
        {
            Console.WriteLine("这是People的有参构造函数");
        }
    }

    class Father:People
    {
        public Father()
        {
            Console.WriteLine("这是父类无参构造函数");
        }
        public Father(int num)
        {
            Console.WriteLine("这是父类有参构造函数");
        }
    }
    class Son:Father
    {
        public Son()
        {
            Console.WriteLine("这是子类无参构造函数");
        }
        public Son(int num)
        {
            Console.WriteLine("这是子类有参构造函数");
        }
    }
}

结果：

无论子类调用的是有参还是无参的构造函数，在子类被创建的时候都只会默认调用父类的无参构造函数

结果：调用的只是父类无参的构造函数和自己的有参构造函数

base和this

区别一：

base：指向基类实例或者基类的构造函数

this：指向自己实例或者本类构造函数

区别二：

base:可以使用base在子类中调用父类的成员

this:用来区分子类与父类的同名成员

区别三：

base:通过base调用父类的函数方法

this:通过this调用自己的函数方法

    class Program
    {
        static void Main(string[] args)
        {
            Son s = new Son("子类",29);
            s.FatherName();
            s.SonFun();             

            Console.ReadKey();
        }
    }

    class Father
    {
        public string name;
        public int age;

        public Father( int age)
        {
            name = "父类";
        }

        public void Func()
        {
            Console.WriteLine("我是父类的方法");
        }
    }

    class Son:Father
    {
        public string name;
        
        public Son(string name, int age):base(age)     //base指向基类的构造函数
        {
            this.name = name;
            this.age = age;
        }

        public void FatherName()
        {
            Console.WriteLine(base.name);       //通过base调用父类的属性
        }
        public void SonName()
        {
            Console.WriteLine(this.name);       //通过this调用本类的属性
        }

        public void SonFun()
        {
            base.Func();                        //通过base调用父类方法
            this.SonName();                     //通过this调用本类的方法
        }
    }

结果：

里式转换

1.子类对象可以当做父类对象使用（甚至可以转成父类去使用）

2.如果父类对象中装的是子类对象，我们可以将他强转成子类对象,并且去使用

is和as

is

表示类型转换，如果能够转换成功，则返回一个true，否则返回一个false;

as

表示类型转换，如果能够转换则返回对应的对象，否则返回null。

密封类

使用sealed关键字修饰的类为密封类，密封类无法被继承。