【泛型】_泛型入门笔记

来源：互联网发布：数控铣床加工中心编程编辑：程序博客网时间：2024/06/06 07:38

【泛型】_泛型入门笔记

分类： Java

【泛型】_泛型入门笔记

本章目标：

掌握泛型的产生意义：
掌握泛型的基本使用：
了解泛型的警告信息及泛型的擦除

3.1为什么要使用泛型？
现在要求设计一个可以表示出坐标点的类，坐标由X和Y组成，坐标的表示方法有以三种：

整数表示、小数表示、字符串表示

[java] view plaincopyprint?
class Point{  
    private Object x ;        // 表示X坐标  
    private Object y ;        // 表示Y坐标  
    public void setX(Object x){  
        this.x = x ;  
    }  
    public void setY(Object y){  
        this.y = y ;  
    }  
    public Object getX(){  
        return this.x ;  
    }  
    public Object getY(){  
        return this.y ;  
    }  
};  
  
public class GenericsDemo01{  
    public static void main(String args[]){  
        Point p = new Point() ;    // 声明一个Point的对象  
        p.setX(10) ;        // 利用自动装箱操作：int --> Integer --> Object  
        p.setY(20) ;        // 利用自动装箱操作：int --> Integer --> Object  
        int x = (Integer)p.getX() ;    // 取出数据先变为Integer，之后自动拆箱  
        int y = (Integer)p.getY() ;    // 取出数据先变为Integer，之后自动拆箱  
        System.out.println("整数表示，X坐标为：" + x) ;  
        System.out.println("整数表示，Y坐标为：" + y) ;  
    }  
};  

[java] view plaincopyprint?
class Point{  
    private Object x ;        // 表示X坐标  
    private Object y ;        // 表示Y坐标  
    public void setX(Object x){  
        this.x = x ;  
    }  
    public void setY(Object y){  
        this.y = y ;  
    }  
    public Object getX(){  
        return this.x ;  
    }  
    public Object getY(){  
        return this.y ;  
    }  
};  
  
public class GenericsDemo02{  
    public static void main(String args[]){  
        Point p = new Point() ;    // 声明一个Point的对象  
        p.setX(10.5f) ;        // 利用自动装箱操作：float --> Float --> Object  
        p.setY(20.6f) ;        // 利用自动装箱操作：float --> Float --> Object  
        float x = (Float)p.getX() ;    // 取出数据先变为Integer，之后自动拆箱  
        float y = (Float)p.getY() ;    // 取出数据先变为Integer，之后自动拆箱  
        System.out.println("小数表示，X坐标为：" + x) ;  
        System.out.println("小数表示，Y坐标为：" + y) ;  
    }  
};  

[java] view plaincopyprint?
class Point{  
    private Object x ;        // 表示X坐标  
    private Object y ;        // 表示Y坐标  
    public void setX(Object x){  
        this.x = x ;  
    }  
    public void setY(Object y){  
        this.y = y ;  
    }  
    public Object getX(){  
        return this.x ;  
    }  
    public Object getY(){  
        return this.y ;  
    }  
};  
  
public class GenericsDemo03{  
    public static void main(String args[]){  
        Point p = new Point() ;    // 声明一个Point的对象  
        p.setX("东经180度") ;        // String --> Object  
        p.setY("北纬210度") ;        // String --> Object  
        String x = (String)p.getX() ;    // 取出数据先变为Integer，之后自动拆箱  
        String y = (String)p.getY() ;    // 取出数据先变为Integer，之后自动拆箱  
        System.out.println("字符串表示，X坐标为：" + x) ;  
        System.out.println("字符串表示，Y坐标为：" + y) ;  
    }  
};  

3.2、认识泛型

泛型可以解决数据类型的安全性问题，它主要的原理，在在类的声明的时候通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这样在类声明或实例化的时候只要指定好需要的类型即可。

泛型类的定义格式：
[访问权限] class 类名称<泛型类型1,泛型类型2,...,泛型类型3>{
   [访问权限]泛型类型标识变量名称;
   [访问权限]泛型类型标识方法名称(){}
   [访问全线]返回值类型声明方法名称(泛型类型标识变量名称)()
}
泛型对象定义：
类名称<具体类> 对象名称 = new 类名称<具体类>();

[java] view plaincopyprint?
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()) ;    // 取得字符串的长度  
    }  
};  

[java] view plaincopyprint?
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()) ;  
    }  
};  

[java] view plaincopyprint?
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 GenericsDemo07{  
    public static void main(String args[]){  
        Point<Integer> p = new Point<Integer>() ;    // 里面的var类型为String类型  
        p.setVar("MLDN") ;        // 设置字符串  
    }  
};  

以上代码将产生错误，因为类型值无法匹配！

3.3、构造方法中使用泛型

使用格式：
[访问权限] 构造方法([<泛型类型> 参数名称]){}

[java] view plaincopyprint?
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()) ;  
    }  
};  

3.4、设置多个泛型

[java] view plaincopyprint?
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()) ;        // 取得信息  
    }  
};  

3.5、泛型安全警告

[java] view plaincopyprint?
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()) ;  
    }  
};  

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

以上代码实际效果如下：

[java] view plaincopyprint?
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()) ;  
    }  
};  

0 0