Java泛型是一項強大的編程特性，為程序員提供了一種靈活、類型安全、可重用的編碼方式。通過泛型，我們能夠編寫更加通用、適應(yīng)多種數(shù)據(jù)類型的代碼，從而提高了代碼的靈活性和可維護性。在這篇博客中，我們將深入探討Java泛型的各個方面，并通過具體的例子來展示其用法和優(yōu)勢。
1. 泛型類和泛型方法
在以下代碼中，printArray 方法使用了泛型類型參數(shù) T，允許我們在運行時指定具體的類型。這種方式使得我們可以編寫通用的方法來處理不同類型的數(shù)組。
public class Print {
/**
* 打印數(shù)組
* @param inputArray
* @param <T>
*/
public static <T> void printArray(T[] inputArray) {
for (T element : inputArray) {
System.out.printf("%s ", element);
}
System.out.println();
}
/**
* 打印整數(shù)數(shù)組
* @param inputArray
*/
public static void IntPrintArray(Integer[] inputArray) {
for (Integer element : inputArray) {
System.out.printf("%s ", element);
}
System.out.println();
}
/**
* 打印字符串數(shù)組
* @param inputArray
*/
public static void StrPrintArray(String[] inputArray) {
for (String element : inputArray) {
System.out.printf("%s ", element);
}
System.out.println();
}
}然后，我們通過一個示例程序 Method01 來展示泛型方法的應(yīng)用：
/**
* @ClassName: Method01
* @Description: 方法1 感受泛型的好處，泛型方法
* @Author: liu
* @Date: 2024-03-09
* @Version: 1.0
**/
public class Method01 {
public static void main(String[] args) {
String[] stringArray = {"Hello", "World"};
Integer[] integerArray = {1, 2, 3, 4, 5};
System.out.println("字符串數(shù)組包含:");
//StringPrint方法
Print.StrPrintArray(stringArray);
//編譯失敗 類型不一致
//Print.StrPrintArray(integerArray);
//泛型方法
Print.printArray(stringArray);
System.out.println("\n整數(shù)數(shù)組包含:");
//IntegerPrint方法
Print.IntPrintArray(integerArray);
//編譯失敗 類型不一致
//Print.IntPrintArray(stringArray);
//泛型方法，提高代碼可用性
Print.printArray(integerArray);
System.out.println("\n整數(shù)數(shù)組包含:");
Object[] objectArray = {1, 2, 3, 4, 5, "Hello", "World"};
Print.printArray(objectArray);
}
}在上述示例中，我們調(diào)用了 printArray 方法，分別傳遞了字符串數(shù)組和整數(shù)數(shù)組。由于泛型的存在，我們能夠使用相同的方法處理不同類型的數(shù)據(jù)，提高了代碼的可重用性。
再舉個例子
/**
* @ClassName: Method03
* @Description: 方法3 可以存儲任意類型的數(shù)據(jù)
* @Author: liu
* @Date: 2024-03-09
* @Version: 1.0
**/
public class Method3 {
public static void main(String[] args) {
// 創(chuàng)建一個存儲整數(shù)的 Box 實例
Box<Integer> integerBox = new Box<>();
integerBox.setValue(42);
System.out.println("Integer Value: " + integerBox.getValue());
// 創(chuàng)建一個存儲字符串的 Box 實例
Box<String> stringBox = new Box<>();
stringBox.setValue("Hello, Generics!");
System.out.println("String Value: " + stringBox.getValue());
// 創(chuàng)建一個存儲布爾值的 Box 實例
Box<Boolean> booleanBox = new Box<>();
booleanBox.setValue(true);
System.out.println("Boolean Value: " + booleanBox.getValue());
}
}
@Data
class Box<T> {
private T value;
}
2. 泛型上限和下限通配符
首先，讓我們來看一個簡單的泛型類和泛型方法的例子?？紤]到動物（Animals）和貓（Cat）、狗（Dog）的實體類：
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Animals {
public String name;
public Integer age;
}
@Data
public class Cat {
public String name;
public Integer age;
public Say say;
public Cat(String name, Integer age, Say say) {
this.name = name;
this.age = age;
this.say = say;
System.out.println("Cat的全參構(gòu)造執(zhí)行，貓邊唱歌吃魚");
}
public Cat() {
System.out.println("Cat的無參構(gòu)造執(zhí)行，你創(chuàng)建了貓，卻一笑而過！");
}
}
@EqualsAndHashCode(callSuper = true)
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Dog extends Animals {
public String name;
public Integer age;
}
@Data
public class Say {
public String say;
public Say(String say) {
this.say = say;
System.out.println("說話" + say);
}
}
接下來，我們將介紹泛型上限和下限通配符的概念，并通過例子 Method02 進行演示。
/**
* @ClassName: Method02
* @Description: 方法2, 泛型上限和下限通配符
* @Author: liu
* @Date: 2024-03-09
* @Version: 1.0
**/
public class Method02 {
public static void main(String[] args) {
/* Cat cat = new Cat();
Dog dog1 = new Dog("旺財", 3);
Cat cat1 = new Cat("小花", 2, new Say("喵喵喵"));
Animals animal1 = new Animals("小動物", 1);
List<Dog> dogList = new ArrayList<>();
List<Cat> catList = new ArrayList<>();
List<Animals> animalsList = new ArrayList<>();
animalsList.add(animal1);
dogList.add(dog1);
catList.add(cat1);*/
// 使用菱形操作符和雙括號初始化簡化代碼
// 在匿名內(nèi)部類中，Java 并不允許使用 <> 進行菱形操作符的類型推斷，還可以使用 Arrays.asList() 方法
List<Dog> dogList = new ArrayList<Dog>(){
private static final long serialVersionUID = -3322276720822396481L;
{
add(new Dog("狗王", 2));
add(new Dog("狗王后", 3));
}};
List<Cat> catList = Arrays.asList(
new Cat("貓王", 1, new Say("喵~")),
new Cat()
);
List<Animals> animalsList = new ArrayList<Animals>(){
private static final long serialVersionUID = 1L;
{
add(new Animals("小動物", 1));
}};
//reason: no instance(s) of type variable(s) exist so that Cat conforms to Animals
//extendMethod(catList);// 編譯報錯
// 泛型方法調(diào)用示例
extendMethod(dogList); // 合法，List<Dog> 是 List<? extends Animals> 的子類
extendMethod(animalsList); // 合法，List<Animals> 是 List<? extends Animals> 的子類
System.out.println("=====================================");
superMethod(dogList); // 合法
//編譯報錯，List<Cat> 不是 List<? super Dog> 的子類
//superMethod(catList);
//編譯合法，運行報錯UnsupportedOperationException
//superMethod(Collections.unmodifiableList(catList));
superMethod(animalsList); // 合法
}
public static <T extends Animals> void extendMethod(List<T> list) {
// 在這里處理只包含數(shù)字類型及其子類的列表
for (T element : list) {
System.out.println(element);
}
}
public static void superMethod(List<? super Dog> list) {
// 在這里處理只包含數(shù)字類型及其父類的列表
list.add(new Dog("二狗", 2));
//list.add(new Animals("Buddy", 2)); // 編譯報錯
for (Object element : list) {
System.out.println(element);
}
}
}在上述代碼中，extendMethod 方法接受一個泛型列表，其中的元素必須是 Animals 類型或其子類。而 superMethod 方法則接受一個泛型列表，其中的元素必須是 Dog 類型或其父類。這樣的靈活性使得我們能夠?qū)Σ煌瑢哟蔚念愡M行處理。
在 Method02 的示例程序中，我們演示了泛型上限和下限通配符的使用：
在這個示例中，我們展示了如何使用泛型上限和下限通配符來處理不同類型的列表，使得我們的代碼更具通用性和靈活性。
3. 靈活處理多個泛型參數(shù)
在實際的編程場景中，有時我們需要處理多個泛型參數(shù)的情況。在這個章節(jié)，將探討如何在Java中靈活地處理多個泛型參數(shù)，以滿足更為復(fù)雜的編碼需求。
代碼如下：
/**
* @ClassName: Method04
* @Description: 演示帶有多個泛型參數(shù)的Pair類的使用
* @Author: 阿水
* @Date: 2024-03-10
* @Version: 1.0
**/
public class Method04 {
public static void main(String[] args) {
// 創(chuàng)建一個帶有泛型參數(shù)的Pair實例
Pair<Dog, Cat> pair = new Pair<>();
// 創(chuàng)建狗和貓的實例
Dog dog = new Dog("旺財", 3);
Cat cat = new Cat("小花", 2, new Say("喵喵喵"));
// 設(shè)置Pair實例的值
pair.setFirst(dog);
pair.setSecond(cat);
// 打印Pair實例的字符串表示形式以及其中的元素
System.out.println(pair);
System.out.println("First Element: " + pair.getFirst().getName());
System.out.println("Second Element: " + pair.getSecond().getName());
// 創(chuàng)建帶有不同泛型參數(shù)的兩個Pair實例
Pair<String, Integer> pair1 = new Pair<>("One", 1);
Pair<Double, String> pair2 = new Pair<>(6.66, "Pi");
// 調(diào)用泛型方法打印Pair實例的值
printPair(pair1);
printPair(pair2);
}
/**
* 打印帶有泛型參數(shù)的Pair實例的值
*
* @param pair 帶有泛型參數(shù)的Pair實例
* @param <T> 第一個元素的類型
* @param <U> 第二個元素的類型
*/
public static <T, U> void printPair(Pair<T, U> pair) {
System.out.println("Pair: " + pair.getFirst() + ", " + pair.getSecond());
}
}
/**
* @ClassName: Pair
* @Description: 帶有兩個泛型參數(shù)的Pair類
* @Author: 阿水
* @Date: 2024-03-10
* @Version: 1.0
**/
@Data
@AllArgsConstructor
@NoArgsConstructor
class Pair<T, U> {
private T first;
private U second;
}
運行結(jié)果如下:
文章來源：http://www.zghlxwxcb.cn/news/detail-842132.html
4.總結(jié)
Java泛型是一項強大的編程特性，通過泛型類和泛型方法，我們能夠編寫通用、靈活的代碼。同時，泛型上限和下限通配符使得我們能夠更好地處理不同層次的類。通過這篇博客，我們深入理解了Java泛型的靈活性、安全性和可重用性，為我們的編程工作提供了更多的便利和可能性。文章來源地址http://www.zghlxwxcb.cn/news/detail-842132.html
到了這里，關(guān)于深入理解Java泛型：靈活、安全、可重用的編程利器的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
