学java 怎么能不会泛型呢!
一、泛型类的定义
泛型类的定义语法
class 类名称 <泛型标识、泛型标识,...> {
private 泛型标识 变量名;
......
}
常用的泛型标识 T、E、K、V
案例
/**
* 泛型类的定义
* @param <T> 泛型标识-----类型形参
* T 创建对象的时候里面具体制定的数据类型
*/
public class Generic<T> {
// T 是由外部使用类的时候来指定的。
private T key;
public Generic(T key) {
this.key = key;
}
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
@Override
public String toString() {
return "Generic{" +
"key=" + key +
'}';
}
}
二、泛型类的使用语法
使用语法
类名<具体的数据类型> 对象名 = new 类名<具体的数据类型>();
java 1.7以后,后边的<>中具体的数据类型可以省略不写
类名<具体的数据类型> 对象名 = new 类名<>();
案例
public static void main(String[] args) {
// 泛型类在创建对象的时候来指定操作的具体数据类型
Generic<String> stringGeneric = new Generic<>("a");
String key = stringGeneric.getKey();
System.out.println("key:" + key);
System.out.println("------------------------");
Generic<Integer> integerGeneric = new Generic<>(100);
Integer key1 = integerGeneric.getKey();
System.out.println("key1:"+key1);
// 总结:泛型的本质是参数化类型,也就是所操作的数据类型被指定为一个参数。
System.out.println("----------注意点1:--------------");
// 泛型类在创建对象的时候,没有指定泛型类,将按照Object类型来操作
Generic generic = new Generic("ABC");
Object key3 = generic.getKey();
System.out.println("key3:"+key3);
System.out.println("----------注意点2:--------------");
// 泛型类不支持基本数据类型,原因就是我们在编译期间会将这个 T 编译成 Object
// 基本数据类型无法转化为 object类型
// Generic<int> intGeneric = new Generic<>(100);
System.out.println("----------注意点3:--------------");
// 同一泛型类,根据不同的数据类型创建的对象,本质上是同一类型
System.out.println(integerGeneric.getClass() == stringGeneric.getClass());
}
总结
泛型类,如果没有指定具体的数据类型,此时,操作类型是Object
泛型的类型参数只能是类类型,不能是基本数据类型
泛型类型在逻辑上可以看成是多个不同的类型,但实际上是相同类型
例题
年终抽奖器
/**
* 抽奖器
* @param <T>
*/
public class ProductGetter<T> {
//奖金或者奖品
private T product;
// 定义奖品、奖金池
ArrayList<T> arrayList = new ArrayList<>();
// 添加奖品到奖品池
public void addProduct(T t){
arrayList.add(t);
}
// 定义一个随机数,用来抽选奖品
Random random = new Random();
//抽奖
public T getProduct(){
product = arrayList.get(random.nextInt(arrayList.size()));
return product;
}
}
public static void main(String[] args) {
ProductGetter<String> stringProductGetter = new ProductGetter<>();
String[] strPro = {"苹果手机","华为手机","扫地机器人","咖啡机"};
//将奖品放入奖金池
for (int i = 0;i< strPro.length;i++){
stringProductGetter.addProduct(strPro[i]);
}
String product = stringProductGetter.getProduct();
System.out.println("恭喜您抽中了:"+product);
System.out.println("******************************");
ProductGetter<Integer> IntegerProductGetter = new ProductGetter<>();
Integer[] intPro = {100,1000,10000,20000};
//将奖品放入奖金池
for (int i = 0;i< intPro.length;i++){
IntegerProductGetter.addProduct(intPro[i]);
}
Integer product1 = IntegerProductGetter.getProduct();
System.out.println("恭喜您,获的了:"+product1+"元");
}
三、从泛型类派生子类(2种情况)
子类也是泛型类,子类和父类的泛型类型要保持一致
class ChildGeneric<T> extends Generic<T>
子类不是泛型类,父类要明确泛型类的数据类型
class ChildGeneric extends Generic<String>
第一种情况:子类和父类的泛型类型要保持一致
如果父类不指定数据类型默认是Object。当和子类指定不同的数据类型的时候就会报错。
父类
public class Parent<E> {
private E value;
public E getValue() {
return value;
}
public void setValue(E value) {
this.value = value;
}
}
子类
/**
* 泛型类派生子类,如果子类也是泛型类,子类的泛型标识要和父类一致。
* @param <T>
*/
public class ChildFirst<T> extends Parent<T> {
@Override
public T getValue() {
return super.getValue();
}
}
测试类
public static void main(String[] args) {
ChildFirst<String> childFirst = new ChildFirst<>();
childFirst.setValue("123");
String value = childFirst.getValue();
System.out.println(value);
}
第二种情况:子类没有使用 泛型
当子类没有使用泛型的时候,父类的泛型类操作的就是一个Object,可以从重写的getValue()方法的返回值看出来。
在这个地方我们无法指定泛型,因为在创建子类对象的时候,我无法确定父类的泛型使用的数据类型。
这时我们需要明确他的数据类型。
总结:子类不是泛型类,父类要明确泛型类的数据类型
四、泛型接口
泛型接口的语法定义
interface 接口名称 <泛型标识,泛型标识,...>{
泛型标识 方法名();
......
}
泛型接口的使用(2种情况)
实现类不是泛型类,接口要明确数据类型
实现类也是泛型类,实现类和接口的泛型类型要一致
五、泛型的好处
类型安全:泛型提供了编译时类型检查机制,减少因类型转换导致的ClassCastException。
消除强制类型转换:在使用泛型后,很多情况下都不需要再进行强制类型转换,代码更加简洁。
提高代码重用性:通过泛型编写的代码可以被不同类型的对象所重用。
总结
Java泛型是一个非常强大的特性,它使得Java代码更加安全、更加灵活、更加易于维护。通过泛型,我们可以编写出更加通用的代码,提高代码的重用性。同时,泛型也提高了代码的可读性和可维护性,使得代码更加易于理解和修改。