文章目录
1. 类与对象
在Java中，所有代码都必须包含在一个类中。类是创建对象的模板或蓝图，而对象是类的具体实例。
public class Dog {
String name;
public void bark() {
System.out.println(name + " says: Bark!");
}
}
// 创建Dog类的对象
Dog myDog = new Dog();
myDog.name = "Rex";
myDog.bark(); // 调用bark方法
Dog是一个类。name是该类的一个属性。bark()是该类的一个方法。myDog是Dog类的一个实例（对象），通过new Dog()创建。
2. 构造方法
构造方法用于初始化新创建的对象状态。它具有与类相同的名字，并且没有返回类型。
public class User {
String name;
// 构造方法
public User(String newName) {
name = newName;
}
}
User user = new User("Alice"); // 使用构造方法创建对象并初始化
3. 继承
继承允许一个类从另一个类继承属性和方法，从而实现代码重用。子类可以扩展或修改父类的行为。
public class Animal {
void eat() {
System.out.println("This animal eats food.");
}
}
public class Dog extends Animal {
void bark() {
System.out.println("The dog barks.");
}
}
Dog dog = new Dog();
dog.eat(); // 继承自Animal的方法
dog.bark(); // 自定义的方法
Dog类继承了Animal类，所以它可以使用Animal的所有非私有成员。
4. 接口
接口定义了一组行为规范，实现了这个接口的类必须提供这些行为的具体实现。
public interface Animal {
void eat();
}
public class Dog implements Animal {
public void eat() {
System.out.println("The dog eats.");
}
}
Animal是一个接口，定义了一个eat方法。Dog实现了Animal接口，并提供了eat方法的具体实现。
5. 抽象类
抽象类不能被实例化，但可以包含抽象方法，这些方法必须由子类实现。
public abstract class Animal {
abstract void eat();
}
public class Dog extends Animal {
void eat() {
System.out.println("The dog eats.");
}
}
Animal是一个抽象类，其中eat是抽象方法。Dog继承了Animal并且实现了eat方法。
6. 方法重载
同一个类中可以有多个同名但参数列表不同的方法，这称为方法重载。
public class Calculator {
int add(int a, int b) {
return a + b;
}
double add(double a, double b) {
return a + b;
}
int add(int a, int b, int c) {
return a + b + c;
}
}
Calculator类中有三个名为add的方法，它们根据传入参数的不同执行不同的操作。
7. 方法重写
子类可以通过提供与父类中同名方法相同的签名来重写父类的方法。
public class Animal {
void makeSound() {
System.out.println("Some sound");
}
}
public class Dog extends Animal {
@Override
void makeSound() {
System.out.println("Bark");
}
}
Dog类重写了Animal类的makeSound方法，以改变其行为。
8. 多态
多态性是指同一个接口或基类可以有不同的实现形式。例如，你可以用一个父类类型的引用指向子类的对象。
Animal myAnimal = new Dog();
myAnimal.makeSound(); // 输出 "Bark"
myAnimal = new Cat();
myAnimal.makeSound(); // 输出 "Meow"
Animal类型的变量myAnimal可以指向Dog或Cat对象，并调用各自版本的makeSound方法。
9. 封装
封装是隐藏对象的内部表示，只暴露必要的部分给外部使用的机制。通常通过设置成员变量为私有(private)，并通过公共(public)方法访问这些变量。
public class Account {
private double balance;
public Account(double initialBalance) {
if (initialBalance > 0) {
balance = initialBalance;
}
}
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
public void withdraw(double amount) {
if (amount <= balance) {
balance -= amount;
}
}
public double getBalance() {
return balance;
}
}
balance是私有成员，只能通过Account类提供的方法访问。
10. 静态变量和方法
静态成员属于类本身而不是特定的对象实例，因此所有对象共享同一份静态成员。
public class MathUtils {
public static final double PI = 3.14159;
public static double add(double a, double b) {
return a + b;
}
}
PI是一个静态常量，add是一个静态方法，可以直接通过类名访问，无需创建对象实例。
11. 内部类
内部类是在另一个类内部定义的类，它可以访问外部类的所有成员。
public class OuterClass {
private String msg = "Hello";
class InnerClass {
void display() {
System.out.println(msg);
}
}
public void printMessage() {
InnerClass inner = new InnerClass();
inner.display();
}
}
InnerClass是OuterClass的内部类，可以直接访问OuterClass的私有成员。
12. 匿名类
匿名类是没有名字的类，通常用于简化代码，特别是在需要快速创建对象的时候。
abstract class SaleTodayOnly {
abstract int dollarsOff();
}
public class Store {
public SaleTodayOnly sale = new SaleTodayOnly() {
int dollarsOff() {
return 3;
}
};
}
- 这里创建了一个匿名类的实例，它实现了
SaleTodayOnly抽象类。
13. 泛型
泛型允许你编写能够处理多种类型的代码，同时保持类型安全。
public class Box<T> {
private T t;
public void set(T t) {
this.t = t;
}
public T get() {
return t;
}
}
Box<Integer> integerBox = new Box<>();
integerBox.set(10);
System.out.println(integerBox.get()); // 应输出：10
Box<T>是一个泛型类，可以存储任何类型的对象。
14. 集合框架
集合框架是一组接口和实现类，用于更高效地管理和操作数据集合。
import java.util.ArrayList;
ArrayList<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");
System.out.println(list); // 应输出：[Java, Python, C++]
import java.util.HashMap;
HashMap<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
map.put("Cherry", 3);
System.out.println(map.get("Apple")); // 应输出：1
ArrayList是一个动态数组，HashMap是键值对的集合。
15. 异常处理
异常处理机制允许程序捕获和响应错误条件。
try {
int result = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Cannot divide by zero!");
} finally {
System.out.println("This will always be printed.");
}
try块包含可能抛出异常的代码。catch块捕获特定类型的异常并处理它。finally块无论是否发生异常都会被执行。
16. 文件I/O
文件输入输出操作涉及到读取和写入文件内容。
读取文件
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
String line;
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
写入文件
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
bw.write("Hello World!");
} catch (IOException e) {
e.printStackTrace();
}
BufferedReader和BufferedWriter用于高效地读取和写入文本文件。
17. 多线程
多线程编程可以让程序同时执行多个任务，提高应用程序的响应性和性能。
创建线程
class MyThread extends Thread {
public void run() {
System.out.println("MyThread running");
}
}
MyThread myThread = new MyThread();
myThread.start();
实现Runnable接口
class MyRunnable implements Runnable {
public void run() {
System.out.println("MyRunnable running");
}
}
Thread thread = new Thread(new MyRunnable());
thread.start();
Thread类和Runnable接口是创建线程的主要方式。
18. 同步
同步机制确保在多线程环境中对共享资源的安全访问。
public class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
synchronized关键字确保一次只有一个线程可以执行方法体内的代码。
19. 高级多线程
使用ExecutorService和Future可以更方便地管理线程池和异步任务。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(() -> {
System.out.println("ExecutorService running");
});
executor.shutdown();
ExecutorService提供了线程池管理功能，submit方法可以提交可运行的任务，shutdown方法关闭服务。