继承

1 继承基本概念

1.1、面向对象有三个过程：封装、继承、多态

1.2、自动属性：不需要写字段，但弊端是不能在get、set中进行判断
例如：

        public class Student
        {
            public string Name//自动属性
            {
                get;
                set;
            }

            int _age;
            public int Age
            {
                get { return _age; }
                set { _age = value; }
            }
        }

1.3、继承概念：
我们在写类的过程当中，会发现，在多个类当中会存在一些相同的属性和方法。
为了解决这种代码冗余，于是乎，我们使用继承来解决这个问题。

1.4、父类与子类：我们把一些类当中所共同具有的属性和方法单独的拿出来封装成一个父类。
然后让其他类去继承这个父类。
如果一个类继承了另一个类，我们管这个类称之为子类，管被继承的那个类称之为父类。
或者 管这类称之为派生类，管被继承的那个类称之为基类。注意：object是所有类的父类

1.5、继承的语法：public class 子类:父类

    class Program
    {
        static void Main(string[] args)
        {
            Student s = new Student();
            Teacher t = new Teacher();
        }
        
    }
    public class People
    {
        public int Age
        {
            set;
            get;
        }
        public char Gender
        {
            get;
            set;
        }
        public string Name
        {
            get;
            set;
        }
    }
    public class Student:People//代表Student类继承People类
    {      
        public void Study()
        {
            Console.WriteLine("会学习");
        }
    }
    public class Teacher
    {
        public void Teach()
        {
            Console.WriteLine("会讲课");
        }
    }

1.6、一个子类继承了一个父类，那么这个子类继承了父类的什么成员？
字段、属性、方法、构造函数

子类继承了父类的属性和方法。
子类并没有继承父类的私有字段。
子类并没有继承父类的构造函数，而是会默认的调用父类那个无参数的构造函数，
当你在父类中写了一个有参数的构造函数之后，那个默认的无参数的构造函数就被干掉了，
此时子类就调不到那个无参数的构造函数了。
解决办法：
1)、在父类中重新写一个无参数的构造函数。
2)、让子类去显示的调用父类有参数的构造函数。使用关键字:base()

1.7、继承的特性：
1、单根性，一个子类只能有一个父类。一个儿子只能有一个爹。
2、传递性，爷爷有的，爹肯定有，爹有的，最终儿子也会有。

1.8、查看视图
右键点击项目可以查看视图，便于看各种类的分布

1.9、object类是一切类型的基类

1.10、练习题：
写一个Reporter类和一个Programmer类，Driver类，他们都有一个打招呼的方式，
不同的是Reporter打招呼时说"大家好，我叫xx，我今年xx岁了，我是x生,我的爱好是xxx"，
Programmer的打招呼的方法是说"大家好，我叫xx，我今年xx岁了,我是x生,我已经工作了xx年"
Driver类是：“大家好，我叫xx，我今年xx岁了,我是x生,我的驾龄是xx年”

    class Program
    {
        static void Main(string[] args)
        {
            Reporter r = new Reporter("小李", 18, '男',"足球");
            Programmer p = new Programmer("程序员", 20, '男', 5);
            Driver d = new Driver("司机", 29, '女', 6);
            r.ReporterSayHello();
            p.ProgrammerSayHello();
            d.DriverSayHello();
            Console.ReadKey();
        }
    }

    public class People
    {
        public string Name
        {
            get;
            set;
        }
        public int Year
        {
            get;
            set;
        }
        public char Gender
        {
            get;
            set;
        }

        public People(string name,int year,char gender)//构造函数
        {
            this.Name = name;
            this.Year = year;
            this.Gender = gender;
        }
    }

    public class Reporter:People
    {
        public Reporter(string name, int year, char gender,string hobby)
            : base(name, year, gender)
        {
            this.Hobby = hobby;
        }
        public string Hobby
        {
            get;
            set;
        }

        public void ReporterSayHello()
        {
            Console.WriteLine("大家好，我叫{0}，我今年{1}岁了，我是{2}生, 我的爱好是{3}", this.Name, this.Year, this.Gender, this.Hobby);
        }
    }

    public class Programmer:People
    {
        public Programmer(string name, int year, char gender, int workyear)
            : base(name,year,gender)
        {
            this.Workyear = workyear;
        }
        public int Workyear
        {
            get;
            set;
        }
        public void ProgrammerSayHello()
        {
            Console.WriteLine("大家好，我叫{0}，我今年{1}岁了，我是{2}生, 我工作{3}年了", this.Name, this.Year, this.Gender, this.Workyear);
        }
    }

    public class Driver:People
    {
        public Driver(string name, int year, char gender, int driveryear) : base(name, year, gender)
        {
            this.Driveryear = driveryear;
        }
        public int Driveryear
        {
            get;
            set;
        }
        public void DriverSayHello()
        {
            Console.WriteLine("大家好，我叫{0}，我今年{1}岁了，我是{2}生, 我驾龄{3}年了", this.Name, this.Year, this.Gender, this.Driveryear);
        }
    }

1.11、new的用法
作用：1、创建对象 2、隐藏从父类中继承来的成员

为什么要用new?: 当子类的成员与父类成员姓名相同时，子类会隐藏父类成员名，但也继承了父类的成员，而隐藏的后果是在main函数中子类对象点不出来父类对象。

若是想故意隐藏从父类继承的成员就使用new
例如：

    public class Person
    {
        public void SayHello()
        {
            Console.WriteLine("我是人类");
        }
    }

    public class Student:Person
    {
        public new  void SayHello()
        {
            Console.WriteLine("我是学生");
        }
    }

