1.类之间的关系#

1
public class ClassA extends ClassB{...}  //继承
2
public class ClassA implements ClassB{...}  //接口
3
public abstract class TrafficTool{...} //抽象类
4
public abstract void slowDown(); //抽象类中抽象类的写法（后面重写）

2.常用写法#

1
public static void main(String[] args) //Main函数写法

1
for(ClassName i : ArrayListName)  //循环写法
2
ArrayList<ClassName> ArrayListName = new ArrayList<>(); //新建ArrayList
3
lists.add(new ClassA); // 加入到ArrayList中

1
System.out.println(""); //输出

1
public interface Vehicle {
2
    void speedUp();
3
    void slowDown();
4
} // 接口内直接声明，后续重写实现

1
import java.util.Arrays;
2

3
public class Test {
4
    public static void main(String[] args) {
5
        int[] arr = {3,1,4,2};
6

7
        // 1. 打印数组（直接打印数组会输出地址，用Arrays才会输出内容）
8
        System.out.println(Arrays.toString(arr)); // [3, 1, 4, 2]
9

10
        // 2. 数组排序
11
        Arrays.sort(arr);
12
        System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4]
13

14
        // 3. 数组查找
15
        int index = Arrays.binarySearch(arr, 3); // 找元素3的下标
16
        System.out.println(index); // 2
17

18
        // 4. 数组复制
19
        int[] newArr = Arrays.copyOf(arr, arr.length);
20
    }
21
}

1
// 创建 String 对象
2
String str1 = "Hello Java";  // 直接赋值
3
String str2 = new String("Hello Java");  // 构造方法创建（新对象）
4

5
// 获取长度
6
int len = str1.length();
7

8
// 按索引获取字符
9
char ch = str1.charAt(0);  // 获取索引0的字符：'H'
10

11
// 字符串拼接
12
String concatStr = str1.concat(" World");  // 拼接："Hello Java World"
13
String addStr = str1 + "!!!";  // 最常用拼接方式
14

15
// 分割字符串
16
String str = "a,b,c,d";
17
String[] splitArray = str.split(",");  // 按逗号分割，返回数组：["a","b","c","d"]
18

19
// 遍历字符串
20
for (int i = 0; i < str1.length(); i++) {
21
    System.out.println(str1.charAt(i));
22
}

1
Vector vector = new Vector(); //定义
2
vector.add("country China"); //增加内容
3

4
//遍历输出所有元素
5
Iterator it = vector.iterator();//使用迭代器
6
while(it.hasNext()){
7
    System.out.println(it.next());
8
}
9

10
//删除/查找
11
while(it.hasNext()){
12
    String str = (String) it.next();
13
    if(str.startsWith(prefix)){  //考过的 判断str是否以perfix为开头
14
        it.remove(); //安全删除
15
    }
16
}

1
//文件读入
2
import java.io.*;
3
public class ReadFile {
4
    public static void main(String[] args) {
5
        try {
6
            // 按题目提示：FileInputStream → InputStreamReader → BufferedReader
7
            FileInputStream fis = new FileInputStream("java.txt");
8
            InputStreamReader isr = new InputStreamReader(fis);
9
            BufferedReader br = new BufferedReader(isr);
10

11
            String line;
12
            while ((line = br.readLine()) != null) {
13
                System.out.println(line);
14
            }
15
            br.close();
16

17
        } catch (IOException e) {
18
            e.printStackTrace();
19
        }
20
    }
21
}

3.UML题目做题策略#

• 1.根据题目找出有几个类，类里面分别有哪些变量，变量的属性应该是什么？
• 2.根据题目描述找出每个类之间的关系，继承、接口等（注意分析题目中暗示的继承关系）
• 3.判断每个类中有哪些东西是super，哪些是this，哪些可以直接复用

1.Arraylist和vector#

• ArrayList 继承了 AbstractList ，并实现了 List 接口
• Arraylist 线程不安全（Vector线程安全）
• ArrayList 存储的是对象引用，不能存基本数据类型
• ArrayList 是按照插入顺序的有序集合
• ArrayList 可以动态扩展，每次扩展到1.5倍

