上一节： 架构师筑基必备技能：深入Java泛型，泛型的作用与定义
本文作者：我俩绝配
本文出处：博客园
原文链接：https://www.cnblogs.com/lihaoyang/p/7105581.html
package generic;
import java.util.ArrayList;
import java.util.List;
/**
* ? -->通配符，类型不确定，用于声明 变量|形参 上
* 不能用在：
* 1，创建对象
* 2，创建泛型类 、泛型方法、泛型接口上
*
*/
public class WildcardTest {
public static void main(String[] args) {
//声明
List<?> list = new ArrayList<Integer>();
list = new ArrayList<String>();
list = new ArrayList<Object>();
test(list);
//编译错误，不能创建对象
// list = new ArrayList<?>();
}
public static void test (List<?> list){
}
//？不能用在泛型方法上
/*public static <?> void test2(List<?> list){
}*/
//？不能创建泛型类
/*class Test<?>{
}*/
}
当然这样用是没有什么意义的，它和用Object一样
泛型上限 extends:
几个有继承关系的类：
package generic;
/**
* 继承链：
* Object
* / \
* Apple Pear
* /
* FujiApple
*
* @author Administrator
*
*/
public class Fruit {
}
class Apple extends Fruit{
}
class Pear extends Fruit{
}
class FujiApple extends Apple{
}
例子程序：
package generic;
import java.util.ArrayList;
import java.util.List;
/**
* extends:泛型的上限 表示 <= ,即 子类
* 1，一般用于 限制操作
* 2，不能用在添加数据上，一般都是读取操作
* 3，规则：
* 遇到 List<? extends Fruit> 什么样的数据可以往上放：
* List<Fruit>
* List<Apple>
* List<? extends Apple>
* 不能存放：
* List<?>
* List<? extends Object>
* @author Administrator
*
*/
public class ExtendsTest {
public static void main(String[] args) {
//extends 为上限，List的类型上限是Fruit
Test<Fruit> t1 = new Test<Fruit>();
Test<Apple> t2 = new Test<Apple>();
Test<Pear> t3 = new Test<Pear>();
//调用方法
List<? extends Fruit> list1 = new ArrayList<Fruit>();
test(list1);
List<Fruit> list2 = new ArrayList<Fruit>();
test(list2);
List<Apple> list3 = new ArrayList<Apple>();
test(list3);
List<FujiApple> list4 = new ArrayList<FujiApple>();
test(list4);
List<? extends Apple> list7 = new ArrayList<FujiApple>();
test(list7);
//报错：因为 ? 相当于 ? extends Object，范围超过了Fruit
List<?> list5 = new ArrayList<Object>();
// test(list5);
List<? extends Object> list6 = new ArrayList<Object>();
// test(list6);
}
//? extends Fruit
public static void test(List<? extends Fruit> list){
}
//内部类
static class Test<T extends Fruit>{
}
}
泛型的下限：Super
package generic;
import java.util.ArrayList;
import java.util.List;
/**
* super: 泛型的下限 >= 父类或者自身
1，一般用于 下限制操作
* 2，能够添加数据上，不能添加父对象
* 3，规则：
*/
public class SuperTest {
public static void main(String[] args) {
//传入的List类型必须 >=Apple，即是 Apple类的父类或自身
List<Apple> list1 = new ArrayList<Apple>();
test(list1);
List<Fruit> list2 = new ArrayList<Fruit>();
test(list2);
List<Object> list3 = new ArrayList<Object>();
test(list3);
//规则 Object > Fruit 正确
List<? super Fruit> list4 = new ArrayList<Object>();
test(list4);
//Apple = Apple 正确
List<? super Apple> list5 = new ArrayList<Apple>();
test(list5);
//FujiApple < Apple,编译报错
List<? super FujiApple> list6 = new ArrayList<Object>();
//test(list6);
//? --> ? extends Object ，可能意思是左边声明是Object的子类，右边是Object，不行？
List<?> list7 = new ArrayList<Object>();
//test(list7);
}
public static void test(List<? super Apple> list){
//不能添加父类对象，子类能添加，这里不是很明白！
list.add(new Apple());
list.add(new FujiApple());
//list.add(new Fruit());//父类不能添加
}
}
泛型嵌套：
学生类：
package generic;
public class Stu<T> {
private T score;
public T getScore() {
return score;
}
public void setScore(T score) {
this.score = score;
}
}
学校类：
package generic;
/**
* @author Administrator
*
* @param <T>
*/
public class School<T> {
private T stu;
public T getStu() {
return stu;
}
public void setStu(T stu) {
this.stu = stu;
}
}
测试类：
package generic;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* 泛型嵌套
* @author Administrator
*
*/
public class StuApp {
public static void main(String[] args) {
Stu<String> stu = new Stu<String>();
stu.setScore("优秀");
System.out.println(stu.getScore());
//泛型嵌套：
School<Stu<String>> sch = new School<Stu<String>>();
sch.setStu(stu);
stu = sch.getStu();
String score = stu.getScore();
System.out.println(score);
//HashMap
Map<String,String> map = new HashMap<String,String>();
map.put("a", "老大");
map.put("b", "老二");
Set<Entry<String, String>> entrySet = map.entrySet();
for (Entry<String, String> entry : entrySet) {
System.out.println(entry.getKey() +"--->"+ entry.getValue());
}
}
}
泛型没有多态：
package generic;
import java.util.ArrayList;
import java.util.List;
public class Other {
public static void main(String[] args) {
//多态
Fruit f = new Apple();
//泛型没有多态：
// List<Fruit> list = new ArrayList<Apple>();//错误
List<? extends Fruit> list = new ArrayList<Apple>();
//泛型没有数组
// Fruit<String>[] arr = new Fruit<String>(); //报错
//JDK1.7泛型简化
List<String> list2 = new ArrayList<>();
}
}
下一节： 架构师筑基必备技能：深入Java泛型，泛型上下边界
网友评论