泛型

　　JDK1.5当中的泛型是主要的，他能帮我们实现参数转换问题。

 

目录

泛型的问题引出

 

 

 

泛型的问题引出

　　

 

现在假设需要你定义一个描述坐标的程序类Point，而这个坐标类中需要提供两个属性，x，y 对于这两个属性的内容有如下几种选着。

　　　　x=10，y=20；

　　　　x=10.1,y=20.2;

　　　　x=东京70度 y=北纬20度；

　　现在要解决的问题是point中的x和y属性类型问题，那么此时需要保存的是int double String 在java里面只有一种类型可以保存所有的类型。

　　　　int自动装 箱为Integer Integer自动向上转为Object

　　　　double自动装箱为Double，Double自动向上转为Object

　　　　String自动装箱为Object

 

package cn.Tony.demo;

import cn.Tony.util.MyMath;

class Point{
    private Object x;
    private Object y;
    public Object getX() {
        return x;
    }
    public void setX(Object x) {
        this.x = x;
    }
    public Object getY() {
        return y;
    }
    public void setY(Object y) {
        this.y = y;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        //第一步：设置数据
        Point p=new Point();
        p.setX(10.2);
        p.setY("北纬10度");
        //第二步：取出数据
        String x=(String)p.getX();
        String y=(String)p.getY();
        System.out.println("x="+x+",y="+y);
    }
}

 

ClassCastException 是两个没有关系的对象进行强制转换带来异常，那么这个时候语法不会有限制，编译时才会有错误，得出一个结论：向下转型是不安全的操作，会带来隐患。

泛型的实现

　　泛型指的是在类定义的时候并不会设置类中的属性或方法中的参数的具体类型，而是在类使用的时候在进行定义，泛型的操作，要做一个类型的声明，或者一个类型的标记，

范例：

package cn.Tony.demo;
//在Point类定义的时候完全不知道X和Y属性是什么类型。而由我们的使用者来进行
class Point <T>{//T表示参数， 是一个占位的标记
    private T x;
    private T y;
    public T getX() {
        return x;
    }
    public void setX(T x) {
        this.x = x;
    }
    public T getY() {
        return y;
    }
    public void setY(T y) {
        this.y = y;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        //第一步：设置数据
        Point<String> p=new Point<String>();
        p.setX("东经10度");//设置坐标
        p.setY("北纬10度");
        //第二步：取出数据
        String x=p.getX();//避免了向下转型
        String y=p.getY();//避免了向下转型
        System.out.println("x="+x+",y="+y);
    }
}

 

　　当开发的程序可以避免向下转型，也就意味着安全隐患被消除了。尽量不要使用向下转型

通配符

　　虽然程序类中有了泛型的定以后避免了ClassCastException的问题，但是又会产生新的情况：参数统一的问题。

范例:观察程序

package cn.Tony.demo;
class Message<T>{
    private T note;
    public void setNote(T note) {
        this.note = note;
    }
    public T getNote() {
        return note;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Message<String> msg=new Message<>();
        msg.setNote("天天帅气！");
        fun(msg);
    }
    public static void fun(Message<String> temp) {
        System.out.println(temp.getNote());
    }
}

　　但是这样会带来一个新的问题，如果泛型的类型设置的不是String，而是Integer（泛型类型只允许设置类和接口而不能是基本数据类型）

范例：错误代码

public class TestDemo {
    public static void main(String[] args) {
        Message<Integer> msg=new Message<>();
        msg.setNote(10);
        fun(msg);
    }
    public static void fun(Message<String> msg) {
        System.out.println(msg.getNote());
    }
}

 

public class TestDemo {
    public static void main(String[] args) {
        Message<Integer> msg=new Message<>();
        msg.setNote(10);
        fun(msg);
    }
    //如果没有设置泛型，那么默认就是Object
    public static void fun(Message msg) {
        msg.setNote("天");
        System.out.println(msg.getNote());
    }
}

　　所以：可以接受所有的泛型类型，不能让用户修改。那么就需要使用我们的通配符来实现，使用“？”来处理。

public class TestDemo {
    public static void main(String[] args) {
        Message<Integer> msg=new Message<>();
        msg.setNote(10);
        fun(msg);
    }
    //此时使用的通配符“？”描述可以接收任意类型，但是由于不确定类型，所以无法修改
    public static void fun(Message<?> msg) {
        System.out.println(msg.getNote());
    }
}

　　而在“？”的基础上又产生了两个子通配符

　　　　？extends类：设置泛型上限：

　　　　　　例如：？extends Number ,表示只能够设置Number或其子类，例如：Integer，Double等；

　　　　 ？super类：设置泛型下限：

　　　　　　例如：？super Strinhg ,表示只能够设置String或其父类Object

范例：观察泛型上限

 

package cn.Tony.demo;
class Message<T extends Number>{
    private T note;
    public void setNote(T note) {
        this.note = note;
    }
    public T getNote() {
        return note;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Message<Integer> msg=new Message<>();
        msg.setNote(10);
        fun(msg);
    }
    //此时使用的通配符“？”描述可以接收任意类型，但是由于不确定类型，所以无法修改
    public static void fun(Message<? extends Number> msg) {
        System.out.println(msg.getNote());
    }
}

 

范例：设置泛型下限

package cn.Tony.demo;
class Message<T>{
    private T note;
    public void setNote(T note) {
        this.note = note;
    }
    public T getNote() {
        return note;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Message<String> msg=new Message<>();
        msg.setNote("11");
        fun(msg);
    }
    //此时使用的通配符“？”描述可以接收任意类型，但是由于不确定类型，所以无法修改
    public static void fun(Message<? super String> msg) {
        System.out.println(msg.getNote());
    }
}

泛型接口

　　泛型除了在类中定义之外还可以定义在接口里面，这种情况称为泛型接口

泛型接口：

 

interface IMessage<T> {
    public void print(T t) ;
}

 

　　但是对于这个接口实现有两种做法：

范例：在子类定义的时候继续使用泛型

package cn.Tony.demo;
interface IMessage<T> {
    public void print(T t) ;
}
class MessageIplm<T> implements IMessage<T>{
    public void print(T t) {
        System.out.println(t);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        IMessage<String> msg=new MessageIplm<String>();
        msg.print("Hello");
    }
}

范例：在子类实现接口的时候给出具体类型 

package cn.Tony.demo;
interface IMessage<T> {
    public void print(T t);
}
class MessageIplm implements IMessage<String>{
    public void print(String t) {
        System.out.println(t);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        IMessage<String> msg=new MessageIplm();
        msg.print("Hello");
    }
}

泛型方法

　　在之前定义的类和方法中继续使用泛型，这种方法就称为泛型方法，但是泛型方法不一定非定义在类和接口里面，也可以单独定义。

范例：定义泛型方法

package cn.Tony.demo;

public class TestDemo {
    public static void main(String[] args) {
        Integer data[]=fun(1,2,3);
        for(int temp:data) {//迭代和自动拆箱
            System.out.println(temp);
        }
    }
    public static <T> T[] fun(T...args) {
        return args;
    }
}