1
ArrayList<T> a = new ArrayList<T>();  // T为Arraylist中元素类型
2
a.get(n) //来获取Arraylist中的第 `n+1` 个元素（index从0开始）
3
a.set(2, "Wiki"); // 第一个参数为索引位置，第二个为要修改的值
4
a.remove(3); // 删除第四个元素
5
a.size(); // 计算 ArrayList 中的元素数量
6
for(String i : a) // 迭代Arraylist中的元素

• Vector删除时必须用 it.remove() 而非 vector.remove()，否则会抛出 ConcurrentModificationException。

2.继承#

• a instanceof b 只要左对象的实际类型是右类型 本身、子类、间接子类，结果为 true。
• null instanceof 任意类，结果永远是 false
• String类、基本类型类、System类、Math类、Collections类被 final 修饰，不能被继承。
• Java只支持单继承（一个类只能 extends 一个父类），但可以实现多个接口（implements 多个）
• 子类未必有更多成员（若没有新增成员则相同）

3.接口#

public ClassA implements InterfaceA

• 接口不能被实例化，只能被实现
• 接口中的字段默认是 public static final（常量），不能定义普通成员变量，且接口常量必须在声明时直接赋值，且不能修改
• 接口中的方法没有方法体（接口无构造方法）
• 接口中抽象方法默认修饰符为 public abstract
• 接口可以多继承接口，类可以多实现接口。
• 接口不能有 private 方法
• 抽象类有构造方法（供子类 super() 调用）；接口无构造方法
• 抽象类=is-a（本质是什么）；接口=like-a（能做什么）

4.Srting类#

• String 是不可变字符串
• String 是引用类型，不是基本数据类型
• String s1 = "hello"; String s2 = "hello"; 则 s1 == s2 为 true
• String 类被 final 修饰，不能被继承

5.数组#

• 数组的声明： int[] arr; int arr[];(定义引用，未分配内存) int[][] matrix;

• 数组的声明+初始化： int[] arr = new int[3]; int[] arr = {1, 2, 3}; int[] arr = new int[]{1, 2, 3};⭐ int[][] matrix = new int[3][3];

  1
  // 直接赋值，编译器自动计算行列
  2
  int[][] matrix = {{1, 2, 3},{4, 5, 6},{7, 8, 9}};

• 数组的初始化：

  1
  int[] arr; // 第一步：声明数组变量（无内存分配）
  2
  arr = new int[10]; // 第二步：初始化（分配内存，指定长度）
  3
  arr = new int[]{1,2,3}; // 或初始化并赋值

• 注意：Java 数组声明时 int[] 内不能写大小

6.关键字#

• super 关键字：

  • super 代表父类对象引用，只存在于子类中，作用：访问父类的成员变量、成员方法、构造方法。
  • 同名变量、重写方法， super. 指向父类。

• this 关键字：

  • this 代表当前对象本身， this() 调用本类其他构造方法。
  • this() 可以在构造方法中调用本类的其他构造方法
  • this 既能在实例方法中使用，也能在构造方法中使用
  • 静态方法中没有 this

• this() 和 super() 都必须放在构造方法第一行，两者都禁止在 static 中使用。

• static 关键字：修饰类的成员（变量、方法、代码块、内部类），表示属于类本身，而非对象实例 不能被重写

• final 关键字： 不可修改、不可重写、不可继承

  • 可以先声明、后赋值，但仅允许赋值 1 次
  • 声明时不赋值不会报错，但使用前必须完成初始化。
  • static final属于类，类加载时就要完成赋值

• abstract 关键字 抽象、不完整，用来定义模板，强制子类补全实现。可修饰类、方法。

  • 只有方法声明，没有方法体（末尾分号结束） public abstract void eat();
  • 抽象方法必须写在抽象类 / 接口中
  • 子类继承抽象类后：必须重写所有抽象方法
  • abstract 修饰抽象类，不能使用 new 直接实例化
  • 普通子类继承抽象类 → 必须实现全部抽象方法
  • 抽象子类继承抽象类 → 可不用实现抽象方法，继续交由下一代子类实现
  • 包含抽象方法的类一定是抽象类

