Java 学习笔记-第六课

1. 反射机制

1.1 反射的概念

• 反射：在运行时分析类的能力。通过反射，可以在运行时获取类的成员信息，如方法、字段和构造函数。

1.2 获取 Class 对象

• 三种方式：

  // 方式一：通过类名
  Class<?> clazz1 = Class.forName("com.example.MyClass");
  
  // 方式二：通过对象
  MyClass obj = new MyClass();
  Class<?> clazz2 = obj.getClass();
  
  // 方式三：通过 .class
  Class<?> clazz3 = MyClass.class;
  

1.3 反射的应用

• 获取类的信息：

  import java.lang.reflect.Method;
  import java.lang.reflect.Field;
  import java.lang.reflect.Constructor;
  
  public class Main {
      public static void main(String[] args) throws Exception {
          Class<?> clazz = Class.forName("com.example.MyClass");
  
          // 获取类的所有方法
          Method[] methods = clazz.getDeclaredMethods();
          for (Method method : methods) {
              System.out.println("Method: " + method.getName());
          }
  
          // 获取类的所有字段
          Field[] fields = clazz.getDeclaredFields();
          for (Field field : fields) {
              System.out.println("Field: " + field.getName());
          }
  
          // 获取类的所有构造函数
          Constructor<?>[] constructors = clazz.getDeclaredConstructors();
          for (Constructor<?> constructor : constructors) {
              System.out.println("Constructor: " + constructor.getName());
          }
      }
  }
  

• 调用方法和访问字段：

  import java.lang.reflect.Method;
  import java.lang.reflect.Field;
  
  public class Main {
      public static void main(String[] args) throws Exception {
          Class<?> clazz = Class.forName("com.example.MyClass");
          Object obj = clazz.newInstance();
  
          // 调用方法
          Method method = clazz.getDeclaredMethod("myMethod", String.class);
          method.setAccessible(true);
          method.invoke(obj, "Hello, World!");
  
          // 访问字段
          Field field = clazz.getDeclaredField("myField");
          field.setAccessible(true);
          field.set(obj, "New Value");
          System.out.println("Field value: " + field.get(obj));
      }
  }
  

2. 注解

2.1 注解的概念

• 注解：提供元数据的机制，可用于编译时和运行时的处理。注解不会直接影响代码的执行。

2.2 定义注解

• 示例：

  import java.lang.annotation.Retention;
  import java.lang.annotation.RetentionPolicy;
  
  @Retention(RetentionPolicy.RUNTIME)
  public @interface MyAnnotation {
      String value();
  }
  

2.3 使用注解

• 示例：

  @MyAnnotation("This is a test annotation")
  public class MyClass {
      @MyAnnotation("This is a method annotation")
      public void myMethod() {
          System.out.println("Executing myMethod");
      }
  }
  

2.4 解析注解

• 示例：

  import java.lang.reflect.Method;
  
  public class Main {
      public static void main(String[] args) throws Exception {
          Class<?> clazz = MyClass.class;
  
          // 获取类注解
          if (clazz.isAnnotationPresent(MyAnnotation.class)) {
              MyAnnotation annotation = clazz.getAnnotation(MyAnnotation.class);
              System.out.println("Class annotation value: " + annotation.value());
          }
  
          // 获取方法注解
          Method method = clazz.getDeclaredMethod("myMethod");
          if (method.isAnnotationPresent(MyAnnotation.class)) {
              MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
              System.out.println("Method annotation value: " + annotation.value());
          }
      }
  }
  

3. 设计模式

3.1 单例模式 (Singleton)

• 定义：确保一个类只有一个实例，并提供全局访问点。
• 实现：

  public class Singleton {
      private static Singleton instance;
  
      private Singleton() {}
  
      public static Singleton getInstance() {
          if (instance == null) {
              instance = new Singleton();
          }
          return instance;
      }
  }
  

3.2 工厂模式 (Factory)

• 定义：定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。
• 实现：

  // 产品接口
  public interface Product {
      void use();
  }
  
  // 具体产品
  public class ConcreteProduct implements Product {
      public void use() {
          System.out.println("Using ConcreteProduct");
      }
  }
  
  // 工厂类
  public class Factory {
      public static Product createProduct() {
          return new ConcreteProduct();
      }
  }
  
  // 使用工厂
  public class Main {
      public static void main(String[] args) {
          Product product = Factory.createProduct();
          product.use();
      }
  }
  

3.3 观察者模式 (Observer)

• 定义：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都能得到通知并自动更新。
• 实现：

  import java.util.ArrayList;
  import java.util.List;
  
  // 观察者接口
  public interface Observer {
      void update(String message);
  }
  
  // 具体观察者
  public class ConcreteObserver implements Observer {
      private String name;
  
      public ConcreteObserver(String name) {
          this.name = name;
      }
  
      public void update(String message) {
          System.out.println(name + " received message: " + message);
      }
  }
  
  // 被观察者接口
  public interface Subject {
      void attach(Observer observer);
      void detach(Observer observer);
      void notifyObservers();
  }
  
  // 具体被观察者
  public class ConcreteSubject implements Subject {
      private List<Observer> observers = new ArrayList<>();
      private String message;
  
      public void attach(Observer observer) {
          observers.add(observer);
      }
  
      public void detach(Observer observer) {
          observers.remove(observer);
      }
  
      public void notifyObservers() {
          for (Observer observer : observers) {
              observer.update(message);
          }
      }
  
      public void setMessage(String message) {
          this.message = message;
          notifyObservers();
      }
  }
  
  // 使用观察者模式
  public class Main {
      public static void main(String[] args) {
          ConcreteSubject subject = new ConcreteSubject();
  
          Observer observer1 = new ConcreteObserver("Observer1");
          Observer observer2 = new ConcreteObserver("Observer2");
  
          subject.attach(observer1);
          subject.attach(observer2);
  
          subject.setMessage("Hello, Observers!");
      }
  }
  

小结

• 本课学习了 Java 的反射机制，包括获取类信息、调用方法和访问字段。
• 介绍了注解的定义、使用和解析。
• 探讨了常用的设计模式，如单例模式、工厂模式和观察者模式。