C#List单列集合、字典集合、抽象类、接口、密封类、部分类

•List单列集合:

internal class Program
{
    static void Main(string[] args)
    {
        //List类: 单列集合, 同时他是带有泛型的集合, 并且该集合还有索引, 同时他还是有序的

        //第一步:先创建Liat集合对象
        List<int> list = new List<int>();

        //第二步:使用它,使用常用的属性和方法
        Console.WriteLine("List集合的数量为:" + list.Count);//0
        Console.WriteLine("List集合的容量为:" + list.Capacity);//0

        // 变量名.Add()  存储数据
        list.Add(123);
        //扩容机制:首次扩容为4,其他次每次扩容为原来长度的2倍
        Console.WriteLine("存储数据后List集合的容量为:" + list.Capacity);//4

        list.Add(10);
        list.Add(17);
        list.Add(20);
        list.Add(100);
        list.Add(200);

        // 变量名.AddRange()  批量添加元素
        int[] ints1 = { 1, 2, 3, 4, 5 };
        list.AddRange(ints1);

        // 变量名.Insert()  在指定 索引的位置插入 数据
        list.Insert(1, 777);

        //  变量名[索引值]  获取里面的数据  是以数组的形式来获取数据
        //获取第三个位置上的数据:（索引2）
        Console.WriteLine("第三个数据为:" + list[2]);

        // 变量名.Remove()  删除List中第一个匹配指定值的元素
        list.Remove(17);

        // 变量名.RemoveAt()  删除指定索引位置的数据
        list.RemoveAt(1);

        // 变量名.RemoveRange()  删除指定范围的数据,参数一开始的索引位置,参数二删除的个数
        //list.RemoveRange(0, 1);


        //高阶函数
        // 变量名.RemoveAll()  批量删除所有符合条件元素
        //Predicate 谓词
        list.RemoveAll(Find);
        Console.WriteLine("经过RemoveAll删除之后");
        foreach (var item in list)
        { Console.WriteLine(item); }

        //Lambda表达式 本质上是匿名函数 (没有名字的函数)
        //语法格式: (参数名称) => {}; --->函数式编程
        //如果{}里面只有一行语句,那么可以再次简化:() => 一个语句(return省略不写)
        //list.RemoveAll((x) => { return x % 2 == 0; });
        //list.RemoveAll((x) => x % 2 == 0);

        list.Add(10);
        list.Add(17);
        list.Add(35);
        list.Add(571);
        list.Add(200);

        // 变量名.Find()  查找第一个符合条件元素,返回值：找到则返回该元素，未找到则返回 T 的默认值
        list.Find((x) => x % 2 != 0);

        // 变量名.FindAll()  按条件批量查找元素,返回一个包含所有匹配元素的新 List<T>，且不会修改原集合
        List<int> list2 = list.FindAll((x) => x % 2 != 0 && x > 100);

        // 变量名.Exists()  判断集合中是否存在符合条件元素,最终返回 bool 值
        bool ex = list.Exists((x) => x == 123);
        Console.WriteLine("123是否在List集合中:" + ex);

        // 变量名.Contains()  判断集合是否包含指定元素 有则返回true  没有返回false
        list.Contains(1);

        // 变量名.Reverse()  反转元素顺序
        list.Reverse();

        // 变量名.ToArray()  转换为数组
        int[] numArray = list.ToArray();

        // 变量名.ForEach()  遍历集合、对每个元素执行指定操作
        Console.WriteLine("ForEach()遍历");
        list.ForEach((x) => Console.WriteLine(x));

        // 变量名.Clear()  清空所有元素，并将Count重置为0但不会改变底层数组的容量
        list.Clear();

    }
    //静态环境中只能直接使用静态信息(不能直接使用非静态信息)
    //非静态环境中既可以使用静态信息,也可以使用非静态信息
    //凡是由static修饰的环境,我们称之为静态环境(区间)

    //定义一个静态方法，符合Predicate<int>委托规则，判断偶数
    static public bool Find(int x)
    {
        return x % 2 == 0;
    }
}

