🔥作者主页:小林同学的学习笔录
🔥mysql专栏:小林同学的专栏
目录
简单化知识点,让你彻底了解泛型
1.泛型的认识
Java泛型是一种在Java编程语言中用来创建泛型类、接口和方法的机制。泛型提供了在编译时期
进行类型检查和类型安全的方法,使得程序员可以在编写代码时指定类、接口或方法可以操作的数
据类型,而不必在实际使用时再指定类型。
注意:泛型只能支持引用数据类型,不支持基本数据类型,但是可以用对应的包装类来实现。如果没有指定集合的泛型,默认是Object。
使用泛型的好处包括:
- 类型安全:泛型可以在编译时检查类型,避免了在运行时出现类型转换错误。
- 代码重用:泛型可以使代码更加通用,可以用于多种类型的数据。
- 简化代码:泛型可以减少代码的重复量,提高代码的可读性和可维护性。
- Get获取数据不需要强转类型或者迭代器遍历元素时也不需要强转。
java 中泛型标记符:
- E - Element (在集合中使用,因为集合中存放的是元素)
- T - Type(Java 类)
- K - Key(键)
- V - Value(值)
- N - Number(数值类型)
- ? - 表示不确定的 java 类型
下面代码将包括泛型类,泛型方法,泛型接口进行说明
// 定义一个泛型类
class Box<T> {
private T content;
// 构造函数
public Box(T content) {
this.content = content;
}
// 获取盒子中的内容
public T getContent() {
return content;
}
// 设置盒子中的内容
public void setContent(T content) {
this.content = content;
}
}
// 定义一个泛型方法
class Util {
// 泛型方法示例:交换数组中两个元素的位置
// 注意:
// 1.只有声明了<T>的方法才是泛型方法,泛型类中的使用了泛型的成员方法并不是泛型方法。
// 2.<T>表明该方法将使用泛型类型T,此时才可以在方法中使用泛型类型T。
public static <T> void swap(T[] array, int i, int j) {
T temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
// 定义一个泛型接口
interface Pair<K, V> {
K getKey();
V getValue();
}
// 实现泛型接口
class OrderedPair<K, V> implements Pair<K, V> {
private K key;
private V value;
public OrderedPair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() {
return key;
}
public V getValue() {
return value;
}
}
public class Main {
public static void main(String[] args) {
// 使用泛型类
Box<Integer> integerBox = new Box<>(10);
System.out.println("Box contains: " + integerBox.getContent());
// 使用泛型方法
String[] names = {"Alice", "Bob"};
Util.swap(names, 0, 1);
System.out.println("Swapped names: " + names[0] + " and " + names[1]);
// 使用泛型接口
Pair<String, Integer> pair = new OrderedPair<>("one", 1);
System.out.println("Key: " + pair.getKey() + ", Value: " + pair.getValue());
}
}
2.泛型类
泛型类定义相对比较简单
泛型类,是在实例化类的时候指明泛型的具体类型
// 定义一个泛型类
class Box<T> {
private T content;
// 构造函数
public Box(T content) {
this.content = content;
}
// 获取盒子中的内容
public T getContent() {
return content;
}
// 设置盒子中的内容
public void setContent(T content) {
this.content = content;
}
}
3.泛型方法
这里需要注意的是,很多人分不清泛型方法和使用泛型方法
泛型方法一定有<T>定义泛型,然后在参数列表使用泛型
使用泛型方法是通过拿类或者接口所定义的泛型来使用
// 定义一个泛型方法
class Util {
// 泛型方法示例:交换数组中两个元素的位置
// 注意:
// 1.只有声明了<T>的方法才是泛型方法,泛型类中的使用了泛型的成员方法并不是泛型方法。
// 2.<T>表明该方法将使用泛型类型T,此时才可以在方法中使用泛型类型T。
public static <T> void swap(T[] array, int i, int j) {
T temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
4.泛型接口
泛型接口和泛型类定义基本一致
// 定义一个泛型接口
interface Pair<K, V> {
K getKey();
V getValue();
}
5.特别强调
- 1.只有声明了<T>的方法才是泛型方法,泛型类中的使用了泛型的成员方法并不是泛型方法。
- 2.<T>表明该方法将使用泛型类型T,此时才可以在方法中使用泛型类型T。
- 3.注意泛型类型参数只能代表引用型类型,不能是原始类型(像 int、double、char 等)
- 4.静态方法无法访问类上定义的泛型;如果静态方法操作的引用数据类型不确定的时候,必须要将泛型定义在方法上。
public class Model<T> {
....
....
/**
* 如果在类中定义使用泛型的静态方法,需要添加额外的泛型声明(将这个方法定义成泛型方法)
* 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
* 如:public static void demo(T t){..},此时编译器会提示错误信息:
"StaticGenerator cannot be refrenced from static context"
*/
public static <T> void demo(T t){
}
}
6.类型通配符
类型通配符一般是使用 ? 代替,表示不确定的类型,他可以进行类型的限定
?extends E:表示可以传递E或者E的所有子类
? super E:表示可以传递E或者E的所有父类
import java.util.*;
public class GenericTest {
public static void main(String[] args) {
List<String> name = new ArrayList<String>();
List<Integer> age = new ArrayList<Integer>();
List<Number> number = new ArrayList<Number>();
name.add("icon");
age.add(18);
number.add(314);
getData(name);
getData(age);
getData(number);
}
public static void getData(List<?> data) {
System.out.println("data :" + data.get(0));
}
}
7.应用场景
1.如果在定义类、方法、接口的时候,如果类型不确定,就可以定义泛型类、泛型方法、泛型接口
2.如果类型不确定,但是能知道以后只能传递某个继承体系,就可以使用使用通配符