Java 面向对象编程

面向对象基础

方法（Method）

定义：在类中声明的可执行代码块，用于实现特定功能。

语法：

1
2
3

[修饰符] 返回类型 方法名([参数列表]) {
    // 方法体
}

调用：通过对象或类名（静态方法）来调用。

示例：

1
2
3

public int add(int a, int b) {
    return a + b;
}

构造方法（Constructor）

定义：用于初始化新创建对象的特殊方法，名称与类名相同，无返回类型。
默认构造器：若类中未定义任何构造方法，编译器会自动提供一个无参构造器。
重载构造器：可定义多个不同参数列表的构造器。

示例：

public class Person {
    private String name;
    public Person() {             // 无参构造
        this.name = "未知";
    }
    public Person(String name) { // 带参构造
        this.name = name;
    }
}

方法重载（Overloading）

定义：同一类中，方法名相同但参数列表（类型、个数或顺序）不同。
作用：提高可读性，根据不同输入类型或数量执行不同逻辑。
注意：仅返回类型不同不能构成重载。

示例：

1
2
3

public void print(int i) { … }
public void print(String s) { … }
public void print(int i, String s) { … }

继承（Inheritance）

定义：一个类（子类）继承另一个类（父类）的属性和方法，用 extends 关键字。
优点：代码重用、可扩展。

示例：

1 2	public class Animal { … } public class Dog extends Animal { … }

多态（Polymorphism）

定义：同一操作作用于不同对象时，可以有不同的行为表现。
两种形式：
1. 编译时多态（方法重载）
2. 运行时多态（方法重写 + 向上转型）

示例：

1 2	Animal a = new Dog(); // 向上转型 a.makeSound(); // 调用 Dog 的实现

抽象类（Abstract Class）

定义：包含抽象方法（无实现）和/或具体方法的类，用 abstract 修饰。
特点：
- 无法实例化，只能被继承；
- 子类必须实现所有抽象方法，或自身也声明为抽象类。

示例：

public abstract class Shape {
    public abstract double area();
    public void describe() {
        System.out.println("这是一个图形");
    }
}

接口（Interface）

定义：只声明方法签名（Java 8+ 可以有默认方法和静态方法），用于指定一组行为规范。
实现：类使用 implements 实现接口，必须实现全部抽象方法。
多继承：一个类可以实现多个接口。

示例：

public interface Flyable {
    void fly();
    default void land() { System.out.println("降落"); }
    static void info() { System.out.println("可飞行"); }
}

静态字段和静态方法（static）

静态字段：属于类本身，被所有实例共享。
静态方法：属于类，可直接通过类名调用，方法内部不能使用 this。
用途：常量定义、工具方法、工厂方法等。

示例：

public class MathUtil {
    public static final double PI = 3.14159;
    public static int max(int a, int b) { return a > b ? a : b; }
}

包（Package）

定义：类的命名空间，用于组织和管理类。
声明：源文件第一行使用 package 关键字。
访问控制：包级别访问（无修饰符）限制在同包内可见。

示例：

1 2	package com.example.app; public class App { … }

作用域（Scope）

分类：
- 类级：public、protected、默认（包内）、private
- 局部变量：方法、构造器或代码块内部声明，只在声明块内可见
原则：“最少可见性”原则，尽量使用私有或包内访问控制。

内部类（Inner Class）

类型：
1. 成员内部类（非静态）
2. 静态内部类（nested static）
3. 局部内部类（在方法内部）
4. 匿名内部类
用途：逻辑上属于外部类、访问外部类成员、事件监听器等。

示例：

public class Outer {
    private int x = 10;
    class Inner { 
        void show() { System.out.println(x); } 
    }
    static class StaticInner { … }
}

模块（Module）

定义：一组包的集合，有自己独立的模块描述符 module-info.java。
关键字：module、requires、exports。
作用：增强封装性，支持模块化开发，控制可见性与依赖。

示例：

// module-info.java
module com.example.app {
    requires java.sql;
    exports com.example.app.api;
}

Java 核心类

字符串（`java.lang.String`）