7.泛型#

• 泛型可用于类、接口、方法
• 泛型在编译期进行类型检查，可用于增强类型安全
• 泛型类型参数只能是引用类型，不能使用基本类型
• 泛型在运行时不保留泛型信息，泛型只在编译时有效
• 泛型集合之间无继承多态关系
• <U extends T> 是上界通配符，意思是 U 必须是 T 本身或 T 的子类（上界为 T）。 对比：<U super T> 是下界通配符，U 必须是 T 或 T 的超类。

8.UML图绘制#

• 类名-属性-方法

9.五大设计模式#

• 单例模式

  • 一个类在整个程序中，有且仅有一个实例，并提供全局唯一访问入口。
  • 私有构造方法：禁止外部 new

  1
  //懒汉式
  2
  public class Singleton {
  3
      private static Singleton instance;
  4
      private Singleton (){}
  5
      public static Singleton getInstance() {
  6
          if (instance == null) {
  7
              instance = new Singleton();
  8
          }
  9
          return instance;
  10
      }
  11
  }

  1
  //饿汉式
  2
  public class Singleton {
  3
      private static Singleton instance = new Singleton();
  4
      private Singleton (){}
  5
      public static Singleton getInstance() {
  6
      return instance;
  7
      }
  8
  }

• 观察者模式

  • 一对多依赖：当被观察者状态改变时，自动通知所有观察者并触发更新
  • 核心角色
    • 被观察者：维护观察者列表，提供增删、通知方法
    • 具体主题：状态改变，触发通知
    • 抽象观察者：定义接收通知的更新接口
    • 具体观察者：收到通知后执行具体逻辑

  1
  public class Subject {
  2
      private List<Observer> observers = new ArrayList<Observer>();
  3
      private int state;
  4
      public int getState(){
  5
          return state;
  6
      }
  7
      public void setState(int state) {
  8
          this.state = state;
  9
          notifyAllObservers();
  10
      }
  11
      public void attach(Observer observer){
  12
          observers.add(observer);
  13
      }
  14
      public void notifyAllObservers(){
  15
          for (Observer observer : observers) {
  16
              observer.update();
  17
          }
  18
      }
  19
  }

  显示更多显示更少

  1
  public abstract class Observer {
  2
      protected Subject subject;
  3
      public abstract void update();
  4
  }

  1
  // BinaryObserver.java 实体观察者类
  2
  public class BinaryObserver extends Observer{
  3
  
  4
      public BinaryObserver(Subject subject){
  5
          this.subject = subject;
  6
          this.subject.attach(this);
  7
      }
  8
  
  9
      @Override
  10
      public void update() {
  11
          System.out.println( "Binary String: " + Integer.toBinaryString( subject.getState() ) );
  12
      }
  13
  }

  每次主函数中subject.setState();时，subject自动调用notifyAllObservers();通知所有attach过的observer，让其更新状态

• 策略模式

  • 定义一系列算法，把每个算法封装成独立类，算法之间可自由切换
  • 使用到了重写，未使用重载
  • 核心是将算法的定义和使用分离
  • 核心角色
    • 抽象策略：接口 / 抽象类，定义算法统一规范
    • 具体策略：实现不同算法
    • 环境上下文：持有策略引用，对外提供调用入口

  1
  public interface Strategy {
  2
      public int doOperation(int num1, int num2);
  3
  }
  4
  
  5
  // Operation1.java
  6
  public class Operation1 implements Strategy{
  7
      @Override
  8
      public int doOperation(int num1, int num2) {
  9
          return num1 + num2;
  10
      }
  11
  }
  12
  
  13
  // Context.java
  14
  public class Context {
  15
      private Strategy strategy;
  16
      public Context(Strategy strategy){
  17
          this.strategy = strategy;
  18
      }
  19
      public int executeStrategy(int num1, int num2){
  20
          return strategy.doOperation(num1, num2);
  21
      }
  22
  }
  23
  
  24
  // MainClass.java
  25
  public class MainClass {
  26
      public static void main(String[] args) {
  27
          Context context = new Context(new OperationAdd());
  28
      }
  29
  }

  显示更多显示更少

