C# 协变逆变(泛型修饰符in和out)


in和out用在范型interface和delegate中, 用来支持逆变和协变(in是逆变,out是协变)。协变保留赋值兼容性,逆变与之相反。


下例中,泛型接口类型参数T有out修饰符,所以 
a) 支持协变,ITest<Base> b = new D(); 可以编译通过,而ITest<Derive> d = new B();出错;
b) T类型只能用过函数返回值,故 T GetInstance(); 编译通过,而 void ShowMe(T obj); 出错;


如果是改为in修饰符,则支持逆变,上述情况相反!


in和out泛型修饰符只能用在泛型接口和泛型委托里面,这样的泛型接口和泛型委托称为变体。

    class Base
    {
        
    }

    class Derive : Base
    {
        
    }

    interface ITest<out T>
    {
        T GetInstance();
<span style="white-space:pre">	</span>void ShowMe(T obj);
    }

    class D : ITest<Derive>
    {
        
    }

    class B : ITest<Base>
    {
        
    }

    class Program
    {
        private static void Main(string[] args)
        {
            ITest<Derive> d = new B();
            ITest<Base> b = new D();
        }
    }



.Net中典型的变体:
public delegate TResult Func<out TResult>();// TResult类型是返回值类型
public delegate TResult Func<in T, out TResult>(T arg); //输入类型T,返回类型TResult
public interface IEnumerable<out T> : IEnumerable // T只出现在返回类型中
public interface IEnumerator<out T> : IDisposable, IEnumerator
public class List<T> : IList<T>, ICollection<T>, IList, ICollection, IReadOnlyList<T>, IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable // 实现变体接口IEnumerable<T>
public class Queue<T> : IEnumerable<T>, ICollection, IEnumerable //  实现变体接口 IEnumerable<T>





  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Kotlin中的泛型是一种类型变量的机制,它允许我们在不确定具体类型的情况下编写通用代码。Kotlin中的泛型支持协变逆变,以及in和out的关键字。 首先,我们来看一个简单的例子,实现一个泛型容器类: ```kotlin class Container<T>(var item: T) { fun getItem(): T { return item } } fun main() { val container = Container<String>("Hello") println(container.getItem()) } ``` 在这个例子中,我们定义了一个名为Container的泛型类,它有一个类型参数T。我们可以创建一个Container实例,并将其实例化为一个具体类型。我们使用getItem方法来获取这个容器中的item。 接下来,我们来介绍一下协变逆变。假设我们有两个类: ```kotlin open class Animal { fun makeSound() { println("Making animal sound") } } class Cat: Animal() { fun meow() { println("Meow") } } ``` 我们可以通过一个简单的示例来说明协变逆变: ```kotlin fun main() { val animals: List<Animal> = listOf(Cat(), Animal()) makeSounds(animals) } fun makeSounds(animals: List<Animal>) { for (animal in animals) { animal.makeSound() } } ``` 在这个例子中,我们定义了一个List<Animal>类型的变量animals,它包含了一个Cat和一个Animal实例。我们将这个变量传递给了makeSounds函数,该函数接受一个List<Animal>类型的参数。 在makeSounds函数中,我们使用for循环遍历animals列表,并对其中的每个Animal实例调用makeSound方法。由于Cat是Animal的子类,因此它也可以被视为Animal类型,因此我们可以将其添加到List<Animal>类型的变量中。 这里的List<Animal>类型就是协变的,因为我们可以将它的子类(如Cat)作为参数传递给makeSounds函数。 现在我们来看一下逆变。假设我们有一个接受Animal类型的参数的函数: ```kotlin fun takeAnimal(animal: Animal) { animal.makeSound() } ``` 我们可以将这个函数传递给另一个函数,该函数期望一个Cat类型的参数。在这种情况下,我们可以使用in关键字来表示逆变: ```kotlin fun main() { val cat: Cat = Cat() takeCat(cat) } fun takeCat(cat: Cat) { takeAnimal(cat) } fun takeAnimal(animal: Animal) { animal.makeSound() } ``` 在这个例子中,我们定义了一个takeCat函数,它接受一个Cat类型的参数。我们将这个函数传递给了takeAnimal函数,该函数期望一个Animal类型的参数。由于Cat是Animal的子类,因此我们可以将Cat类型的参数传递给takeAnimal函数。这里的takeAnimal函数是逆变的,因为它可以接受其超类型(如Animal)的参数。 最后,我们来看一下out和in关键字。我们可以在定义泛型类型参数时使用这些关键字来限制泛型类型参数的使用方式。out关键字用于声明泛型类型参数是协变的,in关键字用于声明泛型类型参数是逆变的。 例如,我们可以定义一个只允许读取的泛型接口: ```kotlin interface ReadOnlyContainer<out T> { fun getItem(): T } ``` 在这个例子中,我们使用out关键字来声明泛型类型参数T是协变的。这意味着我们只能从ReadOnlyContainer接口中获取T类型的值,而不能修改它。这样做的好处是可以使我们更加安全地使用泛型类型参数。 类似地,我们可以定义一个只允许写入的泛型接口: ```kotlin interface WriteOnlyContainer<in T> { fun setItem(item: T) } ``` 在这个例子中,我们使用in关键字来声明泛型类型参数T是逆变的。这意味着我们只能向WriteOnlyContainer接口中设置T类型的值,而不能获取它。这样做的好处是可以避免意外修改泛型类型参数的值。 总结一下,Kotlin中的泛型支持协变逆变,以及in和out关键字。使用协变逆变可以使我们更加灵活地使用泛型类型参数,而使用in和out关键字可以帮助我们更加安全地使用泛型类型参数。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值