C#面向对象的概念 ----继承,里氏转换和几种集合（1）

我们知道面向对象的三个特征，封装，继承和多态。我们前面已经学习了如何封装在类中封装方法。现在我们系统学习什么是继承。

我们下面写几个类：student teacher driver几个类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 草稿1
{
    public class Student
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

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

        private char _gender;
        public char Gender
        {
            get { return _gender; }
            set { _gender = value; }
        }

        private int _id;
        public int Id
        {
            get { return _id; }
            set { _id = value; }
        }

        public void CHLSS()
        {
            Console.WriteLine("吃喝拉撒睡");
        }
        public void Study()
        {
            Console.WriteLine("学生会学习");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 草稿1
{
    public class Teacher
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

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

        private char _gender;
        public char Gender
        {
            get { return _gender; }
            set { _gender = value; }
        }

        private double _salary;
        public double Salary
        {
            get { return _salary; }
            set { _salary = value; }
        }

        public void CHLSS()
        {
            Console.WriteLine("吃喝拉撒睡");
        }
        public void Teach()
        {

            Console.WriteLine("老师会讲课");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 草稿1
{
    public class Driver
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

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

        private char _gender;
        public char Gender
        {
            get { return _gender; }
            set { _gender = value; }
        }

        private int _driveTime;
        public int DriveTime
        {
            get { return _driveTime; }
            set { _driveTime = value; }
        }

        public void CHLSS()
        {
            Console.WriteLine("吃喝拉撒睡");
        }

        public void Drive()
        {
            Console.WriteLine("司机会开车");
        }

    }
}

我们会发现这几个类中成员有重复的，方法有重复的，这时我们把这几个类中重复成员单独拿出来，封装一个类，作为这几个类的

父类。所以我们改造如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 草稿1
{
    public class Person
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

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

        private char _gender;
        public char Gender
        {
            get { return _gender; }
            set { _gender = value; }
        }

        public void CHLSS()
        {
            Console.WriteLine("吃喝拉撒睡");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 草稿1
{
    public class Driver:Person
    {
        private int _driveTime;
        public int DriveTime
        {
            get { return _driveTime; }
            set { _driveTime = value; }
        }
        public void Drive()
        {
            Console.WriteLine("司机会开车");
        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 草稿1
{
    public class Teacher:Person
    {
        private double _salary;
        public double Salary
        {
            get { return _salary; }
            set { _salary = value; }
        }

        public void Teach()
        {

            Console.WriteLine("老师会讲课");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 草稿1
{
    public class Student:Person
    {
        private int _id;
        public int Id
        {
            get { return _id; }
            set { _id = value; }
        }
        public void Study()
        {
            Console.WriteLine("学生会学习");
        }
    }
}

我们可能会在一些类中，写一些重复的成员，我们可以将这些重复的成员，单独的封装到一个类中，作为这些类的父类。

首先，子类继承了父类的属性和方法，但是子类并没有继承父类的私有字段。

引出：子类有没有继承父类的构造函数？

子类并没有继承父类的构造函数。但是，子类会默认调用父类无参数的构造函数。创建父类对象，让子类可以使用父类中的成员。

所以，如果父类中重新写了一个有参数的构造函数之后，那个无参数的就被干掉了，子类就调用不到了，所以子类会报错。

解决办法：1.再父类中重新写一个无参数的构造函数。

          2.在子类中显示的调用父类的构造函数，使用关键字：base()

继承的特性

1.继承的单根性：一个子类只能有一个父类。

2.继承的传递性：

New关键字

1）创建对象

2）隐藏从父类那里继承过来的同名成员。隐藏后果就是子类调用不到父类成员。

---

里氏转换

1）子类可以赋值给父类。如果有一个地方需要一个父类作为参数，我们可以给一个子类代替。

2）如果父类中装的是子类对象，那么可以将这个父类强转为子类对象。

子类对象可以调用父类中的成员，但是父类对象永远都只能调用自己的成员。

类型转换判断的两个关键字

（1）is：表示类型转换，如果能够转换成功，则返回一个true，否则返回一个false。

（2）as：表示类型转换，如果能够转换则返回对应的对象，否则返回一个null。

下面我们做一个综合练习：为了方便观察代码，我们将各种类写到了program类中

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 草稿1
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建10个对象，通过一个循环，去调用他们各自打招呼的方法
            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 ShuaiGuo();
                        break;
                    case 4:
                        pers[i] = new MeiLv();
                        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]).StudentSayHi();
                }
                else if (pers[i] is Teacher)
                {
                    ((Teacher)pers[i]).TeacherSayHi();
                }
                else if (pers[i] is MeiLv)
                {
                    ((MeiLv)pers[i]).MeiLvSayHi();
                }
                else if (pers[i] is ShuaiGuo)
                {
                    ((ShuaiGuo)pers[i]).ShuaiGuoSayHi();
                }
                else if (pers[i] is YeShou)
                {
                    ((YeShou)pers[i]).YeShouSayHi();
                }
                else 
                {
                    pers[i].PersonSayHi();
                }
            }
            Console.ReadKey();
        }
    }

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

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

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

    public class MeiLv : Person
    {
        public void MeiLvSayHi()
        {
            Console.WriteLine("我是美铝");
        }
    }

    public class ShuaiGuo : Person
    {
        public void ShuaiGuoSayHi()
        {
            Console.WriteLine("我是帅锅");
        }
    }

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

关键字protected:

受保护的：可以在当前类的内部以及该类的子类中访问。

---

两个集合ArrayList和HashTable

ArrayList集合我数组对比：

数组：长度不可变，类型单一

集合：长度任意改变，类型多元化。

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 草稿1
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList list = new ArrayList();

            list.Add(1);
            list.Add(3.14);
            list.Add(true);
            list.Add("张三");
            list.Add('男');
            list.Add(5000m);

            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(list[i]);
            }
            Console.ReadKey();
        }
    }
}

ArrayList集合的几个方法：

list.addRange():添加集合元素。

list.Clear():清空所有元素。

list.Remove():删除单个元素，写谁就删谁。

list.RemoveAt():根据下标删除元素。

list.RemoveRange()：根据下标删除一定范围的元素

list.Sort():升序排列

list.Reverse():反转

list.Insert():在指定的位置插入一个元素。

list.InsertRange():在指定位置插入一定范围的元素。

list.Contains():判断是否包含某个指定的元素。

ArrayList集合长度问题

每次集合中实际包含的元素个数（count）超过了可以包含的元素的个数（capcity）的时候，集合就会像内存中申请多开辟一倍的

空间，来保证集合的长度一直够用。

HashTable键值对集合

在键值对集合当中，我们是根据键去找值的。

键值对对象[键]=值；

注意：键值对集合当中，键必须是唯一的，而值是可以重复的。

下面我们讨论一下我们如何能够遍历HashTable集合的所有元素，我们一提到便利元素，肯定会想到使用for循环，但是HashTable集合中

键的类型是object，所以可能不是值类型，而且foreach循环的运行效率要比for循环的高，所以我们不能使用for循环，这时我们可以使用foreach。

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 草稿1
{
    class Program
    {
        static void Main(string[] args)
        {
            Hashtable ht = new Hashtable();
            ht.Add(1,"张三");
            ht.Add(2,true);
            ht.Add(3,'男');
            ht.Add(false,"错误的");

            foreach (var item in ht.Keys)
            {
                Console.WriteLine(ht[item]);
            }
            Console.ReadKey();
        }
    }
}

我们除了使用foreach循环添加数据，也可以使用赋值的方法添加数据。这种方式也可以把相同键值的值覆盖掉。

键值对对象[键]=value；

键值对集合常用方法：

ht.ContainsKey();判断是否包含键。

ht.Add():添加键值对元素。

ht.Clear();清空所有元素。

ht.Remove():移除键所对应的元素。

---

学习几个重要的类

Path类：

Path.Get FileName（）:获得文件名。

Path.GetFileNameWithoutExtension():获得文件名但是不包括扩展名。

Path.GetExtension():获得文件的扩展名。

Path.GetDirectoryName():获得文件所在的文件夹的名称。

Path.GetFullPath():获得文件所在的全路径。

Path.Combine():链接两个字符串作为路径。

File类：

File.Create():创建一个文件。

File.Delete():删除一个文件。

File.Copy():复制一个文件。