Java 核心知识点梳理：修饰符、OOP 与常用 API

一、访问修饰符

（一）public

所有类（无论是否在同一个包或是否子类）都可以访问。用于类、方法、变量、构造函数。

//定义公开的类 public class text1 { 
    //定义公开的变量 public String name="aaa";
    //定义公开的方法 public void printname(){ System.out.println("bbb"); }
    //定义构造函数（方法） public text1() { }
}

（二）protected

同一个包内的类可以直接访问，不同包中的子类可以通过继承（extends）访问，不同包中的非子类无法访问。用于方法、变量（不能用于类和外部接口）。

//定义公开的类（protected 不能定义类） public class text1 {
    //定义变量 protected String a = "A";
    //定义方法 protected void rename(){ System.out.println("rename"); }
}
//不同包下的子类 text2 通过继承 text1 来访问 text1 中的变量和方法
class text2 extends text1{
    protected void rname2(){ System.out.println(a); rename(); }
}

（三）private

仅限声明它的类内部访问。方法、变量（不能用于类和外部接口），外部要使用getter/setter来访问。

//定义公开的类（private 不能定义类） public class text1 {
    //定义私有变量 private String name="Alice";
    //定义私有方法 private void rename(String name){ this.name=name; System.out.println(name); }
    //定义公有方法来调用私有方法 public String getName() { return name; }
    //setter public void setName(String name) { this.name = name; }
    //getter public void name(String name){ rename(name); }
}

（四）default（无修饰符）

同一个包内的类可以直接访问，不同包中的类（无论是否子类）无法访问。用于类、方法、变量、构造函数。

//无修饰符的 default 类 class text1 {
    //无修饰符的 default 变量 String name = "Alice";
    //无修饰符的 default 方法 void rename(String name){ name=name; }
    //无修饰符的 default 构造函数（无参） text1(){}
}

二、行为修饰符

（一）final

类中不能被继承，方法中不能被重写，变量中只能赋值一次（不可变）。

//final 类不能被扩展（继承) final class text1 {
    //final 变量不可修改，只能赋值一次 final String name = "Alice";
    //final 方法不能被重写 final void rename(String name){ name=name;//这是无效代码，因为 name 不能修改。 }
}

（二）static（静态）

定义变量是属于类而不是对象，在对象中可以使用是因为实例共享，定义方法是属于类而不是对象，在对象中可以直接通过类名调用，**代码块（static{...代码...}）**在类第一次加载时才执行（自动）。

public class text1 {
    //静态变量 static String name ="Alice";
    //静态方法 public static void printname(){ System.out.println(name); }
    //代码块 static { name=name+"Liu"; }
}
public class text {
    public static void main(String[] args) {
        //不需要 new 一个 text1 类的实例对象，而是可以直接使用类名来调用类中的静态变量和静态方法
        System.out.println(text1.name);//类第一次加载时执行了代码块，使得原本的 name="Alice"改成了"AliceLiu"
        text1.name="jack";//修改 name 的值，
        text1.printname();//再次加载类时不会执行代码块，所以 name="jack"不会改为"jackLiu"
    }
}
//AliceLiu
//jack 

（三）abstract（抽象）

定义的类不能被实例化，只能被继承，定义的方法只有声明，没有实现，必须由子类重写。

//定义抽象类，只能继承 abstract class text1 {
    //定义抽象方法，只能声明，子类才能重写 public abstract void print(); 
}

（四）synchronized

保证多线程环境下同步访问。

（五）volatile

确保多线程环境下变量的可见性。

三、继承、重写、重载、多态、封装

（一）继承

1.定义

继承是面向对象编程（OOP）的三大核心特性之一（封装、继承、多态），允许一个类（子类/派生类）继承另一个类（父类/基类）的字段（成员变量）和方法，从而实现代码复用。子类可以扩展或修改父类的功能（重写），但无法直接访问父类的 private 成员（除非通过 getter/setter）。

2.特点

单继承：Java 类只能直接继承一个父类（但可以实现多个接口）。

构造方法调用：子类构造方法必须调用父类构造方法（显式或隐式通过 super()）。

