85.java泛型类

泛型类

格式

2. 类上的泛型声明

          修饰符 class 类名<泛型>{
          
          }

import java.util.Arrays;

public class Demo6<T> {
    public static void main(String[] args) {
        // 使用泛型类，创建对象的时候需要指定具体的类型
        new Demo6<Integer>().getData(5);
    }

    public T getData(T data) {
        return data;
    }

    // 反序任意类型数组
    public void reverse(T[] arr) {
        int start = 0;
        int end = arr.length - 1;
        for (int i = 0; i < arr.length; i++) {
            if (start < end) {
                T temp = arr[start];
                arr[start] = arr[end];
                arr[end] = temp;
            }
        }
    
}

在泛型类中定义一个静态方法

public class Demo6<T> {
    public static void main(String[] args) {
        System.out.println(getData2(100));
    }

    public T getData(T data) {
        return data;
    }

    //静态方法
    public static T getData2(T data) {
        return data;
    }

}

 

 

 

注意：静态方法不可以使用类中定义的泛型

因为类中的泛型需要在对象初始化时指定具体的类型，而静态优先于对象存在。那么类中的静态方法就需要单独进行泛型声明，声明泛型一定要写在static后，返回值类型之前

泛型类细节：

1、创建对象的时候要指定泛型的具体类型
2、创建对象时可以不指定泛型的具体类型(和创建集合对象一眼)。默认是Object，例如我们使用集合存储元素的时候没有使用泛型就是那么参数的类型就是Object
3、类上面声明的泛型只能应用于非静态成员函数，如果静态函数需要使用泛型，那么
需要在函数上独立声明。
4、如果建立对象后指定了泛型的具体类型，那么该对象操作方法时，这些方法只能操作一种数据类型。
5、所以既可以在类上的泛型声明，也可以在同时在该类的方法中声明泛型。

泛型练习：

定义泛型成员

public class Demo7 {
    public static void main(String[] args) {
        Father<String> f = new Father<String>("jack");
        System.out.println(f.getT());
        Father<Integer> f2 = new Father<Integer>(20);
        System.out.println(f2.getT());
    }

}

class Father<T> {
    private T t;

    public Father() {

    }

    public Father(T t) {
        super();
        this.t = t;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

}

如果Father类有子类，子类该如何实现

public class Demo7 {
    public static void main(String[] args) {
        Father<String> f = new Father<String>("jack");
        System.out.println(f.getT());
        Father<Integer> f2 = new Father<Integer>(20);
        System.out.println(f2.getT());
    }

}

class Father<T> {
    private T t;

    public Father() {

    }

    public Father(T t) {
        super();
        this.t = t;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

}
//子类指定了具体的类型
class Son extends Father<String>{
    
}
//子类也需要使用泛型
class Son3<T> extends Father<T>{
    
}
//错误写法，父类上定义有泛型需要进行处理
class Son2 extends Father<T>{
    
}