大数据最全带你从零学大数据系列之Java篇---第十五章泛型

最新推荐文章于 2024-10-01 09:29:45 发布

2401_84182578

最新推荐文章于 2024-10-01 09:29:45 发布

阅读量300

点赞数 4

分类专栏：程序员文章标签： java 大数据开发语言

本文链接：https://blog.csdn.net/2401_84182578/article/details/138433342

版权

程序员专栏收录该内容

126 篇文章 0 订阅

订阅专栏

// 1. 声明引用
Animal<String> animal;
// 2. 实例化对象
Animal<Integer> animal = new Animal<>();
// 3. 访问静态成员
Animal<Integer>.display();
// 4. 被继承
class Dog extends Animal<String> {}
class Dog<T> extends Animal<T> {}

15.5.2. 泛型类的特点

在类中定义的泛型，虽然还不明确是什么类型，但是在当前类中是可以使用的。
在使用到这个类的时候，必须要指定泛型的类型。如果不指定，默认是 Object。
泛型，只能在当前的类中使用，不能在其他的类中使用，包括子类。

15.5.3. 示例代码

/**
 * @Description   泛型在类中的使用
 */
public class Test {
    public static void main(String[] args) {
        // 实例化一个对象
        // 指定了泛型的类型是 String 类型
        Person<String> xiaoming = new Person<>();
        // 泛型，是在编译前期进行的类型检查。一旦编译完成，泛型就不存在了。
        xiaoming.part = "xiaoming";

        Person<Integer> xiaohong = new Person<>();
        xiaohong.part = 2;

        // 实例化一个子类对象
        Student student = new Student();
        student.part = "abc";

        // 实例化一个泛型子类对象
        Teacher<Integer> xiaowang = new Teacher<>();
        xiaowang.part = 132;

        // 如果多个泛型，使用这个类的时候，逐个进行类型指派即可
        Animal<String, Integer> animal = new Animal<>();

        // 如果对于一个泛型类，在使用的时候，没有指派类型，默认是 Object 类型
        Person xiaobai = new Person();
    }
}

class Animal<T, M> { }

class Person<T> {
    String name;
    int age;
    T part;     // 虽然现在还不明确T是什么类型，但是我们可以使用这个类型。
}

class Student extends Person<String> {}

class Teacher<E> extends Person<E> { }14.6. 泛型在接口中的使用

15.6.1. 语法部分

**泛型接口的定义：**在接口名字的后面，添加上一对尖括号。在尖括号里面定义泛型。

interface MyInterface<T> {}
interface MyInterface<T, M> {}

**泛型接口的使用：**实现类实现接口、使用接口访问接口中的静态成员、被继承。

// 1. 实现类实现接口
class MyInterface1Impl implements MyInterface1<Person> {}
// 2. 使用接口访问接口中的静态成员
MyInterface<String>.test();
// 3. 被继承
interface SubMyInterface extends MyInterface1<String> {}

15.6.2. 泛型接口的特点

在接口中定义的泛型，虽然还不明确是什么类型，但是在当前接口中是可以使用的。
在使用到这个接口的时候，必须要指定泛型的类型。如果不指定，默认是 Object。
泛型，只能在当前的接口中使用，不能在其他的接口中使用，包括子接口。

15.6.3. 示例代码

/**
 * @Description 泛型接口的使用
 */
public class Test {
    public static void main(String[] args) {
        // 使用匿名内部类的形式实现接口
        MyInterface1<Person> impl = new MyInterface1<Person>() {
            @Override
            public int compareTo(Person o1, Person o2) {
                return 0;
            }
        };
        // 使用lambda表达式实现接口
        // 此时，会根据左侧的接口引用中的泛型，推导出接口实际指派的类型是谁
        MyInterface1<Person> impl1 = (o1, o2) -> o1.age - o2.age;
        MyInterface1<String> impl2 = (o1, o2) -> o1.length() - o2.length();
    }
}

// 定义一个泛型接口
interface MyInterface1<T> {
    int compareTo(T o1, T o2);
}

// 子接口
interface SubMyInterface extends MyInterface1<String> {}

// 实现类
class MyInterface1Impl implements MyInterface1<Person> {
    @Override
    public int compareTo(Person o1, Person o2) {
        return 0;
    }
}

class Person {
    int age;
}