1. 面向对象编程（OOP）的四大基本特性
Java 是一门面向对象的编程语言，理解并掌握 OOP 的四大基本特性是学习 Java 的基础。
1.1 封装（Encapsulation）
封装指的是将对象的属性和方法封装成一个单元，并限制外部访问，只能通过特定的访问方式（getter 和 setter 方法）来修改和获取对象的状态。封装可以提高代码的安全性和可维护性。
示例：
public class Person {
private String name; // 私有属性
// Getter 方法
public String getName() {
return name;
}
// Setter 方法
public void setName(String name) {
this.name = name;
}
}
1.2 继承（Inheritance）
继承允许一个类从另一个类派生，获取父类的属性和方法。Java 中的继承是单继承（一个类只能有一个直接父类）。继承使得代码能够重用，并且支持层次化的分类。
示例：
class Animal {
public void eat() {
System.out.println("Eating...");
}
}
class Dog extends Animal {
public void bark() {
System.out.println("Barking...");
}
}
1.3 多态（Polymorphism）
多态是指同一个方法或属性在不同情况下表现出不同的行为。在 Java 中，多态有两种实现方式：方法重载（Overloading）和方法重写（Overriding）。
- 方法重载：同一类中方法名相同但参数不同。
- 方法重写：子类重写父类的方法，实现不同的功能。
示例：
class Animal {
public void sound() {
System.out.println("Animal sound");
}
}
class Dog extends Animal {
@Override
public void sound() {
System.out.println("Barking...");
}
}
public class Test {
public static void main(String[] args) {
Animal animal = new Dog();
animal.sound(); // 输出 "Barking..."，即实现了多态
}
}
1.4 抽象（Abstraction）
抽象指的是隐藏实现细节，只暴露必要的接口给用户。Java 中的抽象通过抽象类和接口来实现。
- 抽象类：不能实例化，可以包含抽象方法（没有实现）和非抽象方法。
- 接口：只能包含抽象方法（Java 8 之后可以包含默认方法和静态方法）。
示例：
abstract class Animal {
abstract void sound();
}
class Dog extends Animal {
@Override
void sound() {
System.out.println("Bark");
}
}
2. Java 集合框架（Collection Framework）
Java 集合框架提供了许多用于存储和操作数据的类和接口。它主要包括以下几种类型：
- List：有序、允许重复的集合。常见实现有
ArrayList和LinkedList。 - Set：无序、不允许重复的集合。常见实现有
HashSet和TreeSet。 - Map：键值对集合，不允许重复键。常见实现有
HashMap和TreeMap。
2.1 List 示例（ArrayList）
import java.util.ArrayList;
public class ListExample {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");
System.out.println(list); // 输出 [Java, Python, C++]
}
}
2.2 Set 示例（HashSet）
import java.util.HashSet;
public class SetExample {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Apple"); // 会被自动忽略
System.out.println(set); // 输出 [Apple, Banana]
}
}
2.3 Map 示例（HashMap）
import java.util.HashMap;
public class MapExample {
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
map.put("Alice", 25);
map.put("Bob", 30);
map.put("Charlie", 35);
System.out.println(map); // 输出 {Alice=25, Bob=30, Charlie=35}
}
}
3. 异常处理（Exception Handling）
Java 提供了强大的异常处理机制，用于捕获和处理程序中的错误。使用 try-catch-finally 语句块可以有效地捕获异常并进行相应处理。
示例：
public class ExceptionExample {
public static void main(String[] args) {
try {
int result = 10 / 0; // 可能会抛出异常
} catch (ArithmeticException e) {
System.out.println("Error: " + e.getMessage()); // 捕获异常并输出错误信息
} finally {
System.out.println("This block is always executed."); // 无论是否有异常都会执行
}
}
}
4. Java 8 新特性
Java 8 引入了许多新的特性，尤其是 Lambda 表达式、Streams API 和默认方法。
4.1 Lambda 表达式
Lambda 表达式允许你以更简洁的方式传递代码块。它可以减少冗长的匿名类代码。
示例：
import java.util.List;
import java.util.ArrayList;
public class LambdaExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");
list.forEach(item -> System.out.println(item)); // 使用 Lambda 表达式打印每个元素
}
}
4.2 Streams API
Streams API 使得我们能够以声明性方式处理集合，支持链式操作和并行操作。
示例：
import java.util.List;
import java.util.ArrayList;
public class StreamExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");
list.stream()
.filter(item -> item.startsWith("J")) // 过滤以 J 开头的元素
.forEach(System.out::println); // 打印结果
}
}
5. Java 多线程与并发
Java 提供了多线程支持，可以让程序并发执行多个任务，尤其是在 CPU 密集型或 I/O 密集型操作中非常有用。Java 的多线程机制基于 Thread 类和 Runnable 接口。
示例：
class MyThread extends Thread {
public void run() {
System.out.println("This is a thread");
}
}
public class ThreadExample {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start(); // 启动线程
}
}
6. Java I/O 操作
Java 提供了丰富的 I/O 类库来进行文件和数据流的操作。常用的类有 File、FileReader、FileWriter、BufferedReader 等。
示例：
import java.io.*;
public class FileExample {
public static void main(String[] args) throws IOException {
// 写入文件
FileWriter writer = new FileWriter("example.txt");
writer.write("Hello, Java!");
writer.close();
// 读取文件
BufferedReader reader = new BufferedReader(new FileReader("example.txt"));
String line = reader.readLine();
System.out.println(line); // 输出：Hello, Java!
reader.close();
}
}
这篇内容是对 Java 基础知识的更进一步探讨，涵盖了 OOP、集合框架、异常处理等核心概念，同时引入了 Java 8 的新特性，如 Lambda 表达式和 Streams API。如果你有任何问题或需要进一步的解释，随时提问！
发表回复