Java语法细节快速复习

构造函数是必须的；构造函数没有返回值；不构造有参构造函数也会自动创建无参构造函数，但是有参构造函数创建后不会自动创建无参构造函数了
package必须放到java程序的刚开始
非静态方法可以访问静态成员，但是静态方法不可以访问非静态成员
实例变量只能通过对象名访问，类变量既可以通过某个对象名也可以通过类名来访问
final类不能派生子类，final方法不能被覆盖
在方法中使用不定长度参数时，声明的不定长参数必须在参数的最后一个
局部变量可以与成员变量重名
实例变量是属于对象的。一个类的多个对象对实例变量可以设置不同的值
访问权限private< 默认 < protected < public
- public：全局访问，任何类都可访问；
- protected：包内+子类访问，同一包中的类或子类可访问；
- 默认（无修饰符）default：包内访问，仅同一包中的类可访问；
- private：本类访问，仅当前类内部可访问（最严格的封装）
private可以修饰构造方法
抽象方法不能是静态方法，因为静态方法不能被方法重写，但是父类所在的抽象类中的抽象方法被非抽象类子类所继承的话就要实现父类中全部的抽象方法的方法重写，二者相互矛盾
抽象类不可以直接实例化对象
抽象方法必须存在于抽象类（abstract class）或者接口（interface）中，但是
- “An interface is a class-like construct that contains only constants, abstract methods, default methods, and static methods. In many ways, an interface is similar to an abstract class, but an abstract class can contain data fields.” “A class can implement multiple interfaces, but it can only extend one superclass.”
修饰静态内部类用static修饰符
类中所有成员变量在所有成员方法中有效、
final修饰不可修改，static 修饰是可以修改的
private修饰的成员变量不能被子类直接访问，但在创建子类对象时，该变量仍然会被分配内存空间并初始化

一个接口可以继承其他接口；接口中的方法默认是public abstract方法；接口中的属性，都是静态常量

interface MyInterface {
    // 以下三种声明方式完全等价：
    int MAX_VALUE = 100;                    // 最简洁写法
    public static final int MAX_VALUE = 100; // 完整写法
    static final int MAX_VALUE = 100;       // public可省略
    
    // 错误：必须初始化
    // int ERROR_VALUE; // 编译错误
}

类在实现接口的方法时，必须显式地使用public修饰符
抽象类与接口中
abstract可以与final不能修饰同一个类
子类不继承父类的构造方法，需要使用super关键字

接口和类不同，不具有单继承性，它可以继承多个接口。

interface InterfaceA {}
interface InterfaceB {}
interface InterfaceC extends InterfaceA, InterfaceB {}  // ✓ 正确：多继承

// 甚至可以继承更多
interface InterfaceD extends InterfaceA, InterfaceB, InterfaceC {}  // ✓ 正确

执行顺序

// 父类
class Father {
    static { System.out.println("父类静态代码块"); }
    { System.out.println("父类实例代码块"); }
    public Father() { System.out.println("父类构造方法"); }
}
// 子类
class Son extends Father {
    static { System.out.println("子类静态代码块"); }
    { System.out.println("子类实例代码块"); }
    public Son() { System.out.println("子类构造方法"); }
}
// 测试类
public class Test {
    public static void main(String[] args) {
        System.out.println("主方法执行");
        new Son();
    }
}

父类静态代码块
子类静态代码块
主方法执行
父类实例代码块
父类构造方法
子类实例代码块
子类构造方法

遵循「先父后子、先静态后实例」的原则，完整执行流程：

父类静态代码块（多个按从上到下）
子类静态代码块（多个按从上到下）
主方法（若存在）
父类实例代码块（多个按从上到下）
父类构造方法
子类实例代码块（多个按从上到下）
子类构造方法
普通方法（按需调用）

编译看左边，运行看右边

eg1.

class A {
    int v1 = 10;
    int v2 = 10;
    public void m1() {
        System.out.println("A m1");
    }
    public void m2() {
        System.out.println("A m2");
    }
}
class B extends A {
    int v2 = 20;
    int v3 = 20;
    public void m2() {
        System.out.println("B m2");
    }
    public void m3() {
        System.out.println("B m3");
    }
}
public class Main {
    public static void main(String[] args) {
        A a = new B();
        a.m1();
        a.m2();
        a.m3();
        System.out.println(a.v1);
        System.out.println(a.v2);
        System.out.println(a.v3);
    }
}

编译时类型是 A，运行时类型是 B。

在 A 类中，方法有 m1() 和 m2()，没有 m3()。
因此，通过 a.m3() 调用时，编译器检查 A 类型是否有 m3() 方法，结果 A 中没有，所以会编译错误。

同理，A 类的成员变量有 v1、v2，没有 v3，所以 a.v3 也是编译错误。

因此，无法通过编译。

编译错误：找不到符号 a.m3() 和 a.v3，因为编译时类型 A 中没有这些成员

eg2.

class Father {
    int a = 100;
    int b = 200;
    public void print() {
        System.out.println(a + " " + b);
    }
}
class Child extends Father {
    int b = 300;
    int c = 400;
    public void print() {
        System.out.println(a + " " + b + " " + c);
    }
    public void printExtend() {
        System.out.println(c);
    }
}
public class Main {
    public static void main(String[] a) {
        Father obj=new Child();
        System.out.println(obj.a+" "+obj.b);
        obj.print();
    }
}

步骤 1：分析obj的类型

步骤 2：执行System.out.println(obj.a+ " " +obj.b);

步骤 3：执行obj.print();

接口中的方法默认访问权限是_____（public）
Java 中的异常分为受检异常（Checked Exception）和非受检异常（Unchecked Exception），处理要求不同：
1. 受检异常：必须显式处理（捕获try-catch 或声明throws抛出），否则编译报错。比如IOException、SQLException等。
2. 非受检异常：不需要强制捕获，编译能通过（但运行时可能崩溃）。包括运行时异常（如NullPointerException、ArrayIndexOutOfBoundsException）和错误（Error）（如OutOfMemoryError）。

受检异常必须处理，非受检异常可以不处理。

检测到错误的程序可以创建一个适当异常类型的实例并将其抛出，这被称为抛出异常。声明异常的关键字是 throws，而抛出异常的关键字是 throw
异常从属关系

Java 中Throwable的子类是Error和Exception，因此 “异常（广义）分为 Error 和 Exception”
在 Java 中，try不能单独存在（语法要求try必须搭配catch、finally中的至少一个），因此catch和finally不能同时省略。

try块的代码先执行，finally块的代码后执行（这是基础顺序，不存在try在finally之后执行的情况）。

总结：

基础顺序：try（先） → finally（后）
return干扰下：try计算返回值 → finally执行 → try返回暂存的结果

eg:

捕获异常有父子类关系的时候，异常子类在先，异常父类在后
在异常处理中，如释放资源、关闭文件、关闭数据库等由finally子句来完成

posted @ 2025-12-31 14:17 dearbi 阅读(1) 评论(0) 收藏举报来源

刷新页面返回顶部

dearbi

Java语法细节快速复习

公告