•字典集合Dictionary:

 //Dictionary 字典集合 双列集合 泛型集合
 //我们需要在字典集合中存储数据时是存储一对值
 //左边的值我们称之为键(Key)(目录/索引)
 //右边的值我们称之为值(Value)
 //键和值两者之间是一一映射的
 //键是不允许重复的,值是可以重复的
 //键是不能为空(null),值是可以为空(null)
 //字典 类似于List，只能 存储 固定类型 的数据，长度不固定

 //第一步:先创建字典集合对象
 //格式:
 //Dictionary<键的数据类型,值的数据类型> 变量名 = new Dictionary<键的数据类型,值的数据类型>() {};
 Dictionary<string, int> dict = new Dictionary<string, int>() { };

 //第二步:使用字典集合:常用的属性和方法

 // 变量名.Add()  向字典添加键值对（Key-Value）
 dict.Add("A", 123);
 dict.Add("B", 125);
 dict.Add("C", 128);

 // 变量名.Count  实际存储的键值对（Key-Value）个数
 Console.WriteLine(dict.Count);//3

 // 字典名称[Key]  通过键获取值 类似与数组的方式 
 Console.WriteLine(dict["B"]);//125

 // 变量名.Remove()  删除元素, 通过Key键进行删除, 删除一对值(Key和value)
 dict.Remove("A");//true

 // 变量名.ContainsKey()  查找字典中是否拥有指定key键
 Console.WriteLine(dict.ContainsKey("吴"));//False

 // 变量名.ContainsValue  判断字典中是否拥有指定的value值
 Console.WriteLine(dict.ContainsValue(123));//false

 // 使用属性Keys---->会把字典集合中所有的key全部获取到
 Dictionary<string, int>.KeyCollection keys = dict.Keys;
 //遍历集合
 Console.WriteLine("dict字典集合中所有的Key依次为:");
 foreach (string key in keys)
 { Console.WriteLine(key + "--->" + dict[key]); }

 // 使用属性Values---->会把字典集合中所有的Value值全部获取到
 Dictionary<string, int>.ValueCollection values = dict.Values;
 //遍历集合
 Console.WriteLine("dict字典集合中所有的Value值依次为:");
 foreach (int val in values)
 { Console.WriteLine(val); }

 // 变量名.ContainsValue()  判断是否存在指定值（Value）, 返回 bool值
 dict.ContainsValue(123);

 //通过键修改值
 //把键为B的值修改为100
 dict["B"] = 100;

 //字典作用:一般用于记录一些信息，用字典存储的数据，可以加快查询的速度

•抽象类abstract：

internal class Program
{
    static void Main(string[] args)
    {
        //抽象类 主要是想要 在类中去 定义抽象方法
        //抽象方法: 使用 abstract关键字 修饰的方法 就叫做抽象方法
        //抽象方法 是没有方法体, 结尾不以{}结尾, 而是以;结尾
        //抽象方法 一般我们 定义在 抽象类(接口), 普通类是 不允许定义抽象方法的
        //当我们在类中定义方法,如果该不需要方法体,只需要声明一个方法格式,你们此方法可以被定义为一个抽象方法
        //如果该方法是需要被重写的，那么我们可以把该方法定义成抽像方法。
        //抽象类一般情况下都有子类的,作为父类使用

        //语法格式:
        //抽象类的定义 格式: public abstract class 抽象类名 {}
        //抽象方法的定义 格式: public abstract 返回值类型 方法名称 (参数列表);

        /*
         * 抽象类的特点：
         * 1. 抽象类需 要使用 abstract关键字修饰 
         * 2. 在抽象类中的 抽象成员，都使用 关键字abstract修饰，该成员包括 属性和方法，抽象方法是 不能含有 方法体内容，以;作为结束，属性是 不能有初始值，也就是后面不能添加=
         * 3. 抽象成员 一定要定义抽象类中，非抽象类一般是不能定义抽象成员。
         * 4. 抽象类 不能直接实例化，意思是 不能直接创建对象
         * 5. 抽象类中 是有构造方法，并且还可以 重载。主要是给 子类使用的
         * 6. 子类继承抽象类后，子类就需要 重写父类中的抽象成员，和所有的抽象成员
         * 7. 抽象成员 不能使用 private关键字修饰
         * 8. 在抽象类中也可以定义普通成员信息，比如字段，属性，方法
         * 9. 子类在重写抽象方法时，必须和父类中定义的抽象方法格式完全一样
         * 10. 在抽象类中也可以定义虚方法。
         */
    }
}
//定义抽象类
public abstract class People
{
    //抽象类 中可以定义 抽象方法
    //又叫 纯虚方法
    //用 abstract关键字修饰的方法
    //特点:
    //1.只能在抽象类中申明
    //2.没有方法体
    //3.不能是私有的
    //4.继承后必须实现 用override重写
    //5.抽象方法 不可以 也不需要 拥有内容
    public abstract void Study(string content);

}
//定义People抽象类的子类
public class Student : People
{
    //子类继承父类,如果父类中有抽象方法,那么父类中的抽象方法一般情况下是要被重写的
    //如果没有被重写,那么此处代码会报语法错误

    //重写父类中的抽象方法
    public override void Study(string content)
    { Console.WriteLine("好好学习"); }
}
//普通类
public class Person { }

•接口interface：

