以下是Java语言最有特色的几个特性的代码示例，按特性分组展示：
面向对象编程 (OOP)
Java是一种面向对象的编程语言，支持封装、继承和多态等面向对象的特性。
// 封装
class Car {
private String brand;
private int price;
public void setBrand(String brand) {
this.brand = brand;
}
public void setPrice(int price) {
this.price = price;
}
public void displayInfo() {
System.out.println("Brand: " + brand);
System.out.println("Price: " + price);
}
}
// 继承
class ElectricCar extends Car {
private int batteryCapacity;
public void setBatteryCapacity(int batteryCapacity) {
this.batteryCapacity = batteryCapacity;
}
public void displayInfo() {
super.displayInfo();
System.out.println("Battery Capacity: " + batteryCapacity);
}
}
// 多态
public class Main {
public static void main(String[] args) {
Car car1 = new Car();
car1.setBrand("Toyota");
car1.setPrice(20000);
car1.displayInfo();
ElectricCar car2 = new ElectricCar();
car2.setBrand("Tesla");
car2.setPrice(50000);
car2.setBatteryCapacity(75);
car2.displayInfo();
}
}异常处理 (Exception Handling)
Java通过异常处理机制来处理程序运行过程中可能出现的异常情况。
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try {
File file = new File("input.txt");
Scanner scanner = new Scanner(file);
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
System.out.println(line);
}
scanner.close();
} catch (FileNotFoundException e) {
System.out.println("File not found.");
}
}
}多线程 (Multithreading)
Java提供了多线程编程的支持，可以同时执行多个线程来实现并发操作。
class MyThread extends Thread {
private String name;
public MyThread(String name) {
this.name = name;
}
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(name + ": " + i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Main {
public static void main(String[] args) {
MyThread thread1 = new MyThread("Thread 1");
MyThread thread2 = new MyThread("Thread 2");
thread1.start();
thread2.start();
}
}泛型 (Generics)
Java的泛型机制允许在编译时指定类型参数，增加代码的可重用性和类型安全性。
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
for (String name : names) {
System.out.println(name);
}
}
}当然！以下是更多Java语言最有特色的编码特性的代码示例，按特性分组展示：
Lambda表达式
Java 8引入了Lambda表达式，可以简洁地编写匿名函数，并用于函数式编程和集合操作。
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println(name));
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
.filter(n -> n % 2 == 0)
.mapToInt(n -> n)
.sum();
System.out.println("Sum of even numbers: " + sum);
}
}Stream API
Java 8引入了Stream API，提供了一种流式操作集合的方式，支持函数式编程和并行处理。
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
long count = names.stream()
.filter(name -> name.length() > 4)
.count();
System.out.println("Count of names with more than 4 characters: " + count);
}
}Optional类
Java 8引入了Optional类，用于处理可能为空的值，避免了空指针异常。
import java.util.Optional;
public class Main {
public static void main(String[] args) {
Optional<String> name = Optional.ofNullable(getName());
if (name.isPresent()) {
System.out.println("Name: " + name.get());
} else {
System.out.println("Name not found");
}
}
public static String getName() {
return "Alice";
}
}注解 (Annotations)
Java支持使用注解（Annotations）来为程序元素添加元数据，并提供了一些内置的注解，如@Override和@Deprecated等。
import java.util.ArrayList;
import java.util.List;
@SuppressWarnings("unused")
public class Main {
@Deprecated
public static void oldMethod() {
System.out.println("This method is deprecated.");
}
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
// 使用了@SuppressWarnings注解，忽略编译器的警告
names.forEach(System.out::println);
// 使用了@Deprecated注解，表示该方法已经过时
oldMethod();
}
}当然！以下是更多Java语言最有特色的编码特性的代码示例，按特性分组展示：
反射 (Reflection)
Java的反射机制允许在运行时检查和操作类、对象和方法等信息。
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Main {
public static void main(String[] args) throws Exception {
// 获取类的信息
Class<?> clazz = Class.forName("com.example.Person");
System.out.println("Class Name: " + clazz.getName());
// 获取构造函数
Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
Object person = constructor.newInstance("Alice", 25);
// 获取字段
Field nameField = clazz.getDeclaredField("name");
nameField.setAccessible(true);
System.out.println("Name: " + nameField.get(person));
// 调用方法
Method helloMethod = clazz.getDeclaredMethod("hello");
helloMethod.invoke(person);
}
}
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
private void hello() {
System.out.println("Hello, " + name);
}
}序列化 (Serialization)
Java的序列化机制允许将对象转换为字节流进行存储或传输，并在需要时重新构造对象。
import java.io.*;
public class Main {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// 对象序列化
Person person = new Person("Alice", 25);
FileOutputStream fileOut = new FileOutputStream("person.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(person);
out.close();
fileOut.close();
// 对象反序列化
FileInputStream fileIn = new FileInputStream("person.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
Person deserializedPerson = (Person) in.readObject();
in.close();
fileIn.close();
System.out.println("Name: " + deserializedPerson.getName());
System.out.println("Age: " + deserializedPerson.getAge());
}
}
class Person implements Serializable {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}