访问权限：子类可以访问父类的 public 和 protected 成员，但无法直接访问 private 成员。

3.举例

public class text1 {
    String name;
    public text1() { }
    public text1(String name) { this.name = name; }
    public void rename(){ System.out.println(name+"***"); }
}
public class text extends text1{
    //调用父类的构造方法 public text(String name) { super(name); }
    public void rename(){ System.out.println(name+"..."); }
}

（二）重写

1.定义

重写是子类重新定义父类中已有的方法，以提供不同的实现逻辑。

重写的方法必须与父类方法具有相同的名称、参数列表和返回类型（或子类返回类型是父类返回类型的子类，即协变返回类型）。

重写的方法访问权限不能比父类方法更严格（例如父类方法是 public，子类不能改为 private）。

2.特点

运行时多态：通过父类引用调用重写方法时，实际执行的是子类的实现（动态绑定）。

@Override 注解：建议使用，帮助编译器检查是否正确重写。

不能重写：

• final 方法（禁止重写）。
• static 方法（静态方法属于类，不属于对象，重写会隐藏父类方法）。
• private 方法（子类无法访问，谈不上重写）。

3.举例

//text1 是父类，提供了一个方法 public class text1 {
    public void show(){ System.out.println("hello"); }
}
//text2 继承了 text1，可以重写父类的方法 public class text2 extends text1{
    @Override//注解，用于显示表明重写 public void show(){ System.out.println("helloWorld"); }
}
public class text{
    public static void main(String[] args) {
        //父类引用指向子类对象 (demo1 的引用类型是 text1，但是实际类型是 text2）
        //注意：demo1 只能调用子类中重写父类的方法（即只能调用父类中的方法，而不能调用子类独有的方法）
        text1 demo = new text1();
        text1 demo1 = new text2();
        demo.show();
        demo1.show();
    }
}
//hello
//helloWorld

（三）重载

1.定义

重载是在同一个类中定义多个同名方法，但参数列表不同（参数类型、数量或顺序不同）。形参列表不同指的是：形参的个数、类型、顺序不同，不关心形参的名称。（子类中的两个方法是继承了父类的方法来重写的话，即使两个方法在子类中满足重载的定义，也不是重载，因为是重写父类的方法）

2.特点

编译时多态：根据调用时传入的参数类型和数量决定调用哪个方法（静态绑定）。

常见用途：提供多个便利方法（如 System.out.println() 的多种重载版本）。

3.举例

public class text1 {
    //show() 和 show(String) 两个方法是重载 public void show(){ System.out.println("hello"); }
    public String show(String name){ return "hello"+name; }
}

（四）多态

1.定义

多态是面向对象编程（OOP）的三大核心特性之一（封装、继承、多态），它允许同一方法调用在不同对象上表现出不同的行为。

2.在 Java 中，多态的实现依赖于（实现条件）：

1. 继承（子类继承父类）
2. 方法重写（Override）（子类重写父类方法）
3. 父类引用指向子类对象（如 Animal animal = new Cat();）

3.特点

①同一接口，不同实现：父类定义一个方法，子类可以重写该方法，提供自己的实现逻辑。

②运行时动态绑定：程序在运行时根据对象的实际类型决定调用哪个方法，而不是根据引用变量的声明类型。（如 Animal animal = new Cat();）

4.举例

//text1 是父类，提供了一个方法 public class text1 {
    public void show(){ System.out.println("hello"); }
}
//text2 继承了 text1，可以重写父类的方法 public class text2 extends text1{
    @Override//注解，用于显示表明重写 public void show(){ System.out.println("helloWorld"); }
}
//text3 继承了 text1，可以重写父类的方法 public class text3 extends text1{
    @Override public void show(){ System.out.println("hello world!"); }
}
public class text{
    public static void main(String[] args) {
        //父类引用指向子类对象 (demo1 的引用类型是 text1，但是实际类型是 text2）
        //注意：demo1 只能调用子类中重写父类的方法（即只能调用父类中的方法，而不能调用子类独有的方法）
        text1 demo = new text1();
        text1 demo1 = new text2();
        text1 demo2 = new text3();
        demo.show();
        demo1.show();
        demo2.show();
    }
}
//hello
//helloWorld
//hello world!

