泛型

/**

* 泛型进阶

* 概念：泛型只是编译时的概念，供编译器进行语法检查时用的

* (由于程序员需要一种类型安全的集合，正是这种需求促成了泛型)

* 目的：

* 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接口的实现类的引用调用

public static <T extends Number & Comparable > void copyFromArray(List<T> l,T[] a){

for(T o:a){

l.add(o);

}

}

}

/**

* 泛型类(泛型的通配符与泛型方法的通配符约束一致)

* 1.静态方法中不能使用类的泛型

* (原因：泛型类中的泛型在创建类的对象时被替换为确定类型，

* 静态方法可以通过类名直接访问，而java为一种强类型语言，

* 没有类型的变量或对象是不允许的，所以静态方法中不能使用类的泛型)

* 2.不能创建[泛型类]的的对象(因为泛型类有可能是一个接口或抽象类)

* 3.不能在Catch子句中使用泛型

* (因为编译时，如果try子句抛出的是已检查异常，编译器无法确定 Catch能不能捕获这个异常)

*/

public class TestGenerics4 {

public static void main(String[] args) {

MyClass2 test = new MyClass2();

MyClass2<String> s=new MyClass2<String>();

s.method1("231");

MyClass2<Integer> s2=new MyClass2<Integer>();

s2.method1(231);

}

}

class MyClass2 <T >{

public void method1(T t){

}

public T method2(){

return null;

}

/*静态方法中不能使用类的泛型

public static void m(T t){

}

*/

/*不能创建[泛型类]的的对象 T可以是一个接口

public void m(){

T t=new T();

}

*/

/*不能在Catch子句中使用泛型

public void m(){

try{

}

catch(T t){}

}

*/

}