泛型

class Point<T>{        // 此处可以随便写标识符号，T是type的简称
    private T var ;    // var的类型由T指定，即：由外部指定
    public T getVar(){    // 返回值的类型由外部决定
        return var ;
    }
    public void setVar(T var){    // 设置的类型也由外部决定
        this.var = var ;
    }
};
public class GenericsDemo06{
    public static void main(String args[]){
        Point<String> p = new Point<String>() ;    // 里面的var类型为String类型
        p.setVar("MLDN") ;        // 设置字符串
        System.out.println(p.getVar().length()) ;    // 取得字符串的长度
    }
};

　　以上是将var变量设置成了String类型，当然也可以设置成Integer，如果设置的内容与指定的泛型类型不一致，则在编译时将出现错误。

class Point<T>{
    private T x ;        // 表示X坐标
    private T y ;        // 表示Y坐标
    public void setX(T x){
        this.x = x ;
    }
    public void setY(T y){
        this.y = y ;
    }
    public T getX(){
        return this.x ;
    }
    public T getY(){
        return this.y ;
    }
};

public class GenericsPoint{
    public static void main(String args[]){
        Point<Integer> p = new Point<Integer>() ;
        p.setX(10) ;        // 利用自动装箱操作：int --> Integer
        p.setY("北纬210度") ;        // 利用自动装箱操作：int --> Integer
        int x = p.getX() ;    // 自动拆箱
        int y = p.getY() ;    // 自动拆箱
        System.out.println("整数表示，X坐标为：" + x) ;
        System.out.println("整数表示，Y坐标为：" + y) ;
    }
};

　　在这样的程序里，减少了类型转换的操作代码，而且更加安全，如果设置的内容不是数字，则在编译的时候出现错误。

 

class Point<T>{        // 此处可以随便写标识符号，T是type的简称
    private T var ;    // var的类型由T指定，即：由外部指定
    public Point(T var){        // 通过构造方法设置内容
        this.var = var ;
    }
    public T getVar(){    // 返回值的类型由外部决定
        return var ;
    }
    public void setVar(T var){    // 设置的类型也由外部决定
        this.var = var ;
    }
};
public class GenericsDemo08{
    public static void main(String args[]){
        Point<String> p = new Point<String>("MLDN") ;    // 里面的var类型为String类型
        System.out.println("内容：" + p.getVar()) ;
    }
};

　　

设置多个泛型

class Notepad<K,V>{        // 此处指定了两个泛型类型
    private K key ;        // 此变量的类型由外部决定
    private V value ;    // 此变量的类型由外部决定
    public K getKey(){
        return this.key ;
    }
    public V getValue(){
        return this.value ;
    }
    public void setKey(K key){
        this.key = key ;
    }
    public void setValue(V value){
        this.value = value ;
    }
};
public class GenericsDemo09{
    public static void main(String args[]){
        Notepad<String,Integer> t = null ;        // 定义两个泛型类型的对象
        t = new Notepad<String,Integer>() ;        // 里面的key为String，value为Integer
        t.setKey("李兴华") ;        // 设置第一个内容
        t.setValue(30) ;            // 设置第二个内容
        System.out.print("姓名；" + t.getKey()) ;        // 取得信息
        System.out.print("，年龄；" + t.getValue()) ;        // 取得信息

    }
};

 

　　在泛型应用中最好在声明类对象的时候就指定好其内部的数据类型，例如“Info<String>”，但也可以不指定类型

class Info<T>{
    private T var ;
    public T getVar(){
        return this.var ;
    }
    public void setVar(T var){
        this.var = var ;
    }
    public String toString(){        // 覆写Object类中的toString()方法
        return this.var.toString() ;
    }
};
public class GenericsDemo10{
    public static void main(String args[]){
        Info i = new Info() ;        // 警告，没有指定泛型类型
        i.setVar("MLDN") ;            // 设置字符串
        System.out.println("内容：" + i.getVar()) ;
    }
};

编译以上的程序：

注意：GenericDemo10.java 使用了未经检查或不安全的操作。
注意：要了解详细信息，请使用 -Xlint:unchecked重新编译。

　　程序并不会因此不执行，但是此时，在Info类中并没有指定泛型的类型，则在java中为了保证程序依然可以使用，会将T设置成Object类型，这样一来，就可以接收任意的数据类型，也就是说此时var的类型就是Object，所有的泛型信息将被擦除，实际上以上的程序就相当于一下的定义格式：

class Info<T>{
    private T var ;
    public T getVar(){
        return this.var ;
    }
    public void setVar(T var){
        this.var = var ;
    }
    public String toString(){        // 覆写Object类中的toString()方法
        return this.var.toString() ;
    }
};
public class GenericsDemo11{
    public static void main(String args[]){
        Info<Object> i = new Info<Object>() ;        // 指定Object为泛型类型
        i.setVar("MLDN") ;            // 设置字符串
        System.out.println("内容：" + i.getVar()) ;
    }
};

 

 

 

总结：

泛型的产生意义：为了保证数据的安全性

泛型的基本使用：由外部指定其具体的操作类型