java 学习笔记 第二阶段：Java进阶
目录
多线程编程
线程的概念与生命周期
创建线程的两种方式（继承Thread类、实现Runnable接口）
线程同步与锁机制（synchronized、Lock）
线程池（ExecutorService）
线程间通信（wait、notify、notifyAll）
实践建议：编写多线程程序，模拟生产者-消费者问题。
反射机制
Class类与反射
获取类的信息（字段、方法、构造器）
动态创建对象与调用方法
实践建议：通过反射实现一个简单的依赖注入。
注解（Annotation）
内置注解（@Override、@Deprecated等）
自定义注解
元注解（@Target、@Retention等）
实践建议：自定义注解并实现简单的注解处理器。
网络编程
TCP/IP协议与Socket编程
UDP协议与DatagramSocket编程
HTTP协议与URLConnection
实践建议：编写一个简单的聊天程序。
数据库编程
JDBC简介
连接数据库（DriverManager、Connection）
执行SQL语句（Statement、PreparedStatement）
事务管理
数据库连接池（DBCP、C3P0、HikariCP）
-
多线程编程
-
线程的概念与生命周期
// 1. 线程的概念与生命周期// 线程是程序执行的最小单位，一个程序可以有多个线程。 // 线程有以下几种状态： // - NEW: 新建状态，线程已经创建但尚未开始执行。 // - RUNNABLE: 运行状态，线程正在运行或等待被调度执行。 // - BLOCKED: 阻塞状态，线程因等待锁而被阻塞。 // - WAITING: 等待状态，线程正在等待其他线程的通知。 // - TIMED_WAITING: 超时等待状态，线程正在等待超时。 // - TERMINATED: 终止状态，线程执行完成或者异常终止。// 示例：线程状态的转换 public class ThreadLifeCycle {public static void main(String[] args) {Thread thread = new Thread(() -> {System.out.println("Thread is running...");});System.out.println("Thread state: " + thread.getState()); // NEW 状态thread.start();System.out.println("Thread state: " + thread.getState()); // RUNNABLE 状态} } -
创建线程的两种方式（继承Thread类、实现Runnable接口）
// 2. 创建线程的两种方式// （1）继承 Thread 类 class MyThread extends Thread {@Overridepublic void run() {System.out.println("Thread is running using Thread class!");} }public class ThreadExample {public static void main(String[] args) {// 创建并启动线程MyThread myThread = new MyThread();myThread.start(); // 调用 start() 方法启动线程} }// （2）实现 Runnable 接口 class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("Thread is running using Runnable interface!");} }public class RunnableExample {public static void main(String[] args) {// 创建线程Thread thread = new Thread(new MyRunnable());thread.start(); // 调用 start() 方法启动线程} } -
线程同步与锁机制（synchronized、Lock）
// 3. 线程同步与锁机制// 线程同步：避免多个线程同时访问共享资源导致数据不一致的问题。 // （1）使用 synchronized 关键字进行同步 class Counter {private int count = 0;// 使用 synchronized 确保线程安全public synchronized void increment() {count++;}public int getCount() {return count;} }public class SynchronizedExample {public static void main(String[] args) throws InterruptedException {Counter counter = new Counter();// 创建两个线程并启动Thread thread1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {counter.increment();}});Thread thread2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {counter.increment();}});thread1.start();thread2.start();thread1.join();thread2.join();System.out.println("Final count: " + counter.getCount()); // 输出结果应该是 2000} }// （2）使用 Lock 进行同步 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;class LockCounter {private int count = 0;private Lock lock = new ReentrantLock();public void increment() {lock.lock(); // 获取锁try {count++;} finally {lock.unlock(); // 释放锁}}public int getCount() {return count;} }public class LockExample {public static void main(String[] args) throws InterruptedException {LockCounter counter = new LockCounter();// 创建两个线程并启动Thread thread1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {counter.increment();}});Thread thread2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {counter.increment();}});thread1.start();thread2.start();thread1.join();thread2.join();System.out.println("Final count using Lock: " + counter.getCount()); // 输出结果应该是 2000} } -
线程池（ExecutorService）
// 4. 线程池（ExecutorService）// 使用线程池来管理线程，避免频繁的创建与销毁线程。 // ExecutorService 是一个接口，提供了用于创建线程池和提交任务的方法。import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors;public class ThreadPoolExample {public static void main(String[] args) {// 创建一个固定大小的线程池ExecutorService executorService = Executors.newFixedThreadPool(2);// 提交任务executorService.submit(() -> System.out.println("Task 1 is executed"));executorService.submit(() -> System.out.println("Task 2 is executed"));// 关闭线程池executorService.shutdown();} } -
线程间通信（wait、notify、notifyAll）
// 5. 线程间通信（wait、notify、notifyAll）// 使用线程间通信来协调多个线程的执行顺序。 // - wait()：使当前线程进入等待状态，并释放锁。 // - notify()：唤醒等待队列中的一个线程。 // - notifyAll()：唤醒等待队列中的所有线程。class SharedResource {private int count = 0;// 使用 wait 和 notify 进行线程间通信public synchronized void produce() throws InterruptedException {while (count >= 1) {wait(); // 如果资源已满，当前线程等待}count++;System.out.println("Produced, count: " + count);notify(); // 通知消费者}public synchronized void consume() throws InterruptedException {while (count <= 0) {wait(); // 如果资源为空，当前线程等待}count--;System.out.println("Consumed, count: " + count);notify(); // 通知生产者} }public class ProducerConsumerExample {public static void main(String[] args) throws InterruptedException {SharedResource resource = new SharedResource();// 创建并启动生产者线程Thread producer = new Thread(() -> {try {for (int i = 0; i < 5; i++) {resource.produce();}} catch (InterruptedException e) {e.printStackTrace();}});// 创建并启动消费者线程Thread consumer = new Thread(() -> {try {for (int i = 0; i < 5; i++) {resource.consume();}} catch (InterruptedException e) {e.printStackTrace();}});producer.start();consumer.start();producer.join();consumer.join();} } -
实践建议：编写多线程程序，模拟生产者-消费者问题。
-
-
反射机制
-
Class类与反射
<反射机制是 Java 提供的一个强大特性，它允许在运行时动态地查询和操作类的结构（如字段、方法、构造器等），以及动态创建对象和调用方法。// 1. Class类与反射// 在 Java 中，`Class` 是一个类，用于描述一个类的信息， // 每个类在 JVM 中都有一个与之对应的 `Class` 对象，通过该对象可以获取类的各种信息。 // 获取 `Class` 对象的方式有几种：// （1）使用 `getClass()` 方法 Object obj = new String("Hello"); Class<?> clazz1 = obj.getClass(); // 获取对象的 Class 对象 System.out.println(clazz1.getName()); // 输出类的全限定名：java.lang.String// （2）使用 `Class.forName()` 方法 Class<?> clazz2 = Class.forName("java.lang.String"); // 通过类名获取 Class 对象 System.out.println(clazz2.getName()); // 输出类的全限定名：java.lang.String// （3）使用 `.class` 语法 Class<?> clazz3 = String.class; // 获取 String 类的 Class 对象 System.out.println(clazz3.getName()); // 输出类的全限定名：java.lang.String
-