java 泛型类

泛型的概念

java泛型，是jdk1.5引入的一个新特性，泛型提供了编译时类型检测机制，该机制允许我们在编译时检测到非法的类型数据结构。

• 编译器检查
• 减少了数据类型转换

泛型类

泛型类声明语法

class 类名 <泛型标识，泛型标识.....> {
  private 泛型标识 变量名；
}

public class Generic<T> {
    private T key;

    public T getKey() {
        return key;
    }
    public void setKey(T key) {
        this.key = key;
    }
    public Generic(T key) {
        super();
        this.key = key;
    }
    @Override
    public String toString() {
        return "Generic [key=" + key + "]";
    }
}

泛型类使用语法

类名<具体的数据类型> 对象名 = new 类名<具体的数据类型>();

jdk1.7之后：
类名<具体的数据类型> 对象名 = new 类名<>();

public class MainClass {

    public static void main(String[] args) {
        Generic<String>strGen = new Generic<>("hello world");
        Generic<Integer>intGen = new Generic<>(100);
        
        // 泛型类不支持基本数据类型
//      Generic<int>intbaseGen = new Generic<>(100); error
        // 泛型类创建对象，没有指定类型，将按照object类型处理
        Generic objGen = new Generic("hello world");
        
        // 泛型类型本质都是相同的类类型
        System.out.println(strGen.getClass()); //class com.test.generic.Generic
        System.out.println(intGen.getClass()); //class com.test.generic.Generic
        System.out.println(objGen.getClass()); //class com.test.generic.Generic
    }
}

泛型类使用

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class ProductGet <T>{
    private T product; //奖品
    Random random = new Random();
    List<T>list = new ArrayList<>(); // 奖品池
    // 添加奖品
    public void addPro(T t) {
        list.add(t);
    }
    // 抽奖
    public T getPro() {
        product = list.get(random.nextInt(list.size()));
        return product;
    }
    
    public static void main(String[] args) {
        ProductGet<String> strProGet = new ProductGet<>();
        String[]strProArr = {"小米pad","华为手机","苹果pad","扫地机器人"};   
        for (int i = 0; i < strProArr.length; i++) {
            strProGet.addPro(strProArr[i]);
        }
        
        String Strpro = strProGet.getPro();
        System.out.println("获得了："+Strpro);
        
        System.out.println("-----------------");
        ProductGet<Integer>intProGet = new ProductGet<>();
        int[]intProArr = {200, 1000, 3000, 10000};   
        for (int i = 0; i < intProArr.length; i++) {
            intProGet.addPro(intProArr[i]);
        }
        int intPro = intProGet.getPro();
        System.out.println("获得了："+intPro);
    }
}

泛型类派生子类

1. 子类也是泛型类，子类和父类的泛型类型要一致
class ChildGeneric<T> extends Generic<T>
2. 子类不是泛型类，父类要明确泛型数据类型
class ChildGeneric extends Generic<String>

Parent

public class Parent<T> {
    private T val;

    public T getVal() {
        return val;
    }
    public void setVal(T val) {
        this.val = val;
    }
}

ChildFirst 子类也是泛型类

/**
 * 子类也是泛型类，子类的泛型类型要和父类的泛型类型一致
 * 子类可以进行泛型扩展
 * @param <T> 泛型类型
 */
public class ChildFirst<T,E,K> extends Parent<T> {
    @Override
    public T getVal() {
        return super.getVal();
    }
}

ChildSecond 子类不是泛型类

/**
 * 子类不是泛型类，父类要明确泛型数据类型
 */
public class ChildSecond extends Parent<String> {

    @Override
    public String getVal() {
        return super.getVal();
    }
}

泛型接口

interface 接口名称<泛型标识，泛型标识,....> {
    泛型标识 方法名();
}

1. 实现类不是泛型类，接口要明确数据类型
2. 实现类也是泛型类，实现类和接口的泛型类型要一致

public interface Generic<T> {
    T getKey();
}

public class Generic1Impl implements Generic<String>{

    @Override
    public String getKey() {
        return null;
    }
}
public class Generic2Impl<T> implements Generic<T> {
    @Override
    public T getKey() {
        return null;
    }
}