C# class 基类 泛型 泛型的基类
时间: 2023-08-29 12:10:58 浏览: 32
在C#中,可以使用泛型来指定一个类的基类,同时也可以使用泛型约束来限制泛型类型参数的类型。通过泛型的基类和泛型约束,可以实现更加灵活和可复用的代码。
以下是一个示例代码,演示了如何定义一个泛型类,并指定其基类以及泛型约束:
```csharp
public class MyBaseClass
{
public void BaseMethod()
{
Console.WriteLine("BaseMethod called.");
}
}
public class MyGenericClass<T> : MyBaseClass where T : SomeType
{
public void GenericMethod(T item)
{
Console.WriteLine("GenericMethod called.");
// 可以访问 MyBaseClass 中的成员
BaseMethod();
// 可以使用 T 类型的参数 item 进行操作
Console.WriteLine($"Item: {item}");
}
}
```
在上面的示例中,`MyBaseClass` 是一个基类,`BaseMethod` 是其成员方法。`MyGenericClass<T>` 是一个泛型类,泛型类型参数 `T` 受到 `SomeType` 泛型约束限制,并且继承自 `MyBaseClass`。在 `MyGenericClass<T>` 中,可以访问 `MyBaseClass` 的成员方法,并且使用 `T` 类型的参数进行操作。
使用示例代码:
```csharp
MyGenericClass<int> instance = new MyGenericClass<int>();
instance.GenericMethod(42);
```
在上面的代码中,我们创建了一个 `MyGenericClass<int>` 的实例,并调用了 `GenericMethod` 方法,传入了整数类型的参数 `42`。输出结果如下:
```
GenericMethod called.
BaseMethod called.
Item: 42
```
总结起来,通过在泛型类中指定基类和泛型约束,可以使泛型类继承自指定的基类,并对泛型类型参数进行类型约束,提供更加灵活和可复用的代码。
相关推荐













Java泛型中的协变和逆变都是针对类型转换的规定。
协变(covariant):指的是继承链中子类(派生类)类型能够作为父类(基类)类型的一种属性,也就是子类可以作为父类使用的能力。在泛型中,协变的概念可以用来表示如果类型A是类型B的一个子类型,那么泛型类G就可以视作泛型类G的一个子类型。
例子:
java
// Animal类
public class Animal {}
// Dog类是Animal类的子类
public class Dog extends Animal {}
// 泛型接口List
public interface List<E> {
void add(E e);
E get(int index);
}
// 定义一个方法acceptList,其形参类型为List<? extends Animal>
public static void acceptList(List<? extends Animal> list) {
for (Animal animal : list) {
// ...
}
}
// List类型为List<Dog>
List<Dog> list = new ArrayList<Dog>();
list.add(new Dog());
acceptList(list); // 在这里,我们可以传入一个List<Dog>参数,因为Dog类是Animal类的子类
逆变(contravariant):指的是继承链中父类(基类)类型能够作为子类(派生类)类型的一种属性,也就是父类可以作为子类使用的能力。在泛型中,逆变的概念可以用来表示如果类型A是类型B的一个超类型,那么泛型类G就可以视作泛型类G的一个子类型。
例子:
java
// Animal类
public class Animal {}
// Dog类是Animal类的子类
public class Dog extends Animal {}
// 泛型接口Comparator
public interface Comparator<T> {
int compare(T o1, T o2);
}
// 定义一个方法sortList,其形参类型为List<? super Dog>
public static void sortList(List<? super Dog> list) {
// ...
}
// List类型为List<Animal>
List<Animal> list = new ArrayList<Animal>();
list.add(new Animal());
sortList(list); // 在这里,我们可以传入一个List<Animal>参数,因为Animal类是Dog类的超类型
extends和super关键字常常用于定义泛型类型参数的上边界(upper bound)和下边界(lower bound)。extends表示类型参数的上限,超过这个范围就会导致编译错误;super表示类型参数的下限,超过这个范围也会导致编译错误。
例子:
java
// 泛型类Pair,其类型参数T有上限(用extends)为Comparable<? super T>,表示类型T要么是Comparable<? super T>本身,要么是Comparable<? super T>的子类型
public class Pair<T extends Comparable<? super T>> {
private T first;
private T second;
public Pair(T first, T second) {
this.first = first;
this.second = second;
}
public T getFirst() {
return first;
}
public T getSecond() {
return second;
}
public T max() {
return first.compareTo(second) >= 0 ? first : second;
}
}
// Pair类型为Pair<String>
Pair<String> pair = new Pair<String>("hello", "world");
String max = pair.max(); // 在这里,我们可以调用max方法,因为String类实现了Comparable<String>接口