（五）封装

封装是将数据和方法包装在一起，限制对对象的直接访问，通常通过私有属性和公共 getter/setter 方法实现。

四、不常见关键字

（一）assert（断言）

1.作用

用于调试，在开发和测试阶段验证某些条件是否为真。如果条件为假，则抛出 AssertionError。

2.格式

①assert true/false : 在抛出的异常里显示的内容;

②开启断言（IntelliJ IDEA 中）

1. 打开 Run——>Edit Configurations
2. 左侧选择你要运行的文件，在右侧找到'Modify options'，选择'Add VM options'
3. 在'VM options'输入框中输入'-ea'（默认禁用断言，禁用可写'-da'）

3.举例

public class text{
    public static void main(String[] args) {
        int x = 5;
        assert x==10 : "x 不等于 10";
        System.out.println("x 是"+x);
    }
}
//开启断言
//Exception in thread "main" java.lang.AssertionError: x 不等于 10
// at dome.text.main(text.java:6)
//不开启断言
//x 是 5

五、Java 异常类

（一）Error

Error 是 Java 中的严重错误，通常由 JVM 抛出，表示系统级错误，如 OutOfMemoryError、StackOverflowError 等。程序通常无法恢复或处理这些错误。

程序会崩溃。

（二）Exception

Exception 是可以通过 try-catch 块程序可以捕获和处理的异常，通常由外部因素（如用户输入、文件读取等）引起，不会导致程序崩溃。Exception 分为 检查型异常（Checked Exception） 和 非检查型异常（Unchecked Exception，即 RuntimeException）。

程序捕获了异常后会打印错误信息并继续执行。不会导致程序崩溃（除非未捕获）。

（三）try_catch_finally

2.finally

①作用

用于执行必要的清理操作（如关闭文件、释放资源等），无论是否发生异常都会执行。

②触发条件

无论 try 块是否抛出异常，无论是否执行了 catch 块，甚至在 try 或 catch 块中使用了 return，finally 仍会执行。

③特点

• 每个 try 块可以没有 catch，但如果有 finally，它必须与 try 配对。（即一个 try 块可以有多个 catch 块，只能有一个 finally 块）
• 可以是try_catch、try_catch_finally、try_finally三种搭配
• 通常用于释放资源，确保程序不会因异常导致资源泄漏。

④举例

import java.util.Scanner;
public class text{
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        try{
            int a = input.nextInt();
        }finally {
            System.out.println("finally 运行...");
        }
    }
}
//hello
//finally 运行...
//Exception in thread "main" java.util.InputMismatchException
// at java.base/java.util.Scanner.throwFor(Scanner.java:943)
// at java.base/java.util.Scanner.next(Scanner.java:1598)
// at java.base/java.util.Scanner.nextInt(Scanner.java:2263)
// at java.base/java.util.Scanner.nextInt(Scanner.java:2217)
// at dome.text.main(text.java:10)

六、运算符

大部分运算符内容在《Java 的基础二》这篇文章中讲解了。

（二）<<、>>、>>>位移运算符

1.作用

用于对二进制位进行操作。它们的主要作用是对数字的二进制表示进行移位，常用于底层编程、性能优化或特定算法（如哈希计算、加密等）。

2.<<（左移运算符）

将一个数的二进制表示向左移动指定的位数，右侧用 0 填充。效果：相当于对该数乘以 2^n（n 是移位的位数）。

public class text{
    public static void main(String[] args) {
        int a =5;//二进制位：00000101
        int b = a<<3;//左移 2 位：00101000（即 40）
        System.out.println(b);//输出 40（5*2^3=40)
    }
}
//40

3.>>（带符号右移运算符）

将一个数的二进制表示向右移动指定的位数，左侧用 符号位（正数补 0，负数补 1）填充。效果：相当于对该数除以 2^n（向下取整）。