• 装饰器模式

  • 动态地给一个对象添加额外的职责，同时不改变其结构
  • 提供了一种灵活的替代继承方式来扩展功能
  • 核心角色
    • 抽象构件：顶层抽象接口/类，定义核心行为
    • 具体构件：原始基础对象（被装饰的主体）
    • 抽象装饰器：继承/实现抽象构件，持有抽象构件引用
    • 具体装饰器：在原有功能上叠加新逻辑

  1
  public interface Shape {
  2
      void draw();
  3
  }
  4
  public class Rectangle implements Shape {
  5
      @Override
  6
      public void draw() {
  7
          System.out.println("Shape: Rectangle");
  8
      }
  9
  }
  10
  public class Circle implements Shape {
  11
      @Override
  12
      public void draw() {
  13
          System.out.println("Shape: Circle");
  14
      }
  15
  }
  16
  public abstract class ShapeDecorator implements Shape {
  17
      protected Shape decoratedShape;
  18
      public ShapeDecorator(Shape decoratedShape){
  19
          this.decoratedShape = decoratedShape;
  20
      }
  21
      public void draw(){
  22
          decoratedShape.draw();
  23
      }
  24
  }
  25
  public class RedShapeDecorator extends ShapeDecorator {
  26
      public RedShapeDecorator(Shape decoratedShape) {
  27
          super(decoratedShape);
  28
      }
  29
      @Override
  30
      public void draw() {
  31
          decoratedShape.draw();
  32
          setRedBorder(decoratedShape);
  33
      }
  34
      private void setRedBorder(Shape decoratedShape){
  35
          System.out.println("Border Color: Red");
  36
      }
  37
  }
  38
  public class DecoratorPatternDemo {
  39
      public static void main(String[] args) {
  40
          Shape circle = new Circle();
  41
          ShapeDecorator redCircle = new RedShapeDecorator(new Circle());
  42
          System.out.println("Circle with normal border");
  43
          circle.draw();
  44
          System.out.println("\nCircle of red border");
  45
          redCircle.draw();
  46
      }
  47
  }

  显示更多显示更少

• 组合模式

  • 把单个对象和由多个对象组成的 “整体容器”，当成一模一样的东西来用
  • 单个节点、一组节点，调用方式完全一样
  • 将对象组合成树形结构以表示”部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性
  • 核心角色：
    • Component接口：定义了所有对象必须实现的操作
    • Leaf类：实现Component接口，代表树中的叶子节点
    • Composite类：也实现Component接口，并包含其他Component对象的集合

  1
  //抽象构件（统一接口）
  2
  public abstract class FileNode {
  3
      public abstract void show();
  4
  }
  5
  
  6
  // 叶子节点（文件，无子节点）
  7
  public class File extends FileNode {
  8
      private String name;
  9
      public File(String name) { this.name = name; }
  10
      @Override
  11
      public void show() {
  12
          System.out.println("文件：" + name);
  13
      }
  14
  }
  15
  
  16
  // 容器节点（文件夹，可存子节点）
  17
  import java.util.ArrayList;
  18
  import java.util.List;
  19
  public class Folder extends FileNode {
  20
      private String name;
  21
      private List<FileNode> childs = new ArrayList<>();
  22
      public Folder(String name) { this.name = name; }
  23
  
  24
      // 添加子节点（文件/文件夹）⭐⭐⭐
  25
      public void add(FileNode node) {
  26
          childs.add(node);
  27
      }
  28
  
  29
      @Override
  30
      public void show() {
  31
          System.out.println("文件夹：" + name);
  32
          // 遍历所有子节点
  33
          for (FileNode node : childs) {
  34
              node.show();
  35
          }
  36
      }
  37
  }

  显示更多显示更少

• 策略模式：换算法/换行为（做加法、减法、乘法，直接换一套逻辑） 装饰器模式：在原有功能上叠加功能（原功能保留，外面多加东西）

10.Package包#

