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. 多线程编程

   1. 线程的概念与生命周期

      // 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 状态}
      }

   2. 创建线程的两种方式（继承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() 方法启动线程}
      }

   3. 线程同步与锁机制（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}
      }

   4. 线程池（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();}
      }

   5. 线程间通信（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();}
      }

   6. 实践建议：编写多线程程序，模拟生产者-消费者问题。

2. 反射机制

   1. 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

      <