public class text{
    public static void main(String[] args) {
        int a = 20;//二进制：00010100
        int b = a>>2;//右移 2 位：00000101(即 5）
        System.out.println(b);//输出 5（20/2^2=5)
        int c=-20;//二进制（补码）：11101100
        int d = c>>2;//右移 2 位：11111011（即 -5）
        System.out.println(d);//输出 -5
    }
}
//5
//-5

4.>>>（无符号右移运算符）

将一个数的二进制表示向右移动指定的位数，左侧 始终用 0 填充，无论该数是正数还是负数。效果：适用于无符号数（Java 的 int/long 是有符号的，但 >>> 可以模拟无符号行为）。

public class text{
    public static void main(String[] args) {
        int c=-20;//二进制（补码）：11101100
        int d = c>>>2;//右移 2 位：00111011（即 1073741819）
        System.out.println(d);
    }
}
//1073741819

（三）&=、^=、|=（按位赋值运算符）

1.&=

①作用

&= 是二进制位运算，它对两个数的每一位进行 与操作。，相当于 x = x & y。它先对两个数进行 按位与（&）运算，然后将结果赋值给左侧变量。

②按位与（&）规则：

• 如果 任意一个对应位为 0，结果为 0。
• 否则为 1。

③举例

public class text{
    public static void main(String[] args) {
        int num1=5;//二进制：0101
        int num2=3;//二进制：0011
        num1&=num2;//即 num1=num1&num2
        System.out.println(num1);
    }
}
//1(0001)

2.^=

①作用

^= 是按位异或赋值运算符，相当于 x = x ^ y。

②按位异或（^）规则：

• 如果两个对应位 相同，结果为 0。
• 如果两个对应位 不同，结果为 1。

③举例

public class text{
    public static void main(String[] args) {
        int num1=5;//二进制：0101
        int num2=3;//二进制：0011
        num1^=num2;//即 num1=num1^num2
        System.out.println(num1);
    }
}
//6(0110)

3.|=

①作用

|= 是按位或赋值运算符，相当于 x = x | y。

②按位或（|）规则：

• 如果 任意一个对应位为 1，结果为 1。
• 否则为 0。

③举例

public class text{
    public static void main(String[] args) {
        int num1=5;//二进制：0101
        int num2=3;//二进制：0011
        num1|=num2;//即 num1=num1 | num2
        System.out.println(num1);
    }
}
//7(0111)

七、数据类型的默认值

数据类型	默认值
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0d
char	'\u0000' 或 '\0'
boolean	false
类（Class）	null
接口（Interface）	null
数组（Array）	null

八、Math 库（java.lang.Math)

Math 库是一个位于 java.lang 包中的工具类，提供了丰富的数学运算方法，且所有方法均为静态方法，可直接通过类名调用，无需调包。

（一）Math.abs(x)——返回参数的绝对值

参数类型：

int、long、float、double

public class Main{
    public static void main(String [] args){
        System.out.println(Math.abs(-10.3));
    }
}
//10.3

（二）Math.max/min(a,b)——分别返回两个参数中的最大值和最小值

参数类型：

int、long、float、double

public class Main{
    public static void main(String [] args){
        System.out.println(Math.max(10,8.9));
    }
}
//10.0

（三）Math.pow(a,b)——返回参数 a 的 b 次方

参数类型：

double

public class Main{
    public static void main(String [] args){
        System.out.println(Math.pow(2,3));
    }
}
//8.0

（四）Math.sqrt(x)——返回参数的平方根

参数类型：

double

public class Main{
    public static void main(String [] args){
        System.out.println(Math.sqrt(16));
    }
}
//4.0

（五）Math.ceil(x) / .floor(x)——向上 / 下取整，返回大于 / 小于等于参数的最小 / 最大整数

参数类型：

double

public class Main{
    public static void main(String [] args){
        System.out.println(Math.ceil(-4.2));
    }
}
//-4.0

（六）Math.round(x)——四舍五入到最接近的整数

参数类型：

public class Main{
    public static void main(String [] args){
        System.out.println(Math.round(4.5));
    }
}
//5

（七）Math.rint(x)——返回最接近参数的整数值，如果是中间值则向偶数方向舍入

