java高级--泛型

文章目录

• 1. 什么是泛型?
• 2. 为什么使用泛型?
• 3. 如何使用泛型?
• 4. 泛型类
• 5. 泛型的通配符
• 6. 泛型接口
• 7. 泛型方法

---

一、什么是泛型?

其实我们再使用集合时就用过泛型List<T> 创建一个List对象List<Student> list=new ArrayList();

<T>它就是泛型。

        所谓的泛型就是在类定义时,不为类中属性和方法指定数据类型，而是在类对象创建时为其指           定相应的数据类型。

二、为什么使用泛型?

例子: 要求定义一个Point点类，该类中属性有x坐标和y坐标。

        要求: x和y的值可以都是整数类型。

        ​ x和y的值可以都是小数类型。

        ​ x和y的值可以都是字符串类型。

        如何定义该类呢? 如何确定属性的类型。----Object类型

package demo01;

public class Test {
    public static void main(String[] args) {
        //坐标为整数int--自动装箱->Integer--->Object(向上转型)
        Point p1=new Point(10,20);
        p1.show();
        //坐标为小数
        Point p2=new Point(25.5,36.6);
        p2.show();
        //坐标为字符串
        Point p3=new Point("东经180度","北纬25度");
        p3.show();
    }
}
class Point {
    //x坐标
    private Object x;
    //y坐标
    private Object y;
    
    //输出坐标的值
    public void show(){
        System.out.println("x坐标:"+x+";y坐标:"+y);
    }

    public Point() {
    }

    public Point(Object x, Object y) {
        this.x = x;
        this.y = 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 类名<泛型标志,泛型标志....>{

                //类成员
        }

package demo03;

public class Test03 {
    public static void main(String[] args) {
        Info<String> info = new Info<>();
        info.setVar("hello");
        info.show();

        Info<Integer> info1 = new Info<>();
        info1.setVar(10);
        info.show();

        //如果没有指定泛型类型默认为Object,
        Info  info2=new Info();
        info2.setVar("该吃饭了!!!");
        //如果想使用真正的类型接受，那么必须进行强制
        String o = (String) info2.getVar();
        System.out.println(o);
    }
}

class Info<T>{
    private T var;

    public void show(){
        System.out.println("var========"+var);
    }
    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
}

四、通配符

        在开发中对象的引用传递是最常见的，但是如果在泛型类的操作中，在进行引用传递时泛型类型必须匹配才可以传递，否则是无法传递的。如果想传递，可以定义泛型为?通配符。

package demo04;

public class Test04 {
    public static void main(String[] args) {
        Info<Integer> i=new Info<>();
        i.setVar(250);
        fun(i);

        Info<String> i2=new Info<>();
        i2.setVar("张三");
        fun(i2); //如果为泛型类型:不但要求数据类型相同之外还要求泛型类型也匹配。

        Info<Double> i3=new Info<>();
        i3.setVar(25.5);
        fun(i3);
    }

    //该方法的参数为Info而且它的泛型为Integer类型
    public static void fun(Info<?> info){
        info.show();
    }
}

//T标志可以任意起名.----> 那么在创建对象时，必须为每个泛型指定数据类型。
class Info<T>{

    private T var;
    public void show(){
        System.out.println("var========"+var);
    }

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
}

五、受限泛型

在引用传递中，在泛型操作中也可以设置一个泛型对象的==范围上限==和==范围下限==。范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型或者是此类型的子类，而范围下限使用super进行声明，表示参数化的类型可能是所指定的类型或者此类型的父类型。

语法:

[设置上限]
声明对象: 类名称<? extends 类> 对象名称;
定义类:  [访问权限] 类名称<泛型标识 extends 类>{}

[设置下限]
声明对象: 类名称<? super 类> 对象名称;
定义类:  [访问权限] 类名称<泛型标识 super 类>{}

package demo05;

public class Test05 {
    public static void main(String[] args) {

        Info<Integer> i1 = new Info<>();
        i1.setVar(10);
        fun(i1);

        Info<Object> i3 = new Info<>();
        i3.setVar("嘿嘿嘿");
        fun2(i3);

        Info<String> i2 = new Info<>();
        i2.setVar("hello");
//        fun(i2);//因为String不是Number的子类

    }
    public static void fun2(Info<? super Number> info){
        info.show();
    }

    public static void fun(Info<? extends Number> info){
        info.show();
    }
}

class Info<T>{
    private T var;

    public void show(){
        System.out.println("var========"+var);
    }
    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
}

六、泛型接口

上面那些例子都是使用泛型类。而在jdk1.5以后，泛型也可以定义在接口上了，定义接口的泛型和定义泛型类语法相似。

语法:

public interface 接口名<泛型标志,泛型标志....>{
   //静态常量
   //抽象方法。
}

类如何实现泛型接口:

package demo06;

public class Test06 {
    public static void main(String[] args) {
        Upan u=new Upan();

        Mouse<Integer> mouse=new Mouse<>();
    }
}
//泛型接口
interface USB<T>{
    //常量的命名必须全部大写。
    public static final String NAME=""; 
    T fun(); //抽象方法
}
//子类在实现接口时，确定泛型类型
class Upan implements USB<String>{

    @Override
    public String fun() {
        return "hello world";
    }
}

//子类也实现泛型和父类名相同的泛型
class Mouse<T> implements USB<T>{

    @Override
    public T fun() {
        return null;
    }
}

七、泛型方法

前面学习的所有泛型操作都是将整个类进行泛型化，但同样也可以在类中定义泛型化的方法。泛型方法的定义与其所在的类是否是泛型类是没有任何关系的，所在的类可以是泛型类，也可以不是泛型类。

泛型方法的简单定义 ：

[访问权限] ==<泛型标识>== 泛型标识 方法名称(泛型标识 参数名称)

package demo07;

public class Test07 {
    public static void main(String[] args) {
        String hello = Student.fun("hello");
        Integer fun = Student.fun(250);
        Double fun1 = Student.fun(250.0);
    }
}

class Student{

    //泛型方法: static静态成员，随着类的加载而被加载到JVM内存中。常量池
    public static <T> T fun(T t){

        return t;
    }
}