internal class Program
{
    static void Main(string[] args)
    {
        /*
         * 什么是接口? 在程序当中使用 interface定义的类 就是接口类
         * 在接口当中，一般我们认为 接口中的成员 都是抽象的。
         * 接口一般认为是功能的集合，在接口类 当中的成员 都是抽象方法。
         * 接口一般我们理解成一种规范，一种标准，一种约束。
         * 主要是给子类(派生类)使用的
         * 当子类 继承了接口类，那么就需要 重写接口类 中定义的所有的抽象方法, 重写就意味着需要在子类中添加方法的具体实现(带有方法体内容)
         */

        // 定义一个接口:  接口的名字一般以 I 开头
        // 格式：interface 接口的名称 {成员}

        /*
         * 接口的特点：
         * 1.接口类中 没有构造方法，也不能进行重载，所以接口更不能进行实例化
         * 2.接口类中的成员，不能添加任何修饰符，默认的修饰符是public ,abstract
         * 3.接口中的成员 不能与任何的实现，属性 不能有初始值，方法 不能有 方法体 以分号作结尾
         * 4.接口类中 不能定义字段信息，一般最多 定义属性和方法
         * 5.接口类 与接口类 之间可以 多继承。并且一个class类也可以 同时继承多个接口类
         * 6.接口类 不能继承 class声明的类，但是class声明的类 可以继承interface声明的接口类
         * 7.一个class类 在继承 一个class类的同时，还可以 继承多个interface声明的接口类，但是 前提是 继承class类在前，interface在后。
         * 8.如果一个 抽象类继承了 一个接口类,那么在抽象类中也需要去 重写继承过来的抽象方法。public ,private
         * 9.如果一个class类继承了多个接口类，这多个接口类中有重名的方法。会不会产生程序异常?(不会)。可以进行重写，继承了几个就可以重写几个,但是会变成私有的,需要接口的显示重写。  
         */
    }
}
//定义一个接口类
public interface IUSB
{
    //抽象方法的定义格式:public abstract 返回值类型 方法名称(参数列表);
    /*public abstract*/
    void Connection();
    // 定义充电功能
    void Charging();
}
public class Mouse : IUSB
{
    public /*override*/ void Connection() { }
    public void Charging() { }
}

public interface MyInterface1 { }
public interface MyInterface2 { }
public interface MyInterface3 { }
public interface MyInterface4 { }

// 接口是可以多继承的
public interface MyInterface5 : MyInterface1, MyInterface2, MyInterface3, MyInterface4 { }

// class类是可以同时继承 多个接口类的
public class Myclass : MyInterface1, MyInterface2, MyInterface3 { }

//单根性:只是对于class类来说的，意思是一个class类只能同时继承一个class类个引用
public class class1 { }
public class class2 { }
public class class3 { }

//一个class类可以在继承一个class类的同时又可以继承interface定义的接囗类
//备注:class类在前，interface类在后
public class class4 : class1, MyInterface3 { }

•密封类sealed:

//密封类 主要 限制继承特性，当定义一个密封类的时候，就代表着 这个类没有子类。
//密封类 虽然不能有子类，但是它可以 继承其他类，也就是它可以 作为子类使用。

//密封方法本质:用密封关键字sealed 修饰的重写函数
//作用:让虚方法或者抽象方法之后不能再被重写
//特点: sealed不能单独使用,和override一起出现
public class GrandFather { }

// 定义成密封类
public sealed class Father : GrandFather
{
    public /*virtual*/ void WriteBook()
    { Console.WriteLine("书的思想很伟大!!"); }
}
public class Son /*: Father*/
{
    //public override void WriteBook()
    //{
    //    Console.WriteLine("书的思想不伟大");
    //}
}

•部分类Partial :

internal class Program
 {
     static void Main(string[] args)
     {
         /*
          *  部分类：
          *  我们一般情况下在定义的时候，可以选择先定义类的一部分信息，可以在不同的空间中去多次定义该类的成员信息。
          *  这多个部分类共同组成了一个类
          *  部分类中定义所有成员，可以被所有声明的该部分类所共享。即便成员信息是是私有的，也可以被共享
          */
         Person person = new Person();
         person.Phone = 13833894338L;
         Console.WriteLine(person.Phone);
     }
 }
 public partial class Person
 {
     private int _id;
     private string _name;
     public int Id { get { return _id; } set { _id = value; } }
     public string Name { get { return _name; } set { _name = value; } }
     public Person() { }
     public Person(int id, string name)
     {
         _id = id;
         _name = name;
     }
 }
//创建一个新的类Class1  下面是新类中的代码
internal class Class1 { }
public partial class Person
{
    private long _phone;
    public long Phone { get { return _phone; } set { _phone = value; } }
}