方法的定义与使用：
- 定义规范
访问修饰符 返回值类型 方法名（参数1，参数2......)
{
//这里编写方法的主体（功能实现的具体过程）
Return 返回值;//如果没有返回值，则不需要写该语句
}
- 使用规范
- 对象名.方法名(参数1，参数2......);
- 注意事项：
- 访问修饰符：默认private、不建议省略，可以根据需要定义成public。
- 方法名定义：一般是”动词“或者”动宾短语“，采用的Pascal命名法，首字母大写，不能以数字开头。
- 方法的参数：根据需要添加，也可以没有。
- 方法返回值：使用return返回，return表示方法结束了，它后面不能再有其他的语句。
- 没有返回值：如果不返回任何数据，使用void表示。
实例方法的5种形式：
- 没有返回值，没有参数的方法
- 没有返回值，有参数
- 有返回值，没有参数
- 有返回值，有参数
- 参数带默认值的方法
静态方法：
调用的时候是通过类名.方法名调用，程序运行的时候直接占用内存，不需要初始化对象存内存
-
- 特点：1、生命周期...一旦创建..应用结束才会结束。2、全局。3、效率高
- 用处：用户登录信息、系统配置信息、系统设置、SQLHelper
- 注意：静态的东西创建多了占用内存会很大，非必要情况不要创建静态的对象
调用：静态方法调用非静态方法，不能直接调用，把所在类初始化后再调用
- 关键字static的使用
- 关键字可以修饰类、方法、成员变量，修饰后我们称为：静态类、静态方法、静态字段
- 静态方法的调用
- 类名.方法名
- 静态成员使用经验：
- 静态成员在程序运行时被调入内存中，并且在系统未关闭之前不会被GC回收。
- 类的成员使用非常频繁时候，可以考虑使用static修饰，但不要使用过多
- 静态成员不能直接调用实例成员（静态方法不能直接调用实例方法）
- 静态方法也可以重载
方法重载：
重载是方法名不变，参数列表（参数类型或个数）不同的方法体现。
- 注意：返回值可以相同也可以不同。当参数个数相同而参数类型不同的时候，可以考虑使用泛型，提高代码的复用性。
- 好处：
- 减少类的对外接口（只显示一个方法）、降低类的复杂度
- 便于用户使用（相同功能的方法名称引用）和识别度
- 条件：
- 方法名必须一样
- 方法的参数个数或类型不一样
- 无关性
- 方法重载与返回值无关
泛型：
泛型是一种强大的编程特性，它允许你编写可以适应不同数据类型的代码，同时在编译时确保类型安全。表示一种程序特性，也就是我们在定义的时候，无需指定特定的类型，而在使用的时候，我们必须明确类型。
- 泛型的定义和使用
- 泛型类
- 可以定义泛型类，例如：class MyGenericClass<T> { }，这里的T是类型参数，可以在使用这个类的时候指定具体的类型。
- 可以在泛型类中使用类型参数来定义成员变量、方法参数和返回值类型等。
- 泛型类
- 泛型方法
- 可以在非泛型类中定义泛型方法，如：public static void MyGenericMethod<T>(T parameter) { }。
- 调用泛型方法时，编译器会根据传入的参数类型自动推断出类型参数的值。
泛型集合：
1、集合：定义的时候，无需规定元素的个数
2、泛型：表示一种程序特性，也就是我们在定义的时候，无需指定特定的类型，而在使用的时候，我们必须明确类型
3、应用：集合中、方法中、类中
表示<T> List<T>
- 要求：添加到集合中的元素类型，必须要和泛型集合定义时规定的数据类型完全一致
比较强接口：IComparer<T>
代码实例：
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
}