Java高级—泛型

1.什么是泛型。

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

2.如何来定义泛型

泛型可以定义在类上，接口上，方法上。 泛型类，泛型接口以及泛型方法。

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

格式：

public class 类名<泛型标志,泛型标志....>{

     //类成员
}

实例：

package com.lzl.text01;

/**
 * @create 2022-07-13
 */
public class Text01 {
    public static void main(String[] args) {
        Info<String> info = new Info<>();
        info.setVar("hello");
        info.show();
        Info<Integer> info1 = new Info<>();
        info1.setVar(25);
        info1.show();
        //如过没有指定泛型 那么默认为Object
        Info info2 = new Info();
        info2.setVar("hello");
        info2.show();
    }
}
//T 标志可以随便起名字----》 那么在创建对象的时候，必须为每个泛型指定数据类型
class Info<T>{
    private T var;

    public void show(){
        System.out.println("var:"+var);
    }

    public Info() {
    }

    public Info(T var) {
        this.var = var;
    }

    public T getVar() {
        return var;
    }

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

3.通配符

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

package com.lzl.text02;

/**
 * @create 2022-07-13
 */
public class Text01 {
    public static void main(String[] args) {
        Info<String> info = new Info<>();
        info.setVar("hello");
        info.show();
        Info<Integer> info1 = new Info<>();
        info1.setVar(25);
        info1.show();
        //如过没有指定泛型 那么默认为Object
        Info info2 = new Info();
        info2.setVar("hello");
        info2.show();

        fun(info2);
    }
    //当接受的参数为泛型时，不但要求数据类型相同，泛型的类型也要匹配
    public static void fun(Info<?> info){
        info.show();
    }
}

//T 标志可以随便起名字----》 那么在创建对象的时候，必须为每个泛型指定数据类型
class Info<T>{
    private T var;

    public void show(){
        System.out.println("var:"+var);
    }

    public Info() {
    }

    public Info(T var) {
        this.var = var;
    }

    public T getVar() {
        return var;
    }

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

4.受限泛型

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

语法：

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

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

实例：

package com.lzl.text03;

/**
 * @create 2022-07-13
 */
public class Text01 {
    public static void main(String[] args) {
       People<Number> people = new People<Number>();
       people.setVar(25.5);
       fun(people);
       people.setVar(25);
       fun2(people);
    }
    //传递的参数泛型类型必须为Object的子类或者Object类型
    public static void fun(People<? extends  Object> people){
        people.show();
    }
    //传递的参数泛型类型必须为Integer的子类或者Number类型
    public static void fun2(People<? super  Integer> people){
        people.show();

    }
}
//传递的参数泛型类型必须为Number的子类或者Number类型
class People<T extends Number>{
    private T var;

    public void show(){
        System.out.println("Var:"+var);
    }

    public People() {
    }

    public People(T var) {
        this.var = var;
    }

    public T getVar() {
        return var;
    }

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

5.泛型接口

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

语法：

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

实例：

package com.lzl.text04;

/**
 * @create 2022-07-13
 */
public class Text01 {
    public static void main(String[] args) {
        Mouse<String> mouse =new Mouse<>();
        mouse.setVar("hello");
        Upan upan= new Upan();

    }


}
//泛型接口
interface USB<T> {
 public static final String NAME="";
  T fun();
}
//子接口在实现接口时，确定泛型的类型
class Upan implements USB<String>{

    @Override
    public String fun() {
        return "hello";
    }
}
//子接口也实现 和 父类相同的泛型
class Mouse<T> implements USB<T>{
    private T var;

    public Mouse(T var) {
        this.var = var;
    }

    public Mouse() {

    }

    public T getVar() {
        return var;
    }

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

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

6.泛型方法

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

语法：

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

实例：

package com.lzl;

/**
 * @create 2022-07-13
 */
public class Text05 {
    String hello = Student.fun("hello");
    Integer shuzi = Student.fun(20);
}
class Student{
    //泛型方法： static静态成员，随着类的加载而被加载到jvm内存中，常量池
    public static <T> T fun(T t){
        return t;
    }
}