C#笔记（4） - 技术栈

方法的定义与使用：

定义规范

访问修饰符返回值类型方法名（参数1，参数2......)

{

//这里编写方法的主体（功能实现的具体过程）

Return 返回值;//如果没有返回值，则不需要写该语句

}

使用规范
1. 对象名.方法名(参数1，参数2......);
注意事项：
1. 访问修饰符：默认private、不建议省略，可以根据需要定义成public。
2. 方法名定义：一般是"动词"或者"动宾短语"，采用的Pascal命名法，首字母大写，不能以数字开头。
3. 方法的参数：根据需要添加，也可以没有。
4. 方法返回值：使用return返回，return表示方法结束了，它后面不能再有其他的语句。
5. 没有返回值：如果不返回任何数据，使用void表示。

实例方法的5种形式：

没有返回值，没有参数的方法
没有返回值，有参数
有返回值，没有参数
有返回值，有参数
参数带默认值的方法

静态方法：

调用的时候是通过类名.方法名调用，程序运行的时候直接占用内存，不需要初始化对象存内存

1. 特点：1、生命周期...一旦创建..应用结束才会结束。2、全局。3、效率高
2. 用处：用户登录信息、系统配置信息、系统设置、SQLHelper
3. 注意：静态的东西创建多了占用内存会很大，非必要情况不要创建静态的对象

调用：静态方法调用非静态方法，不能直接调用，把所在类初始化后再调用

关键字static的使用
1. 关键字可以修饰类、方法、成员变量，修饰后我们称为：静态类、静态方法、静态字段
静态方法的调用
1. 类名.方法名
静态成员使用经验：
1. 静态成员在程序运行时被调入内存中，并且在系统未关闭之前不会被GC回收。
2. 类的成员使用非常频繁时候，可以考虑使用static修饰，但不要使用过多
3. 静态成员不能直接调用实例成员（静态方法不能直接调用实例方法）
4. 静态方法也可以重载

方法重载：

重载是方法名不变，参数列表（参数类型或个数）不同的方法体现。

注意：返回值可以相同也可以不同。当参数个数相同而参数类型不同的时候，可以考虑使用泛型，提高代码的复用性。
好处：
1. 减少类的对外接口（只显示一个方法）、降低类的复杂度
2. 便于用户使用（相同功能的方法名称引用）和识别度
条件：
1. 方法名必须一样
2. 方法的参数个数或类型不一样
无关性
1. 方法重载与返回值无关

泛型：

泛型是一种强大的编程特性，它允许你编写可以适应不同数据类型的代码，同时在编译时确保类型安全。表示一种程序特性，也就是我们在定义的时候，无需指定特定的类型，而在使用的时候，我们必须明确类型。

泛型的定义和使用
1. 泛型类
  - 可以定义泛型类，例如：class MyGenericClass<T> { }，这里的T是类型参数，可以在使用这个类的时候指定具体的类型。
  - 可以在泛型类中使用类型参数来定义成员变量、方法参数和返回值类型等。

泛型方法
- 可以在非泛型类中定义泛型方法，如：public static void MyGenericMethod<T>(T parameter) { }。
- 调用泛型方法时，编译器会根据传入的参数类型自动推断出类型参数的值。

泛型集合：

1、集合：定义的时候，无需规定元素的个数

2、泛型：表示一种程序特性，也就是我们在定义的时候，无需指定特定的类型，而在使用的时候，我们必须明确类型

3、应用：集合中、方法中、类中

表示<T> List<T>

要求：添加到集合中的元素类型，必须要和泛型集合定义时规定的数据类型完全一致

比较强接口：IComparer<T>

代码实例：

cs 复制代码

