当前位置：首页 > news >正文

wordpress返回首页一直加载武汉seo报价

news 2026/4/7 3:18:00

wordpress返回首页一直加载,武汉seo报价,东莞疫情分布图最新情况,深圳营销型网站定制回答重点 Java泛型的上下界限定符用于对泛型类型参数进行范围限制，主要有上界限定符和下届限定符。 1）上界限定符 (? extends T)： 定义：通配符?的类型必须是T或者T的子类，保证集合元素一定是T或者T的子类作用&…

回答重点

Java泛型的上下界限定符用于对泛型类型参数进行范围限制，主要有上界限定符和下届限定符。

1）上界限定符 (? extends T)：

定义：通配符?的类型必须是T或者T的子类，保证集合元素一定是T或者T的子类
作用：通常用于读取操作，通配符?类型必须是T/T的子类，然后集合元素也必须是T/T的子类，所以读取是安全的，然而并不能确定到底是哪个类，需要强转类型，强转都不知道转成什么，所以写入是不安全的（可以写入null）

public void process(List<? extends Number> list){// Number是Integer的父类Number num = list.get(0); // 读取是安全的，返回类型是Number或其子类// list.add(1; // 编译错误，不确定泛型的类型}

2）下界限定符 (? super T)：

定义：通配符?的类型必须是T或者T的父类，但是！！集合元素依旧必须是T或者T的子类
作用：通常用于写入操作，读取则返回Object，需要显式类型转换，可能转换失败

public void process(List<? super Integer> list, int n){list.add(1); // 写入是安全的// 不能读取}

这个知识点我是比较迷的，到底该如何理解呢？

List<? extends Animal> animals = new ArrayList<>();
Animal animal = animals.get(0);
animals.add(new Dog());

看这个代码

一个容器，容器中全是Animal，可以get()来读取任何animal，但是不能add(狗)、也不能add(猫)，毕竟，谁知道这个容器到底是啥动物，具有不确定性，所以只能读取不能写入

List<? super Dog> dogs = new ArrayList<>();
dogs.add(new 哈士奇());
Object object = dogs.get(0);
Dog dog = (Dog) object;

一个容器，容器中到底有啥，其实是不确定的，我们唯一能确定的是，我们可以给容器中add(狗)，狗的子类也能add，但是不能get()来取出狗，因为不知道这个容器中还有啥，肯定是有别的东西，但是就是不知道有啥，编译器只好用一个Object来接收，自己再强转

一个是虽然不知道容器里有啥？但是可以get()，反正都是Animal或者子类，我get一个Animal那咋啦？

一个是虽然不知道容器里有啥？但是可以add()，反正都是Dog或者父类，我add一个dog那咋啦？

有一说一，其实还是有点蒙的，我还会回来的

补充一句：由于泛型擦除的存在，所以运行时无法确定泛型的具体类型，这个时候就不能使用instanceof来确定类型安全，向下强转自然就不能保证安全（向上强转倒无所谓），从这方面解释或许就说的通了？

比如，List<? super Dog>，泛型擦除后，就变成了List

总结

读取时: 你需要知道具体的类型，以确保你可以安全地将其视为T。
写入时: 你只需要知道类型的父类，以确保你可以安全地添加T及其子类的对象。

扩展知识

代码示例

public class GenericLimmitTest {public static void main(String[] args) {List<Dog> list = new ArrayList<>();new GenericLimmitTest().add(list);new GenericLimmitTest().run(list);}public void run(List<? extends Animal> list){list.get(0).run(); // 读取}
//    与上面的run()的另一种写法，这种更通用
//    public <T extends Animal> void run(List<T> list){
//        for (T animal : list){
//            animal.run(); // 读取
//        }
//    }public void add(List<? super Dog> list){list.add(new Dog());}}
class Animal{public void run(){System.out.println("running...");}
}
class Dog extends Animal{public void run(){System.out.println("Dog is running...");}
}

为何需要上下界限定符？

泛型提供了类型安全性，但有时我们希望泛型参数的类型在某个范围内，这样可以确保在不同场景下使用泛型时既能获得灵活性，又能保证类型安全。

上下界限定符的设计就是，允许我们定义类型的范围，而不是具体类型

协变与逆变

它们主要用于描述类型之间的兼容性问题

协变：主要解决返回值的灵活性问题，允许更具体的类型返回
逆变：主要解决参数传递的灵活性问题，允许更广泛的类型输入

协变（Covariance）：子类型可以替换父类型（派生类替换基类）

场景：当一个泛型容器（或方法返回类型）允许子类型替换父类型时，就是协变
特点：类型的方向是一致的（从父类到子类）
关键词：输出方向（比如方法的返回值）

public class GenericTest {public static void main(String[] args) {List<? extends Animal> animals;List<Dog> dogs = new ArrayList<>();animals = dogs; // 协变，子类型Dog替换父类型Animal，类型方向：Animal->Dog}class Animal{}class Dog extends Animal{}
}

逆变（Contravariance）：父类型可以替换子类型（基类替换派生类）

场景：当一个泛型容器（或方法参数类型）允许父类型替换子类型时，就是逆变
特点：类型的方向是相反的（从子类到父类）
关键词：输入方向（比如方法的参数）

public class GenericTest {public static void main(String[] args) {List<? super Dog> dogs;List<Animal> animals = new ArrayList<>();dogs = animals; // 逆变，父类型Animal替换子类型Dog，类型方向：Dog->Animal}class Animal{}class Dog extends Animal{}
}