泛型示例

原代码：只对 int[] 进行排序，现增加需求对int[]，byte[] ，char[] 及类中某些字段（price）等进行排序

public class SortHelper{
public void BubbleSort(int[] array) {
int length = array.Length;
for (int i = 0; i <= length - 2; i++) {
for (int j = length - 1; j >= 1; j--) {
// 对两个元素进行交换
if (array[j] < array[j - 1] ) {
int temp = array[j];
array[j] = array[j - 1];
array[j - 1] = temp;
}
}
}
}
}

解决方案1：使用泛型类

public class SortHelper<T> where T: IComparable  //泛型约束
{
public void BubbleSort(T[] array) {
int length = array.Length;
for (int i = 0; i <= length - 2; i++) {
for (int j = length - 1; j >= 1; j--) {
// 对两个元素进行交换
//注意此处不可用array[j]<array[j - 1]
//因为对于T类型（未知类型）不确定能用<进行比较大小
if (array[j].CompareTo(array[j - 1])<0) 
{
T temp = array[j];
array[j] = array[j - 1];
array[j - 1] = temp;
}
}
}
}
}

解决方案2：使用泛型方法

//Book[] bookArray = new Book[2];
//bookArray[0] = new Book(30, "HTML5解析");
//bookArray[1] = new Book(21, "JavaScript实战");
//SortHelper calculator = new SortHelper();
//calculator.SpeedSort<Book>(bookArray);
//编译器可以推断出传递的数组类型，以及是否满足了泛型约束
//即可以简化成calculator.SpeedSort(bookArray);

public class SortHelper{
// CODE：其他实现略
public void SpeedSort<T>(T[] array) where T : IComparable {
// CODE：实现略
}
}

某一个需要进行比较的类

public class Book :IComparable{
privateint price;
private string title;
public Book() { }
public Book(int price, string title) {
this.price = price;
this.title = title;
}
public int Price { get { return this.price; } }
public string Title { get { return this.title; } }
//继承IComparable接口进行比较，注意： 此处向下转换破坏了设计模式中Liskov替换原则
public int CompareTo(object obj) {
Book book2 = (Book)obj;
//int也继承了IComparable接口
return this.Price.CompareTo(book2.Price);
}
}

Liskov替换原则：
关于这个原则这里无法进行专门的讲述，只能简单提一下：这个原则要求方法内部不应该对方法所接受的参数进行向下的强制转换。为什么呢？定义继承体系的目的就是为了代码通用，让基类实现通用的职责，而让子类实现其本身的职责，当定义了一个接受基类的方法时，设计本身是优良的，但是当在方法内部进行强制转换时，就破坏了这个继承体系，因为尽管方法的签名是面向接口编程的，方法的内部还是面向实现编程的。

猜你喜欢