1.12、this的用法
作用：1、代表当前类的对象 2、显示的调用自己的构造函数（base是调用父类的构造函数）（因为未来我们可能会调用多个构造函数构成重载）

          static void Main(string[] args)
        {
            Student s = new Student()//此时就有三种不同的构造函数

        }    
        
    }
    public class Student
    {
        public string Name
        {
            get;
            set;
        }

        public int Age
        {
            get;
            set;
        }

        public char Gender
        {
            get;
            set;
        }

        public int ID
        {
            get;
            set;
        }

        public Student(string name,int age, char gender,int id)
        {

            this.Age = age;
            this.Gender = gender;
            this.Name = name;
            this.ID = id;
        }

        public Student(string name,int age,char gender)
            :this(name,age,gender,0)
        {
         
        }
        public Student(int age,char gender,int id)
            :this(null,age,gender,id)
        { 
        }
        
    }

1.13、里氏转换
1)、子类可以赋值给父类。
2)、如果这个父类中装的是子类对象，那么可以将这个父类强转为子类对象。

        static void Main(string[] args)
        {
            /*Student s = new Student();//创建一个子类对象
            Person p = s;//子类赋值给父类

            上面两行代码可以浓缩为一行代码，如下：
             */
            Person p = new Student();
            Student s = (Student)p;// 将这个父类强转为对应的子类对象
            //如果变成 Teacher s=(Teacher)p;就不行因为子类对象是Student
        }
    }

    public class Person
    {

    }

    public class Student : Person
    {

    }

    public class Teacher:Person
    {

    }

（3）将父类强制转换为子类时，会出现异常，因此引入两个关键字as,is
is：类型转换 ，如果转换成功，返回一个true，否则返回一个false。

        static void Main(string[] args)
        {
            Person p = new Student();

            if(p is Student)
            {
                Student s = (Student)p;
                Console.WriteLine("成功");
            }
            else
            {
                Console.WriteLine("失败");
            }
            Console.ReadKey();
        }
    }

    public class Person
    {

    }

    public class Student : Person
    {

    }

    public class Teacher:Person
    {

    }

as：类型转换，如果转换成功，则返回对应的对象，如果转换失败，返回一个null。

        static void Main(string[] args)
        {
            Person p = new Student();
            Student s = p as Student;
            Console.ReadKey();
        }
    }

    public class Person
    {

    }

    public class Student : Person
    {

    }

    public class Teacher:Person
    {

    }

1.14、里氏转换练习

这道练习题目的是，写七个类，在类中写方法，每次都随机产生七个不同语句

由于pers是Person类，是父类，因此它不能调用子类的方法，因此想pers调用子类方法是要将其强制转换为子类

            Person[] pers = new Person[10];
            Random r = new Random();
            for(int i=0;i<pers.Length;i++)
            {
                int rNumber = r.Next(1, 7);
                switch(rNumber)
                {
                    case 1:pers[i] = new Student();
                        break;
                    case 2:
                        pers[i] = new Teacher();
                        break;
                    case 3:
                        pers[i] = new MeiNv();
                        break;
                    case 4:
                        pers[i] = new ShuaiGe();
                        break;
                    case 5:
                        pers[i] = new YeShou();
                        break;
                    case 6:
                        pers[i] = new Person();
                        break;
                }
            }
            for(int i=0;i<pers.Length;i++)
            {
                if(pers[i] is Student)
                {
                    ((Student)pers[i]).StudentSyHello();
                }
                else if (pers[i] is Teacher)
                {
                    ((Teacher)pers[i]).TeacherSayHello();
                }
                else if (pers[i] is MeiNv)
                {
                    ((MeiNv)pers[i]).MeiNuSayHello();
                }
                else if (pers[i] is ShuaiGe)
                {
                    ((ShuaiGe)pers[i]).ShuaiGeSayHello();
                }
                else if (pers[i] is YeShou)
                {
                    ((YeShou)pers[i]).YeShouSayHello();
                }
                else
                {
                    pers[i].PersonSayHello();
                }
            }


            Console.ReadKey();
        }
    }
   
    public class Person
    {
        public void PersonSayHello()
        {
            Console.WriteLine("我是人类");
        }
    }

    public class Student:Person
    {
        public void StudentSyHello()
        {
            Console.WriteLine("我是学生");
        }
    }

    public class Teacher:Person
    {
        public void TeacherSayHello()
        {
            Console.WriteLine("我是老师");
        }
    }

    public class MeiNv:Person
    {
        public void MeiNuSayHello()
        {
            Console.WriteLine("我是美女");
        }
    }

    public class ShuaiGe:Person
    {
        public void ShuaiGeSayHello()
        {
            Console.WriteLine("我是帅哥");
        }
    }

    public class YeShou:Person
    {
        public void YeShouSayHello()
        {
            Console.WriteLine("我是野兽");
        }
    }

1.15、File类的操作
1、引入命名空间（由于不是所有的类都被头文件命名空间包括，因此要引入命名空间）
（1）使用快捷键 alt+shift+F10
（2）使用鼠标的方式
2、应用
Exist():判断指定的文件是否存在

            bool b = File.Exists(@"F:\c#学习视频\10.Net基础班第十天\0326.Net基础班第十天");
            Console.WriteLine(b);
            Console.ReadKey();

Move()：对一个指定的文件进行剪切操作
Copy():对一个指定的文件进行复制操作
Create():创建一个新文件