• 包（package）用于组织类和接口，类似文件夹，提供命名空间
• 同一包内不能有同名类、不同包之间可以有同名类
• 包中的类可以是 default（包访问权限），不必须是 public
• 包不需要层层嵌套定义声明，包的目录结构层层对应，但声明时直接写全路径 例如 package com.student.util;

11.重写和重载#

重载是「同一个类里方法同名不同参」，重写是「子类改写父类方法」

• 重载（Overload）
  • 在同一个类中，多个方法方法名相同，但参数列表不同，彼此互为重载
  • 必要条件：①方法名完全一致；②参数（个数、类型或者顺序）必须不同
  • 注意：仅返回值不同，不能构成重载
• 重写（Override）
  • 子类继承父类后，子类重新定义一个和父类签名完全一致的方法，覆盖父类原有实现
  • 必要条件：
    • 方法名和参数列表（个数、类型、顺序）完全相同
    • 返回值必须一模一样（子类返回值可以是父类返回值的子类（协变返回））
    • 子类方法权限不能比父类更严格
    • 子类抛出的受检异常，不能比父类更大/更多；可以：不抛异常、抛父类异常、抛父类异常的子类。
  • 注意：
    • final类型方法不能被重写
    • 父类的private方法子类看不见，本质不算重写
    • static静态方法不能被重写，只会 “隐藏”
    • abstract方法，普通子类必须重写
    • 构造方法不能重写，只能重载

12.异常#

• Java中Exception和Error类都来自于Throwable类
• 非检查异常（Unchecked） = RuntimeException 及其子类，编译器不强制处理： NullPointerException ArrayIndexOutOfBoundsException ClassCastException 等。
• 检查异常（Checked）：IOException SQLException ClassNotFoundException，必须 try-catch 或 throws
• 运行时异常（UncheckedException）编译器不强制处理
• RuntimeException（非检查异常）不必显式捕获
• 同一异常对象可以被 catch 后再 throw，可以多次抛出
• 异常没有被处理，放在callstack（调用栈）中
• try-catch-finally 异常处理

  1
  // 标准格式
  2
  try {
  3
      // 可能出现异常的代码（监控区）
  4
      // 一旦代码出现异常，try 块内后续代码立即停止执行，直接跳转到匹配的 catch
  5
      // try 不能单独存在，后面必须跟 catch 或 finally
  6
  } catch (异常类型 异常对象) {
  7
      // 捕获对应异常后的处理逻辑
  8
      // 多个 catch 遵循：子类异常在前，父类异常在后
  9
      // 只会执行第一个匹配到异常类型的 catch，其余 catch 不再执行
  10
  
  11
      // 常见打印报错用的语句：
  12
      // e.getMessage(); 只打印异常原因文本，无类名、堆栈
  13
      // e.toString(); 打印异常类名 + 异常原因
  14
      // e.printStackTrace(); 输出异常类型、原因、代码报错行号、调用栈
  15
  } finally {
  16
      // 正常执行、出现异常、catch 中 return，finally 都会执行
  17
      // 属于无论是否发生异常，**必定执行**的代码
  18
      // 唯一不会执行 finally 的场景：
  19
      // 执行 System.exit(0) 直接终止 JVM；
  20
      // 程序所在线程被杀死、宕机等极端情况。
  21
  }

  显示更多显示更少
  • 无异常：try → finally
  • 有异常，被 catch 捕获：try(中断) → catch → finally
  • 有异常，无对应 catch：try(中断) → finally → 异常向外抛出

  1
  Throwable (父类)
  2
  ├── Error (错误，不可处理)
  3
  └── Exception (异常，可处理)
  4
      ├── RuntimeException (运行时异常，非受检)
  5
      └── UncheckedException (编译时异常，受检)

13.内部类#

• 写在另一个类内部的类，外部包裹的类叫外部类
• 成员内部类：
  • 属于外部类的实例对象，依赖外部类实例
  • 成员内部类可以直接访问外部类的私有成员
  • 不能定义静态成员

  1
  // 方式1：外部类.内部类 引用 = 外部对象.new 内部类()
  2
  Outer.Inner in = new Outer().new Inner();