参数类型：

double

public class Main{
    public static void main(String [] args){
        System.out.println(Math.rint(4.5));
        System.out.println(Math.rint(5.5));
    }
}
//4.0
//6.0

（八）Math.random()——生成一个 [0.0, 1.0) 之间的随机 double 值

public class Main{
    public static void main(String [] args){
        int r = (int) (Math.random()*10);
        System.out.println(r);
    }
}
//7

（九）Math.PI / Math.E——分别表示圆周率π和自然对数的底 e

public class Main{
    public static void main(String [] args){
        System.out.println(Math.PI);
    }
}
//3.141592653589793

九、常用的 Scanner 数据读取方法

（一）nextInt() —— 读取下一个整数

返回值类型：int

好处：直接读取整数，不会读取多余的空格或换行符，适合解析以空格分隔的多个整数。

import java.util.Scanner;
public class text4 {
    public static void main(String[] arges) {
        Scanner input=new Scanner(System.in);
        int num=input.nextInt();
    }
}

（二）nextDouble() —— 读取下一个浮点数

返回值：double

好处：直接读取浮点数，不会读取多余的空格或换行符，适合解析以空格分隔的多个浮点数。

import java.util.Scanner;
public class text4 {
    public static void main(String[] arges) {
        Scanner input=new Scanner(System.in);
        double num=input.nextDouble();
    }
}

（三）next() —— 读取下一个单词

返回值：String

好处：直接读取字符串，不会读取多余的空格或换行符，适合解析以空格分隔的多个字符串。

import java.util.Scanner;
public class text4 {
    public static void main(String[] arges) {
        Scanner input=new Scanner(System.in);
        String num=input.next();
    }
}

（四）nextLine() —— 读取整行

返回值：String

好处：会读取整行（包括空格和换行符），适合解析以空格分隔得整行数据（数组、列表等）

注意：如果要分割读取整行字符串，代码如下

String line = scanner.nextLine(); // 读取 "10 5"

String[] parts = line.split(" "); // 按空格分割，并存入数组中

import java.util.Scanner;
public class text4 {
    public static void main(String[] arges) {
        Scanner input=new Scanner(System.in);
        String line = input.nextLine(); // 读取 "10 5"
        String[] parts = line.split(" "); // 按空格分割
        System.out.println(parts);
    }
}

（五）hasNextInt() —— 检查下一个输入是否是整数

返回值：boolean

import java.util.Scanner;
public class text4 {
    public static void main(String[] arges) {
        Scanner input=new Scanner(System.in);
        if (input.hasNextInt()) {
            int N = input.nextInt();
        }else {
            System.out.println("请输入整数。");
        }
    }
}

（六）hasNext() —— 检查是否还有输入

返回值：boolean

import java.util.Scanner;
public class text4 {
    public static void main(String[] arges) {
        Scanner input=new Scanner(System.in);
        while (input.hasNext()) { // 检查下一个输入是否有数
            int num = input.nextInt(); // 读取整数
            System.out.println("读取到：" + num);
        }
    }
}

十、将字符或字符串形式的数字转换为对应的整数值（int）

（一）char-'0'

1.原理

利用数字字符的 Unicode 编码连续性（'0'-'9'对应 48-57）

2.举例

public class text4 {
    public static void main(String[] arges) {
        String nums = "12345";
        for (int i=0;i<nums.length();i++){
            //如果直接让 char 类型直接转为 int 类型，会输出的是 Unicode 编码
            char n1 = nums.charAt(i);
            int n2 = n1;
            int n3 = n1-'0';
            System.out.println(n1+"的 Unicode 编码："+n2+",实际 int 值为："+n3);
        }
    }
}
//结果
//1 的 Unicode 编码：49，实际 int 值为：1
//2 的 Unicode 编码：50，实际 int 值为：2
//3 的 Unicode 编码：51，实际 int 值为：3
//4 的 Unicode 编码：52，实际 int 值为：4
//5 的 Unicode 编码：53，实际 int 值为：5

（二）Character.getNumericValue(char)

1.原理