不可变：每次对字符串的修改都会产生新的 String 对象。
常用方法：
- 长度与判断：length()、isEmpty()
- 查找：indexOf(…)、lastIndexOf(…)
- 截取与拼接：substring(…)、concat(…)
- 比较：equals(…)、equalsIgnoreCase(…)、compareTo(…)
- 转换：toUpperCase()、toLowerCase()、trim()
- 正则：matches(…)、replaceAll(…)、split(…)
常见用法：缓存字符串池（"..." 原语字面值）、避免频繁拼接导致大量临时对象。

可变字符序列（`java.lang.StringBuilder`／`StringBuffer`）

StringBuilder
- 非线程安全，性能更高。
- 常用方法：append(…)、insert(…)、delete(…)、reverse()、toString()
StringBuffer
- 线程安全，内部方法加了 synchronized，适合多线程场景。

示例：

1
2
3

StringBuilder sb = new StringBuilder();
sb.append("Hello").append(", ").append("World!");
String result = sb.toString();

字符串连接器（`java.util.StringJoiner`）

用途：高效、优雅地将多个元素用指定分隔符连接成字符串，并可选地添加前缀/后缀。

构造示例：

// 仅分隔符
StringJoiner sj1 = new StringJoiner(", ");
// 分隔符 + 前缀 + 后缀
StringJoiner sj2 = new StringJoiner(" | ", "[", "]");
sj2.add("A").add("B").add("C");
System.out.println(sj2.toString()); // [A | B | C]

包装类型（Wrapper Classes）

作用：将基本类型（int、char、boolean…）封装为对象，以便在泛型、集合等场景中使用。
常见包装类：
- 数值：Byte、Short、Integer、Long、Float、Double
- 布尔与字符：Boolean、Character
自动装箱/拆箱：编译器自动在基本类型与包装类型之间转换。
常用方法：
- 转换：parseXxx(String)（如 Integer.parseInt("123")）
- 值获取：intValue()、booleanValue() 等
- 常量：Integer.MAX_VALUE、Double.NaN 等

JavaBean 规范

定义：满足以下条件的普通 Java 类：
1. 公有无参构造器；
2. 属性私有（private 字段），提供对应的公有 getter/setter；
3. 实现 Serializable 接口（可选，但在一些框架里常见）。
用途：数据封装和传输（如 ORM 实体、DTO、表单绑定等）。

示例：

public class User implements Serializable {
    private String name;
    private int age;
    public User() {}  // 无参构造器
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
}

枚举（`java.lang.Enum`／`enum`）

定义：一组命名常量的类型安全集合。
特性：
- 隐式继承自 java.lang.Enum，不能再继承其他类；
- 可定义字段、方法、构造器；
- 自带 values()（返回所有枚举值）与 valueOf(String) 方法。

示例：

public enum DayOfWeek {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
    public boolean isWeekend() {
        return this == SATURDAY || this == SUNDAY;
    }
}

常用工具类

以下是 JDK 中非常常用的一些工具类，它们大多以一组静态方法的形式出现：

类名	主要用途
`java.util.Arrays`	数组操作：排序、查找、填充、比较、转列表等
`java.util.Collections`	集合操作：排序、线程安全包装、不可变集合、搜索等
`java.util.Objects`	对象操作：空指针安全检查（`requireNonNull`）、比较、哈希码、`toString` 辅助等
`java.lang.Math`	数学运算：三角、指数、对数、随机数、舍入等
`java.util.Optional`	避免 `null` 判空，提供流式链式 API
`java.util.UUID`	生成唯一标识符
`java.time` 系列（Java 8+）	日期/时间处理：`LocalDateTime`、`Duration`、`DateTimeFormatter` 等
`java.util.concurrent.*`（常见子包）	并发工具：锁、线程池、`Atomic` 类、并发集合等

`java.lang.Math`