• 静态内部类：
  • 用 static 修饰，属于外部类本身，不依赖外部类实例
  • 静态内部类不能访问外部类的非静态成员
  • 可以正常定义静态变量、静态方法、实例成员

  1
  // 无需外部类实例
  2
  Outer.StaticInner si = new Outer.StaticInner();

• 局部内部类
  • 定义在方法、代码块、构造器内部，作用域仅限当前局部
  • 局部内部类只能在定义它的方法内使用
  • 不能使用 public/private/protected/static 修饰
  • 可以访问外部类所有成员
  • 若访问所在方法的局部变量，该变量必须是 final
• 匿名内部类
  • 没有类名，一次性使用，简写代码
  • 本质：快速继承一个类 / 实现一个接口
  • 只能继承一个类或实现一个接口

14.构造方法#

• 构造方法：类创建对象时，自动调用的特殊方法，作用是初始化对象成员
• 构造方法只有new的时候才会调用，平时不使用
• 构造方法不能被继承，但子类可通过 super() 调用
• 构造方法没有返回值类型声明（void 也没有）
• 构造方法名必须与类名完全相同
• 一个类可以有多个构造方法（构造方法重载）
• this() 与 super() 调用构造
  • this() 调用本类中其他重载的构造方法
  • super() 调用父类的构造方法，子类构造默认第一行隐式存在 super()
  • 必须写在构造方法第一行
  • 同一构造中，this() 和 super() 只能二选一，不能共存
  • 不能循环调用
  • 父类没有无参构造时，子类必须手动写 super(实参) 指定调用父类有参构造
• 不能用 static、final、abstract、native 修饰构造方法
• 构造方法只存在重载、不存在重写
• 抽象类有构造方法、接口没有构造方法
• 核心用途：给新建的对象赋初始值，避免创建对象后再手动赋值

15.多态#

• 同一个方法，不同对象执行不同实现；父类引用指向子类对象
• 多态可以通过继承或接口实现，然后重写父类方法
• 多态的优点：提高代码扩展性和可维护性

16.关联和聚合#

• 关联(Association)
  • 表示两个类之间存在一种长期的、稳定的连接
  • 通常表现为一个类将另一个类作为成员变量
  • 两个对象的生命周期通常是独立的
• 聚合(Aggregation)
  • 关联的一种特殊形式，表示“整体与部分”的关系
  • 依然是成员变量，但在业务逻辑上强调“包含”关系，且该对象通常是从外部传入或共享的
  • 一个“部分”对象可以同时属于多个“整体”对象
  • 部分（Part）可以脱离整体（Whole）而独立存在，整体的销毁不一定导致部分的销毁
• 聚合是关联的特殊形式

17.静态模型和对象模型#

• 静态模型 (Static Model)
  • 静态模型是对象模型中关于结构的那一部分
  • 它关注的是系统在不运行、不随时间变化时的组成成分及其相互关系
  • 不涉及“先做什么后做什么”，也不涉及状态的改变
• 对象模型 (Object Model)
  • 对象模型是对现实世界问题域或系统解决方案的全面抽象
  • 包含类的定义，还包含了对象之间的交互、状态变化以及系统的动态行为
  • 既包含静态结构（类图）
  • 也包含动态行为（序列图、状态图、活动图、协作图）

18.文件读写#

• 文件写入：
  • PrintWriter
    • print()：输出内容不换行
    • println()：输出内容末尾自动换行
    • printf()：格式化输出
    • 必须调用 close() 关闭流释放资源
  • FileWriter：基础字符写入流，可写单个字符、字符串、字符数组，支持 flush() 刷新缓冲区、close() 关闭
  • BufferedWriter：缓冲字符写入流，效率更高，newLine() 实现跨平台换行
• 文件读入：
  • Scanner
    • hasNext()：判断是否还有数据
    • next()/nextInt()/nextDouble()：按分隔符读取数据
    • nextLine()：读取一整行
  • FileReader：基础字符读取流，read() 读单个字符，读到文件末尾返回 -1
  • BufferedReader
    • readLine()：读取一整行，文件末尾返回 null