返回字符的 Unicode 数值-'0'==char-'0'（支持数字、字母、罗马数字等）

2.举例

public class text4 {
    public static void main(String[] arges) {
        String nums = "12345";
        for (int i=0;i<nums.length();i++){
            //如果直接让 char 类型直接转为 int 类型，会输出的是 Unicode 编码
            char n1 = nums.charAt(i);
            //对数字字符（'0'~'9'）：它会自动处理为数字值（等价于 char - '0'）
            int n2 = Character.getNumericValue(n1);
            System.out.println(n1+"的实际 int 值为："+n2);
        }
    }
}
//结果
//1 的实际 int 值为：1
//2 的实际 int 值为：2
//3 的实际 int 值为：3
//4 的实际 int 值为：4
//5 的实际 int 值为：5

（三）Integer.parseInt(String)

1.原理

解析字符串并返回 int，支持正负号

2.举例

public class text4 {
    public static void main(String[] arges) {
        String nums = "12345";
        int num = Integer.parseInt(nums);
        System.out.println(num);
    }
}
//结果
//12345

（四）Scanner.nextInt()

1.原理

从输入流中读取下一个整数（处理用户输入或文件中的数字）

2.举例

import java.util.Scanner;
public class text4 {
    public static void main(String[] arges) {
        Scanner input = new Scanner(System.in);
        while (input.hasNext()){
            int num = input.nextInt();
            System.out.print(num);
        }
        input.close();
    }
}
//输入
//123 456
//结果
//123456

（五）手动逐字符转换（适用于大数或面试题）

1.原理

遍历字符串，逐字符转数字并累加（处理超大数字 [超出 int 范围]）

2.举例

public class text4 {
    public static void main(String[] arges) {
        String s = "789ca";
        int ans=0;//用于存储读出来的整数
        for (int i=0;i<s.length();i++){
            char a =s.charAt(i);
            //判断 a 是否是数字字符
            if(a>='0'&&a<='9'){
                //是的话就累加，*10 是因为要给（a-'0'）空出位置，
                //例如：ans=78;那要实现 ans=789 就得 ans*10=780，然后加上 9
                ans=ans*10+(a-'0');
            }else {
                System.out.println("非数字字符："+a);
            }
        }
        System.out.println(ans);
    }
}
//结果
//非数字字符：c
//非数字字符：a
//789

十一、Scanner 类

（一）作用

Java 的 Scanner 类用于解析基本类型和字符串的输入（来自文件、字符串、控制台等），默认使用空格、制表符、换行符作为分隔符

（二）输入源

1.从字符串读取

new Scanner(字符串)

import java.util.Scanner;
public class text4 {
    public static void main(String[] arges) {
        Scanner input = new Scanner("234 567");
        while (input.hasNext()){
            int num = input.nextInt();
            System.out.print(num);
        }
        input.close();
    }
}
//结果
//234567

2.从控制台读取

new Scanner(System.in)

import java.util.Scanner;
public class text4 {
    public static void main(String[] arges) {
        Scanner input = new Scanner(System.in);
        while (input.hasNext()){
            int num = input.nextInt();
            System.out.print(num);
        }
        input.close();
    }
}
//输入
//123 456
//结果
//123456

3.从文件读取

new Scanner(new File("文件名"))

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class text4 {
    public static void main(String[] arges) {
        try {
            // 从文件读取
            Scanner scanner = new Scanner(new File("input.txt"));
            // 逐行或逐个标记读取
            while (scanner.hasNext()) {
                if (scanner.hasNextInt()) {
                    int num = scanner.nextInt();
                    System.out.println("数字：" + num);
                } else {
                    String text = scanner.next();
                    System.out.println("文本：" + text);
                }
            }
            scanner.close();
        } catch (FileNotFoundException e) {
            System.err.println("文件未找到：" + e.getMessage());
        }
    }
}
//结果
//数字：123
//数字：456
//文本：Hello
//文本：World

十二、增强 for

（一）介绍

增强 for 循环（也称为 for-each 循环）是 Java5 引入的一种简化集合和数组遍历的语法结构。

（二）语法

