java 泛型详解

 

一.泛型（Generic type 或者generics）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型（引用数据类型）进行参数化的类。使用泛型可以把运行时期的错误转移到编译时期，提高了安全性，是1.5版本后的新特性。

二.类中的泛型 

     定义在类后，类中定义了泛型，方法中可以再定义其他类型

   

public class jihe16 {
	public static void main(String[] args){
		
		dy<String> a = new dy<String>();
		a.setQQ(new String("abc"));
		String s =a.getQQ();
		System.out.println(s);		
	}
}
/*
 *类中的泛型
 * */
class dy<QQ>{
	private QQ qq;
	public void setQQ(QQ qq){
		this.qq=qq;
	}
	public QQ getQQ(){
		return qq;	
	} 
	
}

三.方法中的泛型

    定义在返回值前面，修饰符后面

public class jihe17 {
	public static void main(String[] args){
		child<String> c = new child<String>();
		c.print("hahah");
		c.print(4);
		c.print(true);
		c.println("hajs");
		child.print1(true);
	}
}
class child<T>{//类中定义泛型。方法可以同时定义别的类型的泛型
	public <Q>void print(Q q){
		System.out.println(q);
	}
	public  void println(T t){
		System.out.println(t);
	}
	public static  <E> void print1(E e){//静态方法，在类刚加载时就存在，可以在静态方法定义自己的泛型，但不可以                                               //定义和类上一致的泛型。
		System.out.println(e);
	}

四.接口中的泛型

public class jihe18 {
	public static void main(String[] args){
		imp<Boolean> i = new imp<Boolean>();
		i.show(true);
		imp2 i1 = new imp2();
		i1.show("javaStudy!");
	}
}
interface imple<E>{
	 void show(E e);
}
class imp<E> implements imple<E>{//类实现接口方法一：
	public void show(E e) {
		System.out.println(e);
	}
}
class imp2<Stirng> implements imple<String>{//类实现方法二：
	public void show(String s){
		System.out.println(s);
	}
}

五.泛型中的通配符

class Info<T>{  
    private T var ;     // 定义泛型变量  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public String toString(){   // 直接打印  
        return this.var.toString() ;  
    }  
};  
public class GenericsDemo14{  
    public static void main(String args[]){  
        Info<String> i = new Info<String>() ;       // 使用String为泛型类型  
        i.setVar("it") ;                            // 设置内容  
        fun(i) ;  
    }  
    public static void fun(Info<?> temp){     // 可以接收任意的泛型对象  
        System.out.println("内容：" + temp) ;  
    }  
};  

六.泛型上限

class Info<T>{  
    private T var ;     // 定义泛型变量  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public String toString(){   // 直接打印  
        return this.var.toString() ;  
    }  
};  
public class GenericsDemo17{  
    public static void main(String args[]){  
        Info<Integer> i1 = new Info<Integer>() ;        // 声明Integer的泛型对象  
        Info<Float> i2 = new Info<Float>() ;            // 声明Float的泛型对象  
        i1.setVar(30) ;                                 // 设置整数，自动装箱  
        i2.setVar(30.1f) ;                              // 设置小数，自动装箱  
        fun(i1) ;  
        fun(i2) ;  
    }  
    public static void fun(Info<? extends Number> temp){  // 只能接收Number及其Number的子类 （上限） 
        System.out.print(temp + "、") ;  
    }  
} 

七.泛型下限

class Info<T>{  
    private T var ;     // 定义泛型变量  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public String toString(){   // 直接打印  
        return this.var.toString() ;  
    }  
};  
public class GenericsDemo21{  
    public static void main(String args[]){  
        Info<String> i1 = new Info<String>() ;      // 声明String的泛型对象  
        Info<Object> i2 = new Info<Object>() ;      // 声明Object的泛型对象  
        i1.setVar("hello") ;  
        i2.setVar(new Object()) ;  
        fun(i1) ;  
        fun(i2) ;  
    }  
    public static void fun(Info<? super String> temp){    // 只能接收String或Object类型的泛型  
        System.out.print(temp + "、") ;  
    }  
}