定位：提供基本的数学运算方法，全部为 static，无需实例化。
常用方法：
- 三角函数：sin(double)、cos(double)、tan(double)
- 指数与对数：exp(double)、log(double)、pow(double, double)
- 舍入：ceil(double)、floor(double)、round(double)
- 绝对值与符号：abs(int/long/float/double)、signum(double)
- 最大/最小：max(a, b)、min(a, b)
- 随机数：random()（返回 [0.0,1.0)）
特点：
- 方法调用开销小，底层调用 C 语言库
- random() 适用于一般场景，但不保证高质量随机性

double r = Math.random();           // [0.0,1.0)
double v = Math.max(3.2, 4.7);      // 4.7
long l = Math.round(2.6);           // 3
double p = Math.pow(2, 10);         // 1024.0

`java.util.HexFormat` (Java 17+)

定位：在 JDK 17 中引入，用于在字节数组与十六进制字符串之间进行高效互转。

创建方式：

1 2	HexFormat hf = HexFormat.of(); // 默认小写，无分隔符 HexFormat hf2 = HexFormat.ofDelimiter(":", HexFormat.Style.UPPER);

常用方法：
- 编码：formatHex(byte[])、formatHex(ByteBuffer)
- 解码：parseHex(CharSequence)（支持可选分隔符）
特点：
- 支持自定义大小写（UPPER/LOWER）与分隔符
- 性能优于传统的手写循环或第三方库

1
2
3

byte[] data = { (byte)0xDE, (byte)0xAD, (byte)0xBE, (byte)0xEF };
String hex = HexFormat.of().formatHex(data);      // "deadbeef"
byte[] back = HexFormat.of().parseHex(hex);       // [ -34, -83, -66, -17 ]

`java.util.Random`

定位：伪随机数生成器（PRNG），线程安全但在高并发下可能成为性能瓶颈。
构造器：
- new Random() — 基于系统时间的种子
- new Random(long seed) — 指定种子，保证可重现序列
常用方法：
- 基础随机：nextInt()、nextLong()、nextDouble()、nextFloat()
- 指定范围：nextInt(bound)、ints(...)、doubles(...) 等 stream API
特点：
- 同一种子下序列可预测，不适用于安全场景
- Java 8+ 提供流式生成方法，支持并行化处理

Random rnd = new Random();
int x = rnd.nextInt(100);           // [0,100)
double d = rnd.nextDouble();        // [0.0,1.0)
long[] arr = rnd.longs(5, 1, 10).toArray();  // 5 个 [1,10) 的 long

`java.security.SecureRandom`

定位：强随机数生成器，基于操作系统熵源，适合加密、令牌、会话 ID 等安全场景。
获取实例：
- SecureRandom sr = new SecureRandom();
- SecureRandom.getInstance("SHA1PRNG") 或使用其他算法、提供者
常用方法：
- nextBytes(byte[]) — 填充随机字节
- 同 Random 的 nextInt()、nextLong()、nextDouble() 等
特点：
- 初始化可能较慢（等待熵池填充）
- 不同平台可能有不同的默认实现和算法

SecureRandom sr = new SecureRandom();
byte[] nonce = new byte[16];
sr.nextBytes(nonce);                // 填充 16 字节安全随机数
int y = sr.nextInt(1000);           // [0,1000)

Java 面向对象编程

面向对象基础

方法（Method）

构造方法（Constructor）

方法重载（Overloading）

继承（Inheritance）

多态（Polymorphism）

抽象类（Abstract Class）

接口（Interface）

静态字段和静态方法（static）

包（Package）

作用域（Scope）

内部类（Inner Class）

模块（Module）

Java 核心类

字符串（java.lang.String）

可变字符序列（java.lang.StringBuilder／StringBuffer）

字符串连接器（java.util.StringJoiner）

包装类型（Wrapper Classes）

JavaBean 规范

枚举（java.lang.Enum／enum）

常用工具类

java.lang.Math

java.util.HexFormat (Java 17+)

java.util.Random

java.security.SecureRandom

字符串（`java.lang.String`）

可变字符序列（`java.lang.StringBuilder`／`StringBuffer`）

字符串连接器（`java.util.StringJoiner`）

枚举（`java.lang.Enum`／`enum`）

`java.lang.Math`

`java.util.HexFormat` (Java 17+)

`java.util.Random`

`java.security.SecureRandom`