for(元素类型 变量名 : 集合或数组){

//循环体

}

（三）举例

import java.util.ArrayList;
public class text4 {
    public static void main(String[] arges) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(55);
        list.add(23);
        list.add(95);
        for(int num : list){
            System.out.println(num);
        }
    }
}
//结果
//55
//23
//95

（四）底层逻辑

import java.util.ArrayList;
import java.util.Iterator;
public class text4 {
    public static void main(String[] arges) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(23);
        list.add(29);
        list.add(26);
        for (Integer number : list) {
            System.out.println(number);
        }
        // 等价于： Iterator<Integer> it = list.iterator();
        // while (it.hasNext()) {
        //     Integer number = it.next();
        //     System.out.println(number);
        // }
    }
}
//结果
//23
//29
//26

十三、编译错误与运行错误

（一）编译错误

1.定义：

在代码编译阶段（将源代码转换为机器码或字节码时）被发现的错误。

2.特点

①语法错误：如缺少分号、括号不匹配、拼写错误等

②类型错误：如变量类型不匹配

③引用错误：如使用了未定义的变量或方法

④编译错误：程序无法生成可执行文件，直接终止编译

3.结果

编译器直接报错，程序无法运行

4.举例

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello"); // 正确
        int x = "abc"; // 编译时错误：类型不匹配（String 无法赋值给 int）
    }
}

（二）编译正确，运行时错误

1.定义

程序通过编译，但在执行过程中（运行时）发生的错误。

2.特点

①逻辑错误：如空指针访问、数组越界、除零操作等。

②资源问题：如文件未找到、网络连接失败。

③编译通过：代码语法正确，但执行到特定逻辑时崩溃。

3.结果

编译成功，生成可执行文件。运行到错误语句时抛出异常，程序终止。

4.举例

public class Test {
    public static void main(String[] args) {
        String str = null;
        System.out.println(str.length()); // 运行时错误：空指针异常（NullPointerException）
    }
}

十四、常用的切割字符串方法

（一）String.split()

1.作用

使用正则表达式拆分字符串，返回 String[] 数组。

2.特点

1. 返回 String[] 数组
2. 如果分隔符是特殊字符（如 . \ | \ * 等），需要用 \ 转义
3. 默认会忽略连续的分隔符（结果中不包含空字符串）

3.String.split(String regex)——按正则表达式（或简单分隔符）拆分

import java.util.*;
public class text4 {
    public static void main(String[] arges) {
        Scanner input = new Scanner(System.in);
        String s = input.next();
        String[] list = s.split(",");
        System.out.println(Arrays.toString(list));
    }
}
//输入
//1，2，，，3
//结果
//[1，2，，，3]

4.String.split(String regex,int limit)——控制分割次数

①规则

• limit>0：最多分割 limit-1 次，结果数组长度不超过 limit。
• limit=0：等同于 split(regex)，忽略尾部空字符串。
• limit<0：保留所有空字符串（包括尾部）。

import java.util.*;
public class text4 {
    public static void main(String[] arges) {
        Scanner input = new Scanner(System.in);
        String s = input.next();
        //忽略尾部空字符
        String[] list = s.split(",",0);
        //控制分割次数
        String[] list2 = s.split(",",3);
        //保留空字符串
        String[] list3 = s.split(",",-9);
        System.out.println(s+"忽略尾部空字符:"+(Arrays.toString(list)));
        System.out.println(s+"控制分割次数:"+(Arrays.toString(list2)));
        System.out.println(s+"保留空字符串:"+(Arrays.toString(list3)));
    }
}
//输入
//1,2,,,,3,4,,,,,,
//结果
//1,2,,,,3,4,,,,,,忽略尾部空字符:[1, 2, , , , 3, 4]
//1,2,,,,3,4,,,,,,控制分割次数:[1, 2, ,,,3,4,,,,,,]
//1,2,,,,3,4,,,,,,保留空字符串:[1, 2, , , , 3, 4, , , , , , ]

（二）Java8+ 的Stream+Pattern.splitAsStream()

