黑马程序员----java 泛型详解

---------------------- android培训、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 + "、") ;
}
}