泛型的上界

简介: 泛型的上界

一、泛型的上界
class Myclass<类型参数 extends 类型上界> {

}
1
2
3
类型的上界决定了泛型的范围。

class MyArray {

}
public static void main(String[] args) {

    MyArray<Integer> myArray = new MyArray<>();
    MyArray<Boolean> myArray1 = new MyArray<Boolean>();
}

1
2
3
4
5
6
7

我们发现指定了泛型的上界为数值类Number时,传入Boolean类型就会报错。
如果没有指定类型的边界,可以认可 T extends Object,当指定了某个类型为上界,那么只接受某类型本身和子类型作为E的类型实参

上界为接口
我们要实现一个类去找数组的一个的最大值

这里报错了,因为我们这里是Object类型,如果是类型实参是对象的话不就能这样比较了,所以我们将上界定为Comparable接口。

class MyArray> {

public T findMax(T[] arr) {
    T max = arr[0];
    for (int i = 1; i < arr.length - 1; i++) {
        if (arr[i].compareTo(max) > 0) {
            max = arr[i];
        }
    }
    return max;
}

}
1
2
3
4
5
6
7
8
9
10
11
12
我们来求一个Integer类型的最大值。

public static void main(String[] args) {

    MyArray<Integer> myArray = new MyArray<>();
    Integer[] arr = {1,4,6,3,2};
    System.out.println(myArray.findMax(arr));
}

1
2
3
4
5

我们来求一个Person类的最大值。

我们发现使用Person作为类型实参,未法创建对象,因为我们将泛型上界设置为了实现了Comparable的类类型。

class Person implements Comparable{

public int age;

public Person(int age) {
    this.age = age;
}

@Override
public int compareTo(Person o) {
    return this.age - o.age;
}

@Override
public String toString() {
    return "Person{" +
            "age=" + age +
            '}';
}

}
public static void main(String[] args) {

    MyArray<Person> myArray = new MyArray<>();
    Person[] per = {new Person(15),new Person(18),new Person(20)};
    System.out.println(myArray.findMax(per));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

二、泛型方法
1 静态方法
刚刚我们实现的求某个类型数组的最大值必须得创建一个对象,那我们可以不创建对象直接调用吗?

我们直接给方法加上static时,系统报错了,因为static方法是在类加载指定,擦除机制是在编译时检查和强制转换,在类加载时,并不知道是什么类型,所以不能直接加static。
静态方法语法:

public static<泛型形参> T findMax(T[] arr)
1
class MyArray {

public static<T extends Comparable<T>>  T findMax(T[] arr) {
    T max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i].compareTo(max) > 0) {
            max = arr[i];
        }
    }
    return max;
}

}
public static void main(String[] args) {

    Integer[] arr = {1,5,4,7,9,2};
    Integer max = MyArray.findMax(arr);
    System.out.println(max);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

这样我们就可以不依赖对象求出最大值了,那类型实参在那里传?

一般在引用点的后面,一般可以省略。

2 普通方法
静态方法语法:

public <泛型形参> T findMax(T[] arr)
1
class MyArray {

public <T extends Comparable<T>>  T findMax(T[] arr) {
    T max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i].compareTo(max) > 0) {
            max = arr[i];
        }
    }
    return max;
}

}
public static void main(String[] args) {

    Integer[] arr = {1,5,4,7,9,2};
    MyArray myArray = new MyArray();
    System.out.println(myArray.findMax(arr));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

三、通配符
什么是通配符:? 用于在泛型的使用

1 通配符的引入
class Data {

public T data;

public T getData() {
    return data;
}

public void setData(T data) {
    this.data = data;
}

}
public static void main(String[] args) {

    Data<Integer> data = new Data<>();
    data.setData(18);
    print(data);
}
public static void print(Data<Integer> data) {
    System.out.println(data.getData());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

如果我们想输入类型实参为String类型呢?重写一个方法吗?支持重载吗?

我们当写入两种不同泛型类型的方法时,系统报错了,因为在运行阶段是没有泛型这个概念的,相当于他们的类型都是Data类型。
我们来验证一下,打印两种不同泛型实参类型的对象:

public static void main(String[] args) {

    Data<Integer> data = new Data<>();
    Data<String> data1 = new Data<>();
    System.out.println(data);
    System.out.println(data1);
}

1
2
3
4
5
6

我们发现打印出来对象的类型是一样的。

相关文章
|
1月前
|
设计模式 安全 Java
详解Java中的泛型(泛型的语法,擦除机制,泛型的上界)
详解Java中的泛型(泛型的语法,擦除机制,泛型的上界)
72 0
|
10月前
|
Java
Java泛型的协变和逆变
Java泛型的协变和逆变
50 0
|
10月前
|
Java
java泛型:泛型类,泛型接口,泛型方法,泛型集合
java泛型:泛型类,泛型接口,泛型方法,泛型集合
|
存储 安全 Java
Java泛型01:什么是泛型?
Java泛型01:什么是泛型?
93 0
Java泛型01:什么是泛型?
|
Java
Java泛型——泛型方法
Java泛型——泛型方法
131 0
泛型的上下限怎么理解
实体类 public class Fruit { } class Apple extends Fruit{} class Pear extends Fruit{} class Orange extends Fruit{} 复制代码 泛型的上限 如下图,可以看到这里是不允许再添加任何实例的,只能从该list中去获取实例。 为什么不能添加呢?🐖 因为这个list 可能有以下几个情况 list是Fruit类型的,此时你去添加Fruit的子类都没问题 list是Apple类型的,此时你只能添加Apple,同理Pear,Orange也是。🙃 根本不晓得传进来的参数list会是哪种类型
173 0
|
安全 Java 编译器
Java泛型的协变与逆变
ava作为一门面相对象的语言,当然是支持面相对象的三大基本特性的,反手就蹦出三个词:封装、继承、多态。
98 0
|
Java
【Java 泛型】泛型用法 ( 泛型编译期擦除 | 上界通配符 <? extends T> | 下界通配符 <? super T> )
【Java 泛型】泛型用法 ( 泛型编译期擦除 | 上界通配符 <? extends T> | 下界通配符 <? super T> )
154 0
【Java 泛型】泛型用法 ( 泛型编译期擦除 | 上界通配符 <? extends T> | 下界通配符 <? super T> )
|
存储 Java 程序员
Java语法糖之泛型与类型擦除
Java语法糖之泛型与类型擦除
150 0
Java语法糖之泛型与类型擦除
|
SQL 开发框架 .NET