public class Coure:IComparable<Coure>

    {

        //构造函数要跟类名一样

        public Coure() { }

        public Coure(int courseId, string courseName, int classHour, string testchae)

        {

            this.CourseifId = courseId;

            this.CoureId = courseName;

            this.ClassHour = classHour;

            this.Teacher = testchae;

        }

        public int CourseifId { get; set; }

        public string CoureId { get; set; }

        public int ClassHour { get; set; }

        public string Teacher { get; set;}



        //接口对应的比较方法

        public int CompareTo(Coure other)

        {

            return this.CourseifId.CompareTo(other.CourseifId);

            //如果把this放到前面，表示按照升序排列，other在前面就是按照降序排列

        }

    }

    

    class TestGenericList

    {

        #region 泛型集合

        public static void CreateCourses()

        {

            Coure coure1 = new Coure();

            coure1.CourseifId = 1;

            coure1.CoureId = ".Net";

            coure1.ClassHour = 1;

            coure1.Teacher = "x";

            Coure coure2 = new Coure(2,"C#",2,"c");

            Coure coure3 = new Coure(3,"C#",3,"c");

            Coure coure4 = new Coure(4,"C#",4,"c");

            Coure coure5 = new Coure(5,"C#",5,"c");



            //数组方法

            Coure[] coures = new Coure[] { coure1, coure2, coure3, coure4, coure5 };



            foreach (var coure in coures)

            {

                Console.WriteLine(coure.CourseifId+coure.CoureId+coure.ClassHour+coure.Teacher);

            }



            //泛型集合

            //集合：定义的时候，无需规定元素的个数

            //泛型：表示一种程序特性，也就是我们在定义的时候，无需指定特定的类型，而在使用的时候，我们必须明确类型

            //应用：集合中、方法中、类中

            //表示<T>  List<T>

            List<Coure> ts = new List<Coure> { coure1, coure2, coure3, coure4, coure5 };

            //ts.Add(coure1);

            //ts.Add(coure2);

            //ts.Add(coure3);

            //ts.Add(coure4);

            //ts.Add(coure5);

            foreach(var coure in ts)

            {

                Console.WriteLine(coure.CourseifId + coure.CoureId + coure.ClassHour + coure.Teacher);

            }

            //通过有参数的构造函数的方法创建对象

            Coure cour = new Coure(1001, ".net", 200, "C#");

        }

        #endregion



        #region 遍历泛型集合和快速查询

        public void TraversaList1(List<Coure> couresList)

        {

            for (int i = 0; i < couresList.Count; i++)

            {

                Console.WriteLine("CourseifId:"+couresList[i].CourseifId + "CoureId:"+ couresList[i].CoureId + "ClassHour:"+ couresList[i].ClassHour + "Teacher:"+ couresList[i].Teacher);

            }

        }



        public void TraversaList2(List<Coure> couresList)

        {

            foreach(var coure in couresList)

            {

                Console.WriteLine(coure.CourseifId + coure.CoureId + coure.ClassHour + coure.Teacher);

            }

        }



        /// <summary>

        /// 集合快速查询方法

        /// </summary>

        /// <param name="couresList"></param>

        public void QueryElements(List<Coure> couresList)

        {

            //集合查询方法1

            var result1 = couresList.FindAll(c=>c.CourseifId>3);



            //集合查询方法2

            var result2 = from c in couresList where c.CourseifId > 3 select c;

            var result3 = result2.ToList();

        }

        #endregion



        #region 集合元素排序

        //值类型集合元素排序

        public  void ListOrder()

        {

            List<int> ageList = new List<int> { 23, 22, 19, 30, 26 };

            ageList.Sort();

            Coure coure1 = new Coure();

            coure1.CourseifId = 7;

            coure1.CoureId = ".Net";

            coure1.ClassHour = 1;

            coure1.Teacher = "x";

            Coure coure2 = new Coure(2, "C#", 2, "c");

            Coure coure3 = new Coure(3, "C#", 3, "c");

            Coure coure4 = new Coure(4, "C#", 4, "c");

            Coure coure5 = new Coure(5, "C#", 5, "c");

            //对象集合元素排序

            List<Coure> couresList = new List<Coure> { coure1, coure2, coure3, coure4, coure5 };

            couresList.Sort();//会报错，所以在Course类中实现系统接口IComparable<Course>

            Console.WriteLine("CourseifId升序排列");

            TraversaList1(couresList);

            //以上我们使用默认比较器进行排序，很不方便，如果我们需要多种排序，怎么办？



            //比较器接口：其实就是我们可以任意的指定对象属性排序，从而实现动态排序。

            //动态排序

            //排序方法的定义： public void Sort(IComparer<T> comparer)();

            //传递接口的实现类，CourseifId升序

            couresList.Sort(new CourseIdASC());

            Console.WriteLine("CourseifId升序");

            TraversaList1(couresList);

            //传递接口的实现类，CourseifId降序

            couresList.Sort(new CourseIdDESC());

            Console.WriteLine("CourseifId降序");

            TraversaList1(couresList);

            //传递接口的实现类，ClassHour升序

            couresList.Sort(new CourseClassASC());

            Console.WriteLine("ClassHour升序");

            TraversaList1(couresList);

        }



        #endregion







        #region 自定义排序类：根据需要，添加对应个数的排序类



        //比较强接口：IComparer<T>

        /// <summary>

        /// CourseifId升序

        /// </summary>

        class CourseIdASC : IComparer<Coure>

        {

            public int Compare(Coure x, Coure y)

            {

               return x.CourseifId.CompareTo(y.CourseifId);

            }

        }

        /// <summary>

        /// CourseifId降序

        /// </summary>

        class CourseIdDESC : IComparer<Coure>

        {

            public int Compare(Coure x, Coure y)

            {

                return y.CourseifId.CompareTo(x.CourseifId);

            }

        }

        /// <summary>

        /// 课时升序

        /// </summary>

        class CourseClassASC : IComparer<Coure>

        {

            public int Compare(Coure x, Coure y)

            {

                return x.ClassHour.CompareTo(y.ClassHour);

            }

        }

        #endregion

    }