C# OOP重难点

One:使用集合组织相关数据

集合：升级版的数组

1.特点：长度可变+任意类型（系统会将存入的数据统一转化为object类型）
2.集合初始化器：ArrayList list = new ArrayList() {初始数据1,初始数据2,初始数据3};
3.注意事项：记得导入命名空间

             //创建集合的对象
        ArrayList list = new ArrayList(2) { 99,3,2};
        //一、添加数据
        list.Add(59);
        list.Add(79);
        list.Add(99);
        
        //二、获取单个数据
        double num = Convert.ToDouble(list[1]);
        
        //三、遍历集合：将集合中所有的数据获取输出
        for (int i = 0; i < list.Count; i++)
        {
            Console.WriteLine(list[i]);
        }
        //四、删除
        //1.根据数据来删除：当存在重复数据时   只会删除第一个
        //list.Remove(99);
        
        //2.根据索引来删除
        //list.RemoveAt(2);
        
        //3.清空集合
        //list.Clear();

        //五、判断是否包含   true:集合存在此数据       false：数据不存在
        bool f= list.Contains(70);
        
        //六、在指定的下标插入数据
        list.Insert(1, 71);
        Console.WriteLine("删除后：");
        foreach (object item in list)
        {
            Console.WriteLine((int)item);
        }

        //创建对象
        Student stu1 = new Student();
        stu1.Age = 17;
        stu1.Name = "十二的雪";
        Student stu2 = new Student();
        stu2.Age = 19;
        stu2.Name = "十三的秋";
        
        //创建学生集合
        ArrayList stulist = new ArrayList();
        stulist.Add(stu1);
        stulist.Add(stu2);

        //遍历集合
        Console.WriteLine("姓名\t\t年龄");
        for (int i = 0; i < stulist.Count; i++)
        {
            Console.WriteLine(((Student)stulist[i]).Name+"\t\t"+ ((Student)stulist[i]).Age);
        }
        Console.ReadLine();`

哈希表

1.哈希表的特点：长度可变+通过建值对的方式存储数据（key->value)（身份证号–姓名）
2.注意事项：key值不可以重复 value可以重复
存入哈希表会将建值对转换为object 所以会拿出来的时候需要进行类型转换

        //创建哈希表
        Hashtable table = new Hashtable();
        
        //添加
        table.Add("教员","十二");
        table.Add("班主任", "十三");

        //单个数据的获取
        string name=table["班主任"].ToString();

        //遍历
        Console.WriteLine("职位\t\t姓名");
        foreach (object key in table.Keys)
        {
            string jian = key.ToString();
            string zhi = table[jian].ToString();
            Console.WriteLine(jian+"\t\t"+zhi);
        }

        //删除
        table.Remove("教员");
        table.Clear();

        //判断存在
        bool f1=table.ContainsKey(123);
        bool f2=table.ContainsValue(456);

        //获取所有的key
        //table.Keys;
        //获取所有的value
        //table.Values;
        Console.ReadLine();

泛型

1.泛型的标志：<>
2.泛型集合的特性：长度可变+各种类型都可以存放
3.泛型集合的特性：长度可变+只能存放声明的类型数据
4.泛型集合和普通集合不同之处
.普通集合：会将存入的数据全部转成object类型 所以取出来时需要进行类类转换
.泛型集合：不会对存入的数据进行类型转换

---

Two:深入类的方法

构造函数

1.作用：创建对象
2.语法特点：没有返回值并且也不能写void+方法名必须和类名一致 public 类名 (参数){方法体}
3.性能特点：
如果一个类当中没有任何构造函数则系统会自动分配无参构造
但是当类当中存在构造函数以后，系统会将默认分配的无参构造收回

方法重载:同名同类不同参

1.同名：方法名称相同
2.同类：方法定义在同一个类当中
3.不同参：参数列表不同（数量/类型/顺序）
4.判断方法重载：跟返回值和修饰符没有任何关系

---

Three:初始继承和多态

理解继承的概念

一、继承
1.子类->派生类 父类->基类
2.子类可以继承父类所拥有的属性、字段、方法(私有化的字段、属性、方法 子类无权继承)
3.子类和父类必须满足 子类
二、继承两大特性
1.传递性：父类->子类->子类的子类
2.单根性：每一个类只能有一个直接父类
三、this和base
1.this：指代当前类的对象
2.base：只带当前类父类的对象

熟练使用继承建立子类和父类

1.父类：定义共有的字段、属性、方法
2.子类：定义特有的字段、属性、方法
3.子类与父类之间必须符合 is a 的关系

理解多态的概念

1.多种形态，指同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果
2.同一个类在不同场合下表现出不同的行为特征
（方法重载也是实现多态性的一种方式。只不过重载的方法都在同一个类中，而用虚方法实现多态的方法分散在有继承关系的多个类中）

会重写虚方法实现多态

*虚方法 语法：
访问修饰符 virtual 返回值类型 方法名(){
//方法体
}
*方法重写 语法：
访问的修饰符 override 返回值类型 方法名(){
//方法体
}
1.重写：同名同参不同类，（权限不能缩小并且返回值相同）
2.重写：子类改造父类当中已经存在的方法的过程
3.虚方法使用virtual修饰
4.虚方法一般定义在父类当中，让子类选择性重写改造
5.虚方法不可以定义在密封类当中（sealed
（父类中定义的虚方法并非必须被子类重写。在父类中可给出虚方法的默认实现。如果子类不重写父类的虚方法，依然执行父类的默认实现；反之，则执行子类重写后的方法）

---

Four:深入理解多态

理解里氏替换原则

子类可以替换父类->在一个软件系统中，子类对象可以替换所有使用的父类对象，且程序行为没有变化（is进行类型判断，as进行类型转换）

会使用父类类型作为参数

父类作为参数使用，可接受多种子类类型

理解抽象类和抽象方法

**（使用抽象类、抽象方法可以优化程序）
一、抽象类
1.在生活中没有具体存在，概念性的东西称为抽象类
2.特点：
a.使用abstract修饰
b.抽象类不可以实例化对象
c.抽象类可以包含抽象方法和普通方法
二、抽象方法
1.使用abstract修饰
2.抽象方法没有方法体
3.抽象方法必须定义在抽象类当中
4.父类中的抽象方法要求子类必须强制重写（改造）

理解虚方法和抽象方法的区别

*一、虚方法

1. 使用virtual修饰
2. 不可以定义在密封类当中（sealed）
3. 子类可以自主选择是否重写
   二、抽象方法
4. 使用abstract修饰
5. 抽象方法没有方法体{ }
6. 抽象方法必须定义在抽象类当中
7. 父类当中的抽象方法要求子类必须强制重写（改造）*