通配符
package genericity_wildcard;
import java.util.ArrayList;
import java.util.List;
/**
* ? -->通配符,类型不确定,用于声明变量|形参上
* 不能用在
* 1、创建对象
* 2、创建泛型类 泛型方法 泛型接口上
*/
public class TestWildcard {
public static void main(String[] args) {
List<?> list =new ArrayList<Integer>();
list =new ArrayList<String>();
list =new ArrayList<Object>();
/**list =new ArrayList<?>();
*编译错误 不能创建对象 */
test(list);
}
public static void test(List<?> list){
}
/**不能用于泛型方法声明的返回值
public static <?> void test2(List<?> list){
}
*/
class Test<T>{
}
/**不能用在创建泛型类
class Test2<?>{
}
*/
}
package genericity_wildcard;
/**
* 继承链
* Object
* |
* Fruit
* / \
* Apple Pear
* |
* FujiApple
*/
public class Fruit {
}
class Apple extends Fruit{
}
class Pear extends Fruit{
}
class FujiApple extends Apple{
}
- extends泛型的上限-Wildcard_Extends
package genericity_wildcard;
import java.util.ArrayList;
import java.util.List;
/**
* extends : 泛型的上限 <= 即子类或自身
* 1、一般用于上限操作
* 2、不能使用在添加数据上面,一般都是读取操作
* 3、规则
* List<Fruit> -->List<? extends Fruit>
* List<Apple> -->List<? extends Fruit>
* List<? extends Apple> -->List<? extends Fruit>
* 不能存放
* List<?>
* List<? extends Object>
*/
public class Wildcard_Extends {
static class Test<T extends Fruit>{
}
public static void test(List<? extends Fruit> list){
list.add(null);
}
public static void main(String[] args) {
@SuppressWarnings("unused")
Test<Fruit> t1 =new Test<Fruit>();
@SuppressWarnings("unused")
Test<Apple> t2 =new Test<Apple>();
@SuppressWarnings("unused")
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<? extends Apple> list4 =new ArrayList<FujiApple>();
test(list4);
@SuppressWarnings({ "unused", "rawtypes" })
List<?> list5=new ArrayList();
//test(list5);
@SuppressWarnings("unused")
List<? extends Object> list6=new ArrayList<Object>();
List<FujiApple> app =new ArrayList<FujiApple>();
test(app);
}
}
- super,泛型的下限-Wildcard_Super
package genericity_wildcard;
import java.util.ArrayList;
import java.util.List;
/**
* super : 泛型的下限 >= 即父类或自身
* 1、一般用于下限操作
* 2、能够添加数据上面,不能添加父对象
* 3、规则
* List<Fruit> -->List<? super Apple>
* List<Apple> -->List<? super Apple>
* List<? super Fruit> -->List<? super Apple>
* 不能存放
* List<? super FujiApple> -->List<?super Apple>
*/
public class Wildcard_Super {
public static void test(List<? super Apple> list){
list.add(new Apple());
list.add(new FujiApple());
/**list.add(new Fruit());
* 不能添加 父类对象*/
}
public static void main(String[] args) {
List<Apple> list1 =new ArrayList<Apple>();
test(list1);
List<Fruit> list2 =new ArrayList<Fruit>();
test(list2);
List<Object> list3 =new ArrayList<Object>();
test(list3);
List<? super Apple> list4 =new ArrayList<Apple>();
test(list4);
List<? super Fruit> list5 =new ArrayList<Object>();
test(list5);
@SuppressWarnings("unused")
List<? super FujiApple> list6 =new ArrayList<Object>();
@SuppressWarnings("unused")
List<?> list7 =new ArrayList<Object>();
}
}
泛型的嵌套
package genericity_nest;
public class Student<T> {
private T score;
public T getScore() {
return score;
}
public void setScore(T score) {
this.score = score;
}
}
package genericity_nest;
public class BjsxtStudent<T> {
private T stu;
public T getStu() {
return stu;
}
public void setStu(T stu) {
this.stu = stu;
}
}
package genericity_nest;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class TestNest {
/** 泛型嵌套 -->由外到内拆分*/
public static void main(String[] args) {
Student<String> stu =new Student<String>();
stu.setScore("优秀");
System.out.println(stu.getScore());
BjsxtStudent<Student<String>> bjsxtstu =new BjsxtStudent<Student<String>>();
bjsxtstu.setStu(stu);
stu=bjsxtstu.getStu();
String score =stu.getScore();
System.out.println(score);
Map<String,String> map =new HashMap<String,String>();
map.put("a", "java300");
map.put("b", "马士兵javase");
Set<Entry<String,String>> entrySet= map.entrySet();
for(Entry<String,String> entry:entrySet){
String key =entry.getKey();
String value =entry.getValue();
System.out.println(key+"-->"+value);
}
}
}
泛型没有数组,没有多态
package genericity_supplement;
/**
* 继承链
* Object
* |
* Fruit
* / \
* Apple Pear
* |
* FujiApple
*/
public class Fruit {
}
class Apple extends Fruit{
}
class Pear extends Fruit{
}
class FujiApple extends Apple{
}
package genericity_supplement;
import java.util.ArrayList;
import java.util.List;
/**
* 1、泛型没有多态
* 2、泛型没有数组
*/
public class TestOthers {
public static void main(String[] args) {
@SuppressWarnings("unused")
Fruit f =new Apple();
/** List<Fruit> list =new ArrayList<Apple>();
* 泛型没有多态
*/
@SuppressWarnings("unused")
List<? extends Fruit> list =new ArrayList<Apple>();
/**Fruit<String>[] arr =new Fruit<String>[10];
* 泛型没有数组
*/
@SuppressWarnings("unused")
List<Fruit> list2 =new ArrayList<>();
}
}