Java 泛型-白红宇

Java 泛型

阅读量：4575 次

发布时间：2019-06-08

本文共 5107 字，大约阅读时间需要 17 分钟。

Java 泛型技术产生的原因：

package cn.mldn.utli;class Point {    private Object x ;    private Object y ;    public void setX( Object x ) {        this.x = x ;    }    public void setY( Object y ) {        this.y = y ;    }    public Object getX() {        return x ;    }    public Object getY() {        return y ;    }}public class TestDemo {    public static void main(String[] args) {        Point p = new Point() ;        p.setX(10);        p.setY(20);                int x = (Integer) p.getX();        int y = (Integer) p.getY();        System.out.println(x + y) ;    }}

　上述的程序中，利用Point类存储整型数据，利用Object对象进行存储，向下转型为int型

public class TestDemo {    public static void main(String[] args) {        Point p = new Point() ;        p.setX(10.1);        p.setY(20.2);                double x = (Double) p.getX();        double y = (Double) p.getY();        System.out.println(x + y) ;    }}

　上述代码则是利用Point类存储小数，利用Object对象进行存储，向下转型为Double型

public class TestDemo {    public static void main(String[] args) {        Point p = new Point() ;        p.setX("上海");        p.setY("南京");                String x = (String) p.getX();        String y = (String) p.getY();        System.out.println(x + y) ;    }}

上述代码则是利用Point类存储String数据内容，利用Object对象进行存储，向下转型为String型

————————————————

上述的三段代码，均利用Point类进行三种不同类型的多类型同对象的存储，而Point类中是利用Object进行存储的，于是可以在调用处通过向下转型的方式将Object转为int/double/String等类型数据（装箱/拆箱）。

泛型技术：类在定义的时候可以只用一个标记，此标记表示类中属性或方法参数的类型标记，在使用的时候才动态的设置：

package cn.mldn.utli;// 此时设置的T在Point定义上只表示一个标记，在使用的时候需要为其设置具体额类型class Point
     
       {  // Type = T , 是一个类型    private T x ; // x的属性类型不明，有Point在使用时动态使用    private T y ;    public void setX( T x ) {        this.x = x ;    }    public void setY( T y ) {        this.y = y ;    }    public T getX() {        return x ;    }    public T getY() {        return y ;    }}

　　在使用Point类的时候才取设置的内容，也就是设置了类中属性的类型；

public class TestDemo {    public static void main(String[] args) {        Point
     
       p = new Point
      
       () ; 　　　　　// 利用的就是包装类的自动装箱功能        p.setX("上海");        p.setY("南京");        // 由于泛型的特性，使用的时候动态的设置Point接收的类型为String类型，所以返回的也是String类型就不用在转型了        String x = p.getX();        String y = p.getY();        System.out.println(x + y) ;    }}

使用泛型之后，所有类中属性的类型都是动态设置的，而所有使用泛型标记的方法参数类型也都是会发生改变。由此避免了向下转型的安全问题隐患。

如果是采用泛型，那么它能够接受的数据类型只能是基本数据类型的包装类表示，不可以引用类型！

# 在使用泛型类或者接口的时候，没有设置泛型的具体类型，会报错。（如果在没有设置泛型的具体类型的时候，所有泛型使用Object描述泛型的数据类型）

# 在JDK1.7后可以简化泛型：可以将实例化的泛型具体类型的定义省略

——————————

泛型通配符：

package cn.mldn.utli;class Message
     
       {      private T msg ;    public void setMsg(T msg) {        this.msg = msg ;    }    public T getMsg() {        return msg ;    }}public class TestDemo {    public static void main(String[] args) {        Message
      
        m = new Message<> ();        m.setMsg("Hello World!");        fun(m) ;  // 引用传递    }    public static void fun(Message
       
         temp) {        System.out.println(temp.getMsg()) ;    }}

上述代码为Message类设置的是一个String的泛型对象；

　　如果我们需要一个可以接收任何类型的泛型数据，则可以使用 “？” 符号代替 "<>" 定义类型；如此以来则可以接收任何的泛型，但是不可以更改，只可以取出。

public class TestDemo {    public static void main(String[] args) {        Message
     
       m = new Message<> ();        m.setMsg("Hello World!");        fun(m) ;  // 引用传递    }    public static void fun(Message
       temp) {        System.out.println(temp.getMsg()) ;    }}

　　在 “？”的通配符上还有两个子通配符：

　　　　~ ？ extends 类：设置泛型上限，可以在泛型声明上和方法参数上使用；

　　　　　　　　|-- ？ extends Number ：意味着可以设置Number或者子类的泛型

　　　　~ ？ super 类：设置泛型的下限，方法参数上使用；

　　　　　　　　|-- ？super String ：意味只能设置String或者它的父类（Object）

泛型接口：

　定义泛型接口

interface Message
     
       { //设置泛型接口    public void print(T t) ;}

在接口上定义其相应的子类，定义子类主要有两种形式：

形式一：在子类上继续设置泛型

package cn.mldn.utli;interface Message
     
       { //设置泛型接口    public void print(T t) ;}class MessageImpl
      
        implements Message
       
         {    public void print(T t) {        System.out.println(t) ;    }}public class TestDemo {    public static void main(String[] args) {        Message
        
          msg = new MessageImpl
         
          () ; // 向上转型实例化        msg.print("Hello World!");    }    }

形式二：在子类不设置泛型，而父接口明确定义一个泛型类型

package cn.mldn.utli;interface Message
     
       { //设置泛型接口    public void print(T t) ;}class MessageImpl implements Message
      
        {// 接口泛型的第二种定义方法，直接在实现接口的接口处明确一个泛型类型；由此实例化的时候不用设置泛型的具体类型    public void print(String t) {        System.out.println(t);            }    }public class TestDemo {    public static void main(String[] args) {        Message msg = new MessageImpl() ; // 向上转型实例化        msg.print("Hello World!");    }    }

-------------------------------

泛型方法：

　　泛型方法不一定定义在支持泛型的类中。

泛型方法的定义：

package cn.mldn.utli;public class TestDemo {    public static void main(String[] args) {        String str = fun("Hello,World!") ;        System.out.println(str);    }        // T 泛型类型由传入的参数类型决定    public static 
     
       T fun(T t) {        return t;    }}

————————

泛型总结：

　　泛型特性解决的是向下转型所带来的安全隐患，其核心的组成就是在声明类或接口中不用设置具体的参数类型；

　　？符号可以接收任意的泛型类型，但是只能够取出，不能够修改

~~~~

转载于:https://www.cnblogs.com/wangyuyang1016/p/10907191.html

你可能感兴趣的文章