/**
* 泛型进阶
* 概念:泛型只是编译时的概念,供编译器进行语法检查时用的
* (由于程序员需要一种类型安全的集合,正是这种需求促成了泛型)
* 目的:
* 1.努力将运行时异常转换成编译时错误,减少运行时异常数量(提高了编译器的能力)
* 2.解决模板编程的问题
* 基本的用法:在使用集合时,用<>指定集合中可以放入的类型
* 注意:
* 1.属性中使用集合时不指定泛型,默认为<Object>
* 2.泛型不同的引用与对象之间都是不兼容的
* 3.引用的泛型与对象的泛型必须一致
*/
import java.util.*;
public class TestGenerics1 {
public static void main(String[] args) {
List<String> l=new ArrayList<String>();
l.add("ABC");
l.add("DEF");
String str=l.get(0);//使用泛型后,获得对象时不用进行强制类型转换
/*错误,试图将Integer和Double类型的对象放入指定存放String类型对象的集合中
l.add(1);
l.add(1.5);
*/
for(String s:l){//for-each循环 (集合/数组中元素类型 变量:集合/数组名)
System.out.println(s);
}
Map<Integer,String> map=new HashMap<Integer,String>();
map.put(1,"Huxz");
map.put(2,"Liucy");
map.put(3,"TangLiang");
//map.put(1.5,"Liucy");
//map.put("Liucy",1.5);
Set<Integer> keys=map.keySet();
for(Integer i:keys){
String value=map.get(i);
System.out.println(i+"---"+value);
}
List<Number> list=new ArrayList<Number>();
list.add(10);
list.add(1.5);
/*
List<Number> list2;
List<Integer> list3=new ArrayList<Integer>();
list2=list3;
*/
}
}
/**
* 泛型的通配符(用于方法的参数)
* 1.<?> 允许所有泛型的引用调用
* 2.<? extends Number> 只允许泛型为Number及Number子类的引用调用
* 3.<? super Number> 只允许泛型为Number及Number父类的引用调用
* 4.<? extends Comparable> 只允许泛型为实现Comparable接口的实现类的引用调用
* 注意:
* 1.方法参数中使用集合时不指定泛型,默认为<?>
* 2.方法参数中<? extends Number&Comparable>这种修饰符是不支持的
*/
import java.util.*;
import static java.lang.System.*;
public class TestGenerics2 {
public static void main(String[] args) {
List<String> l1=new ArrayList<String>();
List<Object> l2=new ArrayList<Object>();
List<Number> l3=new ArrayList<Number>();
List<Integer> l4=new ArrayList<Integer>();
List<Double> l5=new ArrayList<Double>();
print(l1);
print(l2);
print(l3);
print(l4);
print(l5);
}
//方法参数中使用集合时不指定泛型,默认为<?>
public static void print(List list){
for(Object o:list){
out.println(o);
}
}
/*<?> 允许所有泛型的引用调用
public static void print(List<?> list){
for(Object o:list){
out.println(o);
}
}
*/
/*<? extends Number> 只允许泛型为 Number及Number子类的引用调用
public static void print(List<? extends Number> list){
for(Number o:list){
out.println(o);
}
}
*/
/*<? extends Comparable> 只允许泛型为实现了Comparable接口的实现类的引用调用
public static void print(List<? extends Comparable> list){
for(Comparable o:list){
out.println(o);
}
}
*/
/*<? super Number> 只允许泛型为Number及Number父类的引用调用
public static void print(List<? super Number> list){
for(Object o:list){
out.println(o);
}
}
*/
/*方法参数中<? extends Number&Comparable>这种修饰符是不支持的
public static void print(List<? extends Number & Comparable> list){
for(Object o:list){
out.println(o);
}
}
*/
}
/**
* 泛型的通配符(用于泛型方法)
* 定义:修饰符 泛型 返回类型 方法名 参数表 抛出的异常
* 1.<T> 允许所有泛型的引用调用
* 2.<T extends Number> 只允许泛型为Number及Number子类的引用调用
* 3.<T extends Comparable> 只允许泛型为实现了Comparable接口的实现类的引用调用
* 4.<T extends Number&Comparable>只允许泛型为既是Number及Number子类 又实现了Comparable接口的实现类的引用调用
* 注意:
* 1.泛型方法中<? super Number>这种修饰符是不支持的
*/
import java.util.*;
public class TestGenerics3 {
public static void main(String[] args) {
List<String> l1=new ArrayList<String>();
List<Object> l2=new ArrayList<Object>();
List<Number> l3=new ArrayList<Number>();
List<Integer> l4=new ArrayList<Integer>();
List<Double> l5=new ArrayList<Double>();
String[] a1=new String[10];
Object[] a2=new Object[10];
Number[] a3=new Number[10];
Integer[] a4=new Integer[10];
Double[] a5=new Double[10];
copyFromArray(l1,a1);
copyFromArray(l2,a2);
copyFromArray(l3,a3);
copyFromArray(l4,a4);
copyFromArray(l5,a5);
}
public static <T > void copyFromArray(List<T> l,T[] a){
for(T o:a){
l.add(o);
}
}
/*<T extends Number> 只允许泛型为Number及Number子类的引用调用
public static <T extends Number > void copyFromArray(List<T> l,T[] a){
for(T o:a){
l.add(o);
}
}
*/
/* 此处不许用super
public static <T super Number> void copyFromArray(List<T> l,T[] a){
for(T o:a){
l.add(o);
}
}
*/
//public static <T,V> void m(List<T> l1,List<V> l2){}
//<T extends Number&Comparable>只允许泛型为既是Number及Number子类又
// 实现了Comparable<sp>