基础语法
1. Hello World
public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); }}讲解
这是一个典型的Java程序，它定义了一个名为HelloWorld的类，该类包含一个main方法——Java应用程序的入口点。System.out.println("Hello, World!");打印出"Hello, World!"到控制台。
2. 数据类型
int a = 100;float b = 5.25f;double c = 5.25;boolean d = true;char e = 'A';String f = "Hello";讲解
此代码片段展示了Java中的基本数据类型。int是整数，float和double是浮点数，boolean是布尔类型，char用于单个字符，String用于字符串。
3. 条件判断
if (a > b) { // 条件成立时执行} else if (a == b) { // 另一个条件} else { // 条件都不成立时执行}讲解
使用条件判断来执行不同的代码块。if-else的结构帮助程序做出选择，执行基于不同条件的代码。
4. 循环结构
for循环
for (int i = 0; i < 10; i++) { System.out.println("i: " + i);}讲解
for循环允许在满足某个条件时重复执行代码。这里的for循环从0开始，打印到9。
while循环
int i = 0;while (i < 10) { System.out.println("i: " + i); i++;}讲解
while循环在一个条件成立时不断执行一段代码。只要i小于10，就会继续循环。
do-while循环
int i = 0;do { System.out.println("i: " + i); i++;} while (i < 10);讲解
do-while循环与while循环相似，但它在先执行一次代码之后，才检查条件。
5. 数组
int[] arr = new int[5];arr[0] = 1;arr[1] = 2;// ...int[] arr2 = {1, 2, 3, 4, 5};讲解
数组是用于存储同一类型元素的集合。int[] arr是一个整数数组，arr2是一个带初始化的数组。
6. 方法定义与调用
public static int add(int a, int b) { return a + b;}int sum = add(5, 3); // 调用方法讲解
方法是可重用的代码段。add是一个方法，它接收两个整数参数并返回它们的和。通过调用add(5, 3)获取结果。
面向对象编程
7. 类与对象
public class Dog { String name; public void bark() { System.out.println(name + " says: Bark!"); }}Dog myDog = new Dog();myDog.name = "Rex";myDog.bark();讲解
Dog类具有属性name和方法bark。通过创建Dog对象并设置其属性, 可以调用其方法。
8. 构造方法
public class User { String name; public User(String newName) { name = newName; }}User user = new User("Alice");讲解
构造方法用于对象初始化。在User类中，构造函数赋值name为传入的参数。
9. 继承
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(); // 继承自Animaldog.bark();讲解
继承允许类继承其他类的属性和方法。Dog继承Animal，因此可以调用eat方法。
10. 接口
public interface Animal { void eat();}public class Dog implements Animal { public void eat() { System.out.println("The dog eats."); }}Dog dog = new Dog();dog.eat();讲解
接口定义类须实现的方法。Dog类实现Animal接口，需要具体化eat方法。
11. 抽象类
public abstract class Animal { abstract void eat();}public class Dog extends Animal { void eat() { System.out.println("The dog eats."); }}Animal dog = new Dog();dog.eat();讲解
抽象类可以包含抽象方法，子类必须实现这些方法。Dog类实现抽象类Animal的eat方法。
12. 方法重载
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 calc = new Calculator();calc.add(5, 3); // 调用第一个方法calc.add(5.0, 3.0); // 调用第二个方法calc.add(5, 3, 2); // 调用第三个方法讲解
方法重载允许在同一类中创建多个同名方法，但参数类型或数量不同。Java选择最匹配的签名。
13. 方法重写
public class Animal { void makeSound() { System.out.println("Some sound"); }}public class Dog extends Animal { @Override void makeSound() { System.out.println("Bark"); }}Animal myDog = new Dog();myDog.makeSound(); // 输出 "Bark"讲解
重写允许子类提供父类方法的新实现。在Dog中，makeSound方法重写了Animal类的方法。
14. 多态
public class Animal { void makeSound() { System.out.println("Some generic sound"); }}public class Dog extends Animal { @Override void makeSound() { System.out.println("Bark"); }}public class Cat extends Animal { @Override void makeSound() { System.out.println("Meow"); }}Animal myAnimal = new Dog();myAnimal.makeSound(); // BarkmyAnimal = new Cat();myAnimal.makeSound(); // Meow讲解
多态允许一个对象表现为多种类型。makeSound方法可由Animal类型引用调用，并根据对象类型改变行为。
15. 封装
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; }}Account myAccount = new Account(50);myAccount.deposit(150);myAccount.withdraw(75);System.out.println(myAccount.getBalance()); // 应输出：125.0讲解
封装通过隐藏类信息实现。使用private变量限制直接访问，提供公共方法来调整内部状态。
16. 静态变量和方法
public class MathUtils { public static final double PI = 3.14159; public static double add(double a, double b) { return a + b; } public static double subtract(double a, double b) { return a - b; } public static double multiply(double a, double b) { return a * b; }}double circumference = MathUtils.PI * 2 * 5;System.out.println(circumference); // 打印圆的周长讲解
静态变量和方法属于类本身，而不属于单一对象。可以直接用类名.方法进行调用，例如计算圆周长。
17. 内部类
public class OuterClass { private String msg = "Hello"; class InnerClass { void display() { System.out.println(msg); } } public void printMessage() { InnerClass inner = new InnerClass(); inner.display(); }}OuterClass outer = new OuterClass();outer.printMessage(); // 输出 "Hello"讲解
内部类是定义在另一个类中的类。提供从内部访问外部类成员的权限。用于封装逻辑相关的类。
18. 匿名类
abstract class SaleTodayOnly { abstract int dollarsOff();}public class Store { public SaleTodayOnly sale = new SaleTodayOnly() { int dollarsOff() { return 3; } };}Store store = new Store();System.out.println(store.sale.dollarsOff()); // 应输出3讲解
匿名类允许创建没有名字的类实例。这些类通常用于简化一次性使用，定义新的子类或实现接口。
高级编程概念
19. 泛型
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讲解
泛型提供一种创建类型安全的代码方式，允许类、接口和方法在实现中使用类型参数。这样可避免类型转换错误。
20. 集合框架
ArrayList
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++]讲解
ArrayList是一个动态数组，允许根据需要调整大小。非常适合用于需要频繁添加和删除的场景。
HashMap
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讲解
HashMap是一种基于哈希表的数据结构，提供键与值的映射。高效支持基本操作如插入、检索、删除。
21. 异常处理
try { int result = 10 / 0;} catch (ArithmeticException e) { System.out.println("Cannot divide by zero!");} finally { System.out.println("This will always be printed.");}讲解
Java支持异常处理以捕获和处理错误。try-catch-finally块用于检测错误并执行备用代码，确保某些操作无论是否发生异常都执行。
22. 文件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();}讲解
文件I/O用于读写文件。此代码使用BufferedReader和FileReader读取文件，捕获和处理IO异常，以便安全进行文件操作。
写入文件
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();}讲解
文件写入也使用了try-with-resources，确保在写入后自动关闭BufferedWriter，处理IO异常，保证写入的安全和完整性。
23. 多线程
创建线程
class MyThread extends Thread { public void run() { System.out.println("MyThread running"); }}MyThread myThread = new MyThread();myThread.start();讲解
继承Thread类并覆盖run方法可以创建新线程。通过调用start方法启动线程，执行run中的代码。
实现Runnable接口
class MyRunnable implements Runnable { public void run() { System.out.println("MyRunnable running"); }}Thread thread = new Thread(new MyRunnable());thread.start();讲解
实现Runnable接口是创建线程的另一种方式。将Runnable实例传递给Thread构造方法并调用start。
24. 同步
public class Counter { private int count = 0; public synchronized void increment() { count++; } public synchronized int getCount() { return count; }}讲解
同步确保线程安全访问共享资源。synchronized关键字用于锁定代码块，以防止多个线程同时访问，以便保证数据一致性。
25. 高级多线程
使用Executors
import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;ExecutorService executor = Executors.newFixedThreadPool(2);executor.submit(() -> { System.out.println("ExecutorService running");});executor.shutdown();讲解
Executors提供一个框架来控制线程池。用于管理线程的创建和安排，优化多线程任务执行。
Future和Callable
import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;Callable<Integer> callableTask = () -> { return 10;};ExecutorService executorService = Executors.newSingleThreadExecutor();Future<Integer> future = executorService.submit(callableTask);try { Integer result = future.get(); // this will wait for the task to finish System.out.println("Future result: " + result);} catch (InterruptedException | ExecutionException e) { e.printStackTrace();} finally { executorService.shutdown();}讲解
Callable可以返回结果和抛出异常。结合Future和线程池可以执行耗时任务，并在以后获取结果或处理异常，是构建并发应用的实用工具。
26. 线程池
import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);for (int i = 0; i < 10; i++) { fixedThreadPool.execute(() -> { System.out.println("Running in thread: " + Thread.currentThread().getName()); });}fixedThreadPool.shutdown();讲解
线程池管理线程的创建和销毁，允许重用现有的线程来处理多个任务，以减少开销并提高性能。newFixedThreadPool创建一个固定数量线程的线程池。
27. 可变参数
public static void printNumbers(int... numbers) { for (int num : numbers) { System.out.println(num); }}public static void main(String[] args) { printNumbers(1, 2, 3, 4, 5);}讲解
可变参数（varargs）允许传递不确定数量的参数给方法。用语法int... numbers定义变量参数，可以当作数组使用。
28. 枚举
public enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY}public class Main { public static void main(String[] args) { Day today = Day.MONDAY; System.out.println("Today is " + today); }}讲解
枚举是一种特殊类，用于定义有限数量的常量。它显式表达一个变量可选项列表，提升代码可读性和安全性。
29. 反射
import java.lang.reflect.Method;public class ReflectionExample { public static void main(String[] args) throws Exception { Class<?> cls = Class.forName("java.lang.String"); Method[] methods = cls.getMethods(); for (Method method : methods) { System.out.println("Method: " + method.getName()); } }}讲解
反射允许在运行时动态访问类、方法和字段。此技术可用于工具开发、序列化框架和依赖注入等高级任务，并提供方法遍历java.lang.String类。
30. 注解
@interface MyAnnotation { String value();}@MyAnnotation(value = "Example")public class AnnotatedClass { // 该类使用了自定义注解}讲解
注解为代码提供元数据，广泛应用于框架和库中查找信息。自定义注解可用于文档记录和静态检查。
31. Singleton模式
public class Singleton { private static Singleton instance; private Singleton() {} public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; }}讲解
单例模式保证一个类只有一个实例，并提供一个全局访问点。使用私有构造函数和静态方法，下次调用getInstance()时返回已有实例。
32. Builder模式
public class Product { private final String name; private final double price; private Product(Builder builder) { this.name = builder.name; this.price = builder.price; } public static class Builder { private String name; private double price; public Builder setName(String name) { this.name = name; return this; } public Builder setPrice(double price) { this.price = price; return this; } public Product build() { return new Product(this); } }}Product product = new Product.Builder() .setName("Example Product") .setPrice(29.99) .build();讲解
建造者模式允许构建复杂对象的过程与表示分离。此模式尤其适合对象具有多个可选参数的情况，通过链式调用提升代码易读性。
33. Lambda表达式
interface MathOperation { int operation(int a, int b);}MathOperation addition = (a, b) -> a + b;System.out.println(addition.operation(5, 3)); // 应输出8讲解
Lambda表达式是简化的一种匿名内部类，提供了简洁的语法来表示函数式接口（只有一个抽象方法的接口）的实现。
34. 方法引用
import java.util.function.Consumer;public class MethodReference { public static void main(String[] args) { Consumer<String> printer = System.out::println; printer.accept("Hello, Java!"); }}讲解
方法引用是一种简洁且易读的Lambda表达式形式。使用::引用类方法或实例方法，如System.out::println。
35. Stream API
import java.util.Arrays;import java.util.List;public class StreamExample { public static void main(String[] args) { List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); names.stream() .filter(name -> name.startsWith("A")) .forEach(System.out::println); }}讲解
Stream API支持以声明式风格处理数据集合，简化代码，并支持集合操作如过滤、映射和归约。
36. 正则表达式
import java.util.regex.Matcher;import java.util.regex.Pattern;Pattern pattern = Pattern.compile("a*b");Matcher matcher = pattern.matcher("aaaaab");boolean matchFound = matcher.matches();System.out.println("Match Found: " + matchFound);讲解
正则表达式提供强大的模式匹配机制。Pattern和Matcher类是Java正则表达式API的核心，支持各种复杂字符串操作。
37. JUnit单元测试
import static org.junit.Assert.assertEquals;import org.junit.Test;public class SimpleTest { @Test public void testAddition() { assertEquals(5, 2 + 3); }}讲解
JUnit是Java生态系统中常用的单元测试框架，使用简单注解@Test来定义测试方法，并通过断言检查程序行为。
38. 序列化和反序列化
import java.io.*;class Person implements Serializable { private static final long serialVersionUID = 1L; String name; Person(String name) { this.name = name; }}try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) { Person person = new Person("Alice"); oos.writeObject(person);} catch (IOException e) { e.printStackTrace();}try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) { Person deserializedPerson = (Person) ois.readObject(); System.out.println("Deserialized Name: " + deserializedPerson.name);} catch (IOException | ClassNotFoundException e) { e.printStackTrace();}讲解
序列化可将对象转换为字节流以便存储或传输。反序列化则是将字节流恢复为对象。Serializable接口标记类支持这些过程。
39. 图形用户界面(GUI)基础
import javax.swing.*;import java.awt.*;public class SimpleGUI { public static void main(String[] args) { JFrame frame = new JFrame("Simple GUI"); JButton button = new JButton("Press me"); button.addActionListener(e -> System.out.println("Button pressed!")); frame.setLayout(new FlowLayout()); frame.add(button); frame.setSize(300, 200); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); }}讲解
Java的Swing库用于创建图形用户界面，需要创建JFrame作为窗口，添加JButton等组件，并添加事件监听来处理用户交互。
40. 网络编程
import java.net.*;import java.io.*;public class SimpleClient { public static void main(String[] args) { try (Socket socket = new Socket("localhost", 1234); PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) { out.println("Hello Server!"); } catch (IOException e) { e.printStackTrace(); } }}讲解
网络编程支持通信程序之间的连接和数据交换。这里程序创建一个简单的TCP客户端，通过Socket连接发送数据。
41. JDBC数据库连接
import java.sql.*;public class DatabaseExample { public static void main(String[] args) { String url = "jdbc:mysql://localhost:3306/mydatabase"; String user = "username"; String password = "password"; try (Connection conn = DriverManager.getConnection(url, user, password); Statement stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery("SELECT * FROM mytable")) { while (rs.next()) { System.out.println(rs.getString("column_name")); } } catch (SQLException e) { e.printStackTrace(); } }}讲解
JDBC是Java用于数据库交互的API，执行查询和更新SQL数据库。连接数据库后，通过Statement接口执行SQL语句操作。
42. 使用Optional类
import java.util.Optional;public class OptionalExample { public static void main(String[] args) { Optional<String> optionalValue = Optional.of("Hello"); optionalValue.ifPresent(System.out::println); String value = optionalValue.orElse("Default Value"); System.out.println(value); }}讲解
Optional是Java 8引入的一个容器类，用于避免null值引发的异常，提供安全获取和操作潜在有无的值的方法。
43. 使用LocalDate和LocalDateTime
import java.time.LocalDate;import java.time.LocalDateTime;public class DateExample { public static void main(String[] args) { LocalDate date = LocalDate.now(); LocalDateTime dateTime = LocalDateTime.now(); System.out.println("Date: " + date); System.out.println("DateTime: " + dateTime); }}讲解
LocalDate和LocalDateTime是用于处理日期和时间的新API，提供更简便和安全的方法来操作时间信息，而不再使用线程不安全的java.util.Date.
44. 在Java中使用正则进行匹配
import java.util.regex.Pattern;public class RegexExample { public static void main(String[] args) { String text = "Java is fun!"; Pattern pattern = Pattern.compile("Java"); if (pattern.matcher(text).find()) { System.out.println("The text contains 'Java'"); } }}讲解
正则表达式是一种强有力的工具，用于在字符串中寻找符合条件的子串，Pattern和Matcher在Java中提供了正则表达式的完整支持。
45. 使用CompletableFuture进行异步编程
import java.util.concurrent.CompletableFuture;public class CompletableFutureExample { public static void main(String[] args) { CompletableFuture<Void> future = CompletableFuture.runAsync(() -> { try { Thread.sleep(1000); System.out.println("Async Task"); } catch (InterruptedException e) { e.printStackTrace(); } }); future.join(); // Wait for the task to complete }}讲解
CompletableFuture 是 Java 8 中引入的新类，用于异步编程，可以在非阻塞的方式下完成任务，提高程序的性能和响应能力。
46. Java中VCS的应用
Java中的版本控制系统（VCS）通常使用Git，在代码示例中不直接涉及VCS的具体应用，而是强调良好使用版本控制策略的重要性，包括常见的分支管理（如Git Flow）、提交管理以及使用IDE集成VCS工具进行代码变更跟踪和历史管理。
47. Java中实现Observer设计模式
import java.util.ArrayList;import java.util.List;interface Observer { void update(String message);}class Subject { private List<Observer> observers = new ArrayList<>(); void addObserver(Observer o) { observers.add(o); } void notifyObservers(String message) { for (Observer observer : observers) { observer.update(message); } }}class ConcreteObserver implements Observer { private String name; ConcreteObserver(String name) { this.name = name; } public void update(String message) { System.out.println(name + " received: " + message); }}public class ObserverDemo { public static void main(String[] args) { Subject subject = new Subject(); Observer observer1 = new ConcreteObserver("Observer 1"); Observer observer2 = new ConcreteObserver("Observer 2"); subject.addObserver(observer1); subject.addObserver(observer2); subject.notifyObservers("Hello, Observers!"); }}讲解
观察者模式定义对象间的一对多依赖关系。当一个对象改变状态时，所有依赖者都会收到通知并自动更新。适用于系统中多个对象间的这类通信需求。
48. 使用Spring Boot构建Web应用
Spring Boot是一个用于创建独立、生产级Spring应用程序的框架，提供了约定优于配置理念，简化了Spring应用的开发过程。以下是一个简单的Spring Boot应用示例：
import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.web.bind.annotation.*;@SpringBootApplication@RestControllerpublic class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } @GetMapping("/hello") public String hello() { return "Hello, Spring Boot!"; }}讲解
@SpringBootApplication注解标记Spring Boot应用主类，该类需拥有main方法来启动应用。@RestController和@GetMapping用于定义RESTful Web服务端点。
49. 使用Hibernate进行持久化
Hibernate是Java中的一种持久化框架，简化了数据库访问，并实现了轻量级的Object-Relational Mapping (ORM)。以下是一个基本示例：
import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.cfg.Configuration;@Entitypublic class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; // Getters and setters}public class HibernateUtil { private static final SessionFactory sessionFactory = new Configuration() .configure("hibernate.cfg.xml") .buildSessionFactory(); public static SessionFactory getSessionFactory() { return sessionFactory; }}public class HibernateExample { public static void main(String[] args) { try (Session session = HibernateUtil.getSessionFactory().openSession()) { session.beginTransaction(); User user = new User(); user.setName("Alice"); session.save(user); session.getTransaction().commit(); } }}讲解
Hibernate simplifies the task of interacting with a relational database by automatically handling the low-level details. Using annotations like @Entity, @Id, and @GeneratedValue, Hibernate can map Java objects to database tables.
50. 使用Mockito进行单元测试
Mockito是Java单元测试过程中常用的一个mocking框架，以下是一个示例：
import static org.mockito.Mockito.*;import org.junit.Test;import org.mockito.InjectMocks;import org.mockito.Mock;public class MockitoExample { @Mock MyDatabase databaseMock; @InjectMocks MyService service; @Test public void testQuery() { when(databaseMock.query(anyString())).thenReturn("some data"); String result = service.queryDatabase("query string"); assertEquals("some data", result); verify(databaseMock).query("query string"); }}讲解
Mockito通过创建、配置以及验证mock对象简化单元测试。@Mock标记的对象由Mockito的mocking机制自动生成，而@InjectMocks通过注入mock对象，实现对被测类的依赖管理。
以上是Java学习中常见的50个编程概念与代码示例。在掌握这些基础与高级技巧后，你将更具备驾驭Java项目开发的能力。不断学习和实践将提升你的编程技能和职业发展潜力。