• 多层包装：FileInputStream → InputStreamReader → BufferedReader（字节流转字符流 + 缓冲）
• 异常处理
  • 读文件：文件不存在 → 抛出 FileNotFoundException（受检异常，必须捕获 / 声明）
  • 写文件：文件不存在 → 自动创建，不报错
  • 所有流操作异常父类：IOException
• Reader读入字符 Stream读入字节

小知识点#

• 类型转换
  • 自动转换（隐式）：小范围到大范围
  • 强制转换（显式）：大范围到小范围，需加 (类型) 强转符
• 浮点数字面量默认是 double 类型
  • 错误写法：float x = 6.0;
  • 正确写法：float x = (float) 6.0; 或 float x = 6.0f;
• 装箱 & 拆箱（包装类（Wrapper Class）是指将基本数据类型（Primitive Type）封装成对象的类）
  • 装箱：基本类型 → 对应的包装类
  • 拆箱：包装类 → 基本类型
• 实例变量：属于对象，对象创建后才分配内存
  静态变量：被 static 修饰，属于类，所有对象共享，类加载时初始化
• import 中 * 的作用：导入该包下所有类 / 接口，简化代码，无需逐个导入类
• JavaDoc：专门用于生成程序帮助文档，一般用于类、方法、成员变量上方
  • JavaDoc的首句：概要描述
  • 标签：@author , @version , @return 对代码附加声明
• Java 标识符规则：只能由字母、数字、_ 、$ 组成，不能以数字开头，不能是关键字。
• 数组索引从 0 开始
• Java 独立运行的程序叫 Application（应用程序），有 main() 方法作为入口。 Applets 运行在浏览器中（已废弃）， Servlets 运行在服务器端， Midlets 是 J2ME 移动程序
• Java类初始化顺序（加载及实例化顺序）：
  • 静态变量 → 静态代码块 → 构造代码块 → 构造方法（同级按代码顺序）
  • 静态变量/静态代码块（类加载时，只执行一次）
  • 构造代码块（每次创建对象执行）
• Java中所有类的根类是Object类，所有类都隐式继承Object
• JVM = Java Virtual Machine（Java 虚拟机）。它负责将字节码（.class）翻译为机器码执行，是 Java “一次编写，到处运行”的基础。
• Stack trace（堆栈跟踪）是异常发生时打印的方法调用链，显示从哪个方法调用到哪个方法最终触发了异常，帮助定位错误位置。还可用于理解执行流程、排查性能问题 栈轨迹是方法调用的序列，不是变量列表，也不是错误本身。
• 集合（Collection）表示一个对象拥有多个其他对象，体现的是 one-to-many（一对多）关系
• 当 System.exit() 被调用或 JVM 崩溃时，finally块不执行
• java.util.Calendar 使用 单例模式，通过 Calendar.getInstance() 获取实例，构造方法是 protected，不允许直接 new。 Runtime 类（Runtime.getRuntime()）也是典型单例。
• Java 编译器自动隐式导入 java.lang.*，所以 String、System、Math、Object 等无需 import。java.util 需要手动 import
• 文件读写
  • 打开不存在的文件进行读取时，Java 会抛出 FileNotFoundException，这是 IOException 的子类，属于 Checked Exception，必须处理。
• Object 类的方法：toString、equals、hashCode、getClass、clone、wait、notify、notifyAll、finalize
• 静态方法：
  • 静态方法中没有 this（无当前对象）
  • 静态方法不能是 abstract（abstract 要求子类实现，静态方法不被重写）
  • 静态方法只能直接访问静态变量和静态方法
  • 静态方法属于类本身，通过 类名.方法名() 调用
• 抽象类和接口都可以有数据字段，只是接口中的数据字段默认为常量
• equals(Object obj)用来测试两个字符串是否相等
• public static void main 中修饰符的顺序可以改变
• FlowLayout 是 Panel 和 Applet 的默认布局管理器（从左到右，超出则换行）。JFrame/Frame 默认是 BorderLayout；JPanel 默认也是 FlowLayout
• java.awt.* 是 Java AWT 图形界面的基础包，含 Frame、Panel、Button、Label 等核心组件