为什么需要用泛型?
示例
以下是一个栈的实现代码
package FFF;
public class Test {
public static void main(String[] args) {
Stack stack=new Stack(5);
stack.add(1);
stack.add(2);
stack.add(3);
stack.add(4);
System.out.println(stack.get());
System.out.println(stack.get());
System.out.println(stack.get());
System.out.println(stack.get());
}
}
package FFF;
/***
* 定义一个栈
* 数据先进后出
*/
public class Stack {
//定义数组
private int[] arr;
private int i=-1;
public Stack(int size){
arr=new int[size];
}
public void add(int value){
i++;
arr[i]=value;
}
public int get(){
return arr[i--];
}
}
如果我们定义只能在栈当中存储一种数据类型,如果想要存储其他数据类型,需要对private int[] arr; 数组的类型进行修改
这样的话,每次存储不同数据类型的数组,就需要更改定义,这是十分麻烦的。
因此,我们需要用泛型定义数据,因为泛型能够代表一切类型
泛型类的定义
泛型类的定义语法
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());
}
我们可以将最开始的例子中数组类型定义为泛型
package FFF;
/***
* 定义一个栈
* 数据先进后出
*/
public class Stack <T>{
//定义数组
private T[] arr;
private int i=-1;
public Stack(int size){
arr= (T[]) new Object[size];//Object是所有数据类型的父类,父类转化为子类需要进行强转 }
public void add(T value){
i++;
arr[i]=value;qi
}
public T get(){
return arr[i--];
}
}
package FFF;
public class Test {
public static void main(String[] args) {
Stack<Integer> stack=new Stack(5);//泛型当中只能用到包装类
stack.add(1);
stack.add(2);
stack.add(3);
stack.add(4);
System.out.println(stack.get());
System.out.println(stack.get());
System.out.println(stack.get());
System.out.println(stack.get());
Stack<String> stack1=new Stack(5);
stack1.add("北京");
stack1.add("保定");
stack1.add("沧州");
stack1.add("石家庄");
System.out.println(stack1.get());
System.out.println(stack1.get());
System.out.println(stack1.get());
System.out.println(stack1.get());
}
}
总结:泛型类注意事项
- 泛型类,如果没有指定具体的数据类型,此时,操作类型是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();//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>
第一种情况:子类和父类的泛型类型要保持一致
定义父类
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);
}
第二种情况:子类没有使用 泛型
总结:子类不是泛型类,父类要明确泛型类的数据类型
泛型接口
泛型接口的语法定义
interface 接口名称 <泛型标识,泛型标识,...>{
泛型标识 方法名();
......
}
泛型接口的使用(2种情况)
- 实现类不是泛型类,接口要明确数据类型
- 实现类也是泛型类,实现类和接口的泛型类型要一致
总结
- 泛型的优势:提升代码的重用性和类型安全,避免在运行时出现类型错误。
- 设计灵活的泛型类和接口,使得它们能够用于不同类型的数据,减少类型转换的需要。
- 关注泛型的限制与注意事项,确保代码的可读性和可维护性。
欢迎大家点赞,评论,收藏和关注呦!!