①使用 Java8 的 StreamAPI 拆分字符串，适用于流式处理拆分后的数据

②格式

import java.util.regex.Pattern;//导包

String s = "1,2,3";

Pattern pattern = Pattern.compile(",");//定义分隔符

pattern.splitAsStream(s);//返回 Stream<String>，可以直接用 Stream API 处理。

String str = "1,2,3,4,5";
Pattern pattern = Pattern.compile(",");
pattern.splitAsStream(str)
    .map(Integer::parseInt) // 转换为整数
    .forEach(System.out::println);

（三）substring()+手动拆分

①适用于固定格式，通过 substring() 和 indexOf() 手动拆分

String str = "apple,banana,orange";
int index1 = str.indexOf(",");
int index2 = str.indexOf(",", index1 + 1);
String part1 = str.substring(0, index1); // apple
String part2 = str.substring(index1 + 1, index2); // banana
String part3 = str.substring(index2 + 1); // orange

十五、Java API

（一）介绍

Java API 是一个统称，包含所有 Java 标准库提供的类、接口、方法等，例如：

基础类：Object、String、Math

数值处理：Integer、BigDecimal

集合框架：List、Map

函数式编程：Stream API

工具类：Arrays、Collections

异常处理：Exception 类

（二）Stream API

1. 介绍

函数式数据处理工具，提供了丰富的操作符（方法）来处理集合、数组等数据源。其中中间操作会返回一个新的 Stream，而终止操作会触发计算并返回结果或副作用

2. 中间操作

介绍

中间操作是惰性的（Lazy），不会立即执行，只有遇到终止操作时才会触发整个流水线的计算。

①filter(Predicate predicate)——过滤与筛选

返回值

根据条件筛选元素，返回满足条件的元素组成的 Stream

举例

十六、将字符串转为整型

（一）Integer.parseInt(String s)

• 作用：将字符串解析为 int 基本类型。
• 特点：
  • 如果字符串不是有效的整数格式（如 "abc"），会抛出 NumberFormatException。
  • 不支持前导或后导空格（如 " 123 " 会抛出异常，需先调用 trim()）。
  • 不能解析 null，否则抛出 NullPointerException。

（二）Integer.valueOf(String s)

• 作用：将字符串解析为 Integer 包装类对象（但可自动拆箱为 int）。
• 特点：
  • 内部实际调用了 Integer.parseInt()，但返回的是 Integer 对象。
  • 适用于需要 Integer 对象的场景（如泛型集合）。

（三）Scanner.nextInt()

• 作用：通过 Scanner 从字符串中读取下一个整数。
• 特点：
  • 适用于从复杂输入（如混合了数字和文本）中提取整数。
  • 需要处理 InputMismatchException 如果下一个标记不是整数。

（四）手动转换（不推荐）

• 作用：通过遍历字符串逐字符计算。
• 特点：
  • 仅用于学习原理，实际开发中应使用标准方法。
  • 需要处理符号、溢出、非法字符等复杂逻辑。

String s = "123";
int num = 0;
for (int i = 0; i < s.length(); i++) {
    char c = s.charAt(i);
    if (c < '0' || c > '9') throw new NumberFormatException();
    num = num * 10 + (c - '0');
}

十七、字符串转浮点数

1. 使用 Float.parseFloat() 或 Double.parseDouble()

• Float.parseFloat(String s)
  将字符串解析为 float 基本类型。
• Double.parseDouble(String s)
  将字符串解析为 double 基本类型。

2. 使用 Float.valueOf() 或 Double.valueOf()

• 如果需要 Float 或 Double 包装类对象（而非基本类型），可以使用 valueOf() 方法。
• 返回的是 Float 或 Double 对象，但可以通过自动拆箱转为基本类型。

3. 异常处理

• 如果字符串格式无效（如 "abc"、"12.34.56" 或 null），会抛出 NumberFormatException。
• 必须用 try-catch 处理异常：

String invalidStr = "12.34.56";
try {
    double value = Double.parseDouble(invalidStr);
} catch (NumberFormatException e) {
    System.out.println("错误：" + invalidStr + " 不是有效的浮点数");
}