Java高级特性：泛型、集合框架和异常处理
引言
在前两篇文章中，我们探讨了Java的基本语法和面向对象编程（OOP）特性。在本篇文章中，我们将深入研究Java的一些高级特性，包括泛型、集合框架和异常处理。这些特性可以帮助你编写更加灵活和健壮的代码。
泛型（Generics）
泛型允许类、接口和方法操作任意类型（类型参数），从而提高代码的重用性和类型安全性。
泛型类
定义一个泛型类时，可以使用类型参数，例如 T：
java
public class Box<T> {
private T content;
public void setContent(T content) {
this.content = content;
}
public T getContent() {
return content;
}
public static void main(String[] args) {
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello");
System.out.println("String Box: " + stringBox.getContent());
Box<Integer> intBox = new Box<>();
intBox.setContent(123);
System.out.println("Integer Box: " + intBox.getContent());
}
}泛型方法
泛型方法允许方法在被调用时指定类型参数：
java
public class GenericMethodExample {
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.println(element);
}
}
public static void main(String[] args) {
Integer[] intArray = {1, 2, 3, 4, 5};
String[] strArray = {"A", "B", "C"};
System.out.println("Integer Array:");
printArray(intArray);
System.out.println("String Array:");
printArray(strArray);
}
}有界类型参数
你可以限制泛型类型参数的范围：
java
public class BoundedTypeParameterExample {
public static <T extends Number> void printNumber(T number) {
System.out.println("Number: " + number);
}
public static void main(String[] args) {
printNumber(123); // Integer
printNumber(45.67); // Double
// printNumber("Hello"); // 编译错误
}
}集合框架（Collections Framework）
Java集合框架提供了一组类和接口来存储和操作数据元素。常用的集合包括List、Set和Map。
List
List是一个有序的集合，允许重复元素。常用的实现类有ArrayList和LinkedList。
java
import java.util.ArrayList;
import java.util.List;
public class ListExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");
System.out.println("List: " + list);
for (String fruit : list) {
System.out.println("Fruit: " + fruit);
}
list.remove("Banana");
System.out.println("List after removal: " + list);
}
}Set
Set是一个不允许重复元素的集合。常用的实现类有HashSet和TreeSet。
java
import java.util.HashSet;
import java.util.Set;
public class SetExample {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Orange");
set.add("Apple"); // 重复元素
System.out.println("Set: " + set);
for (String fruit : set) {
System.out.println("Fruit: " + fruit);
}
set.remove("Banana");
System.out.println("Set after removal: " + set);
}
}Map
Map是一个键值对集合。常用的实现类有HashMap和TreeMap。
java
import java.util.HashMap;
import java.util.Map;
public class MapExample {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
map.put("Orange", 3);
System.out.println("Map: " + map);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}
map.remove("Banana");
System.out.println("Map after removal: " + map);
}
}异常处理（Exception Handling）
异常处理是Java中的一个重要机制，用于处理程序执行过程中发生的异常情况。Java提供了多种异常类以及try-catch语句来处理异常。
try-catch 语句
使用try-catch语句可以捕获并处理异常：
java
public class ExceptionHandlingExample {
public static void main(String[] args) {
try {
int result = divide(10, 0);
System.out.println("Result: " + result);
} catch (ArithmeticException e) {
System.out.println("Exception caught: " + e.getMessage());
}
}
public static int divide(int a, int b) {
return a / b;
}
}多个catch块
你可以使用多个catch块来捕获不同类型的异常：
java
public class MultipleCatchExample {
public static void main(String[] args) {
try {
int[] numbers = {1, 2, 3};
System.out.println(numbers[5]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Array index out of bounds: " + e.getMessage());
} catch (Exception e) {
System.out.println("Exception caught: " + e.getMessage());
}
}
}finally块
finally块中的代码总是会执行，无论是否发生异常：
java
public class FinallyBlockExample {
public static void main(String[] args) {
try {
int result = divide(10, 0);
System.out.println("Result: " + result);
} catch (ArithmeticException e) {
System.out.println("Exception caught: " + e.getMessage());
} finally {
System.out.println("This is the finally block.");
}
}
public static int divide(int a, int b) {
return a / b;
}
}自定义异常
你可以创建自己的异常类：
java
class CustomException extends Exception {
public CustomException(String message) {
super(message);
}
}
public class CustomExceptionExample {
public static void main(String[] args) {
try {
checkAge(15);
} catch (CustomException e) {
System.out.println("Exception caught: " + e.getMessage());
}
}
public static void checkAge(int age) throws CustomException {
if (age < 18) {
throw new CustomException("Age must be at least 18");
}
}
}总结
在本篇文章中，我们深入探讨了Java的高级特性，包括泛型、集合框架和异常处理。泛型使得代码更加灵活和类型安全，集合框架提供了丰富的数据结构，而异常处理则帮助我们编写健壮的代码。掌握这些特性将极大地提升你的Java编程技能。
在接下来的文章中，我们将继续探索Java的更多高级特性和实际应用，包括并发编程、文件I/O和网络编程等。希望你能继续关注并享受学习的过程！
如果你有任何问题或需要进一步的解释，请在评论区留言。我们将尽快回复。感谢阅读！