Java程序设计 泛型【一】

63 阅读3分钟

这是我参与2022首次更文挑战的第9天,活动详情查看:2022首次更文挑战

Java程序设计 泛型

泛型类定义

[访问权限] class 类名称<泛型类型标识1,泛型类型标识2,泛型类型标识3>{
	[访问权限] 泛型类型标识 变量名称;
	[访问权限] 泛型类型标识 方法名称(){};
	[访问权限] 返回值类型声明 方法名称(泛型类型标识 变量名称){};
}

泛型对象定义

类名称<具体类> 对象名称 = new 类名称<具体类>();
class P<T>{
    private T var;

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
}
public class Hello {
    public static void main(String[] args) {
        P<Integer> p = new P<Integer>();
        p.setVar(20);
        System.out.println(p.getVar()*5);
        P<String> p2 = new P<String>();
        p2.setVar("20");
        System.out.println(p2.getVar().length());
    }
}

image-20220125113430326

var属性设置成Integer类型和var属性设置成String类型

使用泛型保证输入的数据类型一样

class P<T>{
    private T a;
    private T b;

    public T getA() {
        return a;
    }

    public void setA(T a) {
        this.a = a;
    }

    public T getB() {
        return b;
    }

    public void setB(T b) {
        this.b = b;
    }
}
public class Hello {
    public static void main(String[] args) {
        P<Integer> p = new P<Integer>();
        p.setA(12);
        p.setB(21);
        System.out.println(p.getA());
        System.out.println(p.getB());
    }
}

image-20220125162101460

输入数据不是Integer时编译出错

public class Hello {
    public static void main(String[] args) {
        P<Integer> p = new P<Integer>();
        p.setA(12);
        p.setB("21");
        System.out.println(p.getA());
        System.out.println(p.getB());
    }
}

image-20220125162251176

构造方法使用泛型

[访问权限] 构造方法 ([<泛型类型> 参数名称]){
}
class P<T>{
    private T var;
    public P(T var){
        this.var = var;
    }
    public T getVar(){
        return var;
    }
    public void setVar(T var){
        this.var = var;
    }
}
public class Hello {
    public static void main(String[] args) {
        P<Integer> p = new P <Integer>(1);
        System.out.println(p.getVar());
    }
}

image-20220125163227538

设置多个泛型

class P<X,Y>{
    private X x;
    private Y y;

    public X getX() {
        return x;
    }

    public void setX(X x) {
        this.x = x;
    }

    public Y getY() {
        return y;
    }

    public void setY(Y y) {
        this.y = y;
    }
}
public class Hello {
    public static void main(String[] args) {
        P<Integer,String> p = new P<Integer,String>();
        p.setX(12);
        p.setY("AB");
        System.out.println(p.getX());
        System.out.println(p.getY());
    }
}

image-20220125163545614

使用Object进行接收数据

class P<T>{
    private T var;

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
}
public class Hello {
    public static void main(String[] args) {
        P<Object> a = new P<Object>();
        a.setVar("ABC");
        System.out.println(a.getVar());
        a.setVar(123);
        System.out.println(a.getVar());
    }
}

image-20220125165604223

通配符

匹配任意类型

通配符 ?

class P<T>{
    private T var;

    public T getVar() {
        return var;
    }

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

    @Override
    public String toString() {
        return (String) this.var;
    }
}
public class Hello {
    public static void main(String[] args) {
        P<String> a = new P<String>();
        a.setVar("ABCD");
        fun(a);
    }
    public static void fun(P<?> temp){
        System.out.println(temp);
    }
}

image-20220125172811195

设置上下限

范围上限使用extends关键字声明,表示泛型的类型可能是所指定的类型或者是此类型的子类,而范围下限使用super进行声明,表示泛型的类型可能是所指定的类型,或者是此类型的父类型,或是Object类

上限

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

下限

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

泛型的上限

设置方法只能接收泛型为Number或Number类型的子类

class Info<T>{
    private T var;

    public T getVar() {
        return var;
    }

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

    @Override
    public String toString() {
        return this.var.toString();
    }
}
public class Hello {
    public static void main(String[] args) {
        Info<Integer> a = new Info<Integer>();
        Info<Float> b = new Info<Float>();
        a.setVar(32);
        b.setVar(23.25F);
        fun(a);
        fun(b);
    }
    public static void fun(Info<? extends Number> a){
        System.out.println(a);
    }
}

image-20220125233319342

在类定义时指定泛型的上限

class Info<T extends Number>{
    private T var;

    public T getVar() {
        return var;
    }

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

    @Override
    public String toString() {
        return this.var.toString();
    }
}
public class Hello {
    public static void main(String[] args) {
        Info<Integer> a = new Info<Integer>();
        a.setVar(45);
        System.out.println(a);
    }
}

image-20220125233835789

public class Hello {
    public static void main(String[] args) {
        Info<String> a = new Info<String>();
        a.setVar("45");
        System.out.println(a);
    }
}

image-20220125233951553

传入其他类型报错

泛型的下限

使用的泛型只能在本类及其父类类型上应用时,就必须使用泛型的范围下限进行配置。

class Info<T>{
    private T var;

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
    public String toString(){
        return this.var.toString();
    }
}
public class Hello {
    public static void main(String[] args) {
        Info<String> a = new Info<String>();
        Info<Object> b = new Info<Object>();
        a.setVar("ABC");
        b.setVar(new Object());
        fun(a);
        fun(b);
    }
    public static void fun(Info<? super String> a){
        System.out.println(a);
    }
}

image-20220125235135843

传入其他类型

public class Hello {
    public static void main(String[] args) {
        Info<Integer> a = new Info<Integer>();
        a.setVar(456);
        fun(a);
    }
    public static void fun(Info<? super String> a){
        System.out.println(a);
    }
}

image-20220125235449140