8 面向对象编程

8.2 理解main方法语法

8.2.1 深入理解main方法

解释main方法的形式：public static void main(String[] args){}

main方法是虚拟机调用
java虚拟机需要调用类的main方法，所以该方法的访问权限必须是public
java虚拟机在执行时不必创建对象，所以该方法必须是static
该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行类的参数
java 执行的程序参数1 参数2 参数3

8.2.2特别提示：

在main()方法中，我们可以直接调用main方法所在类的静态方法或静态属性。

但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，[举例说明]Main01.java

public class Main01{
         //静态的变量/属性
       private static String name=" 666";
         //非静态的变量/属性
       private int n1=10000;
         //静态方法
       public static void hi(){
         System.out.println("Main01的hi方法");
	    }
     	//非静态方法
    	public void cry() {
     		System.out.println("Main01 的 cry 方法");
     	}
 public static void main(String[] args) {
         //可以直接使用 name
         //1. 静态方法main 可以访问本类的静态成员
          System.out.println("name=" + name);
          hi();
         //2. 静态方法main 不可以访问本类的非静态成员
        //System.out.println("n1=" + n1);//错误
        //cry();
         //3. 静态方法main 要访问本类的非静态成员，需要先创建对象 , 再调用即可
         Main01 main01 = new Main01();
         System.out.println(main01.n1);//ok
         main01.cry();
      }
 }

8.3代码块

8.3.1基本介绍

代码块又称为初始代码块，属于类中的成员，是类的一部分，类似于方法，将逻辑语句封装在方法体中，通过{}包围去起来。

但是和方法不同没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显示调用，而是加载类时，或创建对象时隐式调用

8.3.2 基本语法

[修饰符]{
代码
};
说明注意:

修饰符可选, 要写的话, 也只能写 static
代码块分为两类, 使用static修饰的叫静态代码块, 没有static修饰的, 叫普通代码块/非静态代码块
逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断等)
4);号可以写上, 也可以省略。

10.3.3 代码块的好处和案例演示

相当于另外一种形式的构造器(对构造器的补充机制), 可以做初始化的操作
场景:如果多个构造器中都有重复的语句, 可以抽取到初始化块中, 提高代码的重用性

8.3.4 代码块使用注意事项和细节讨论 CodeBlockDetail01.java

static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行。
类什么时候被加载[重要背!]
① 创建对象实例时(new)
② 创建子类对象实例，父类也会被加载
③ 使用类的静态成员时(静态属性，静态方法)
案例演示: A类 extends B类的静态块
普通的代码块，在创建对象实例时，会被隐式的调用。
被创建一次，就会调用一次。
如果只是使用类的静态成员时，普通代码块并不会执行。
小结:1. static代码块是类加载时，执行，只会执行一次

普通代码块是在创建对象时调用的，创建一次，调用一次
类加载的3种情况，需要记住.

package com.ming.codeblock;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        // 类被加载的情况举例
        // 1. 创建对象实例时(new)
        // AA aa = new AA();
        // 2. 创建子类对象实例，父类也会被加载, 而且，父类先被加载，子类后被加载
        // AA aa2 = new AA();
        // 3. 使用类的静态成员时(静态属性，静态方法)
        // System.out.println(Cat.n1);
        
        // static 代码块，是在类加载时，执行的，而且只会执行一次.
    }
    
    class DD {
        DD dd = new DD();
        DD dd1 = new DD();
        
        // 静态属性
        public static int n1 = 8888;
        
        // 静态代码块
        static {
            System.out.println("DD 的静态代码 1 被执行...");
        }
        
        // 普通代码块, 在new 对象时，被调用，而且是每创建一个对象，就调用一次
        // 可以这样简单的理解：普通代码块是构造器的补充
        {
            System.out.println("DD 的普通代码块...");
        }
        
        // 普通代码块，在创建对象实例时，会被隐式的调用。
        // 被创建一次，就会调用一次。
        // 如果只是使用类的静态成员时，普通代码块并不会执行
        public void test() {
            System.out.println(DD.n1); // 8888, 静态代码块一定会执行
        }
    }
}

class Animal {
    // 静态代码块
    static {
        System.out.println("Animal 的静态代码 1 被执行...");
    }
}

class Cat extends Animal {
    public static int n1 = 999; // 静态属性
    
    // 静态代码块
    static {
        System.out.println("Cat 的静态代码 1 被执行...");
    }
}

class BB {
    // 静态代码块
    static {
        System.out.println("BB 的静态代码 1 被执行..."); // 1
    }
}

class AA extends BB {
    // 静态代码块
    static {
        System.out.println("AA的静态代码1被执行..."); // 2
    }
}

创建一个对象时，在一个类调用顺序是:(重点，难点)：
① 调用静态代码块和静态属性初始化(注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用) [举例说明]
② 调用普通代码块和普通属性的初始化(注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)
③ 调用构造方法。
新写一个类演示【CodeBlockDetail02.java】
上面执行的顺序一定要记住:理解的记住..

代码:

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        // 创建 A 类对象，触发各类初始化逻辑
        A a = new A(); 
        // 执行顺序说明（结合代码注释理解）：
        // 1. 加载 A 类时，先执行静态代码块和静态属性初始化（按定义顺序）
        // 2. 创建对象时，执行普通代码块和普通属性初始化（按定义顺序）
        // 3. 最后执行构造器
    }
}

class A {
    // 普通代码块：创建对象时执行，在构造器之前，且每次 new 对象都会执行
    { 
        System.out.println("A 普通代码块 01");
    }

    // 普通属性初始化：调用 getN2() 方法，属于“普通属性初始化”逻辑
    private int n2 = getN2(); 

    // 静态代码块：类加载时执行，只执行一次，优先于普通代码块和构造器
    static { 
        System.out.println("A 静态代码块 01");
    }

    // 静态属性初始化：调用 getN1() 方法，属于“静态属性初始化”逻辑
    private static int n1 = getN1(); 

    // 静态方法：供静态属性初始化调用
    public static int getN1() { 
        System.out.println("getN1 被调用...");
        return 100;
    }

    // 普通方法：供普通属性初始化调用
    public int getN2() { 
        System.out.println("getN2 被调用...");
        return 200;
    }

    // 构造器：对象创建时最后执行的逻辑
    public A() { 
        System.out.println("A() 构造器被调用");
    }
}

/*
输出结果：
A 静态代码块 01
getN1 被调用...
A 普通代码块 01
getN2 被调用...
A() 构造器被调用
*/

构造器的最前面其实隐含了 super()和调用普通代码块，新写一个类演示【截图+说明], 静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于构造器和普通代码块执行的 CodeBlockDetail03.java

class A {
public A() {//构造器
    //这里有隐藏的执行要求
    //(1) super();//这个知识点，在前面讲解继承的时候，老师说
    //(2) 调用普通代码块的
    System.out.println("ok");
}
}

代码

public class CodeBlockDetail03 {
    public static void main(String[] args) {
        new BBB(); 
        // 执行顺序：
        // (1) AAA的普通代码块
        // (2) AAA()构造器被调用....
        // (3) BBB 的普通代码块...
        // (4) BBB() 构造器被调用....
    }
}

class AAA { // 父类，默认继承Object
    // 普通代码块
    {
        System.out.println("AAA的普通代码块");
    }
    
    public AAA() {
        // 构造器中隐含的操作：
        // (1) 先调用父类的无参构造器 super()
        // (2) 再调用本类的普通代码块
        System.out.println("AAA()构造器被调用....");
    }
}

class BBB extends AAA {
    // 普通代码块
    {
        System.out.println("BBB 的普通代码块...");
    }
    
    public BBB() {
        // 构造器中隐含的操作：
        // (1) 先调用父类的无参构造器 super()
        // (2) 再调用本类的普通代码块
        System.out.println("BBB() 构造器被调用....");
    }
}

我们看一下创建一个子类对象时(继承关系)，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下:
① 父类的静态代码块和静态属性(优先级一样，按定义顺序执行)
② 子类的静态代码块和静态属性(优先级一样，按定义顺序执行)
③ 父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
④ 父类的构造方法
⑤ 子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
⑥ 子类的构造方法 // 面试题
AAAAA extends BBBBB 类演示 [ 10Min ]55 CodeBlockDetail04.java
静态代码块只能直接调用静态成员(静态属性和静态方法)，普通代码块可以调用任意成员。学习比较麻烦，工作轻松

public class CodeBlockDetail04 {
    public static void main(String[] args) {
        // 老师说明
        // (1) 进行类的加载
        // 1.1 先加载 父类 A02 
        // 1.2 再加载 B02
        // (2) 创建对象
        // 2.1 从子类的构造器开始
        // new B02();//对象
        new C02();
    }
}

class A02 { // 父类
    private static int n1 = getVal01();
    
    static {
        System.out.println("A02 的一个静态代码块..");// (2)
    }
    
    {
        System.out.println("A02 的第一个普通代码块..");// (5)
    }
    
    public int n3 = getVal02();// 普通属性的初始化
    
    public static int getVal01() {
        System.out.println("getVal01");// (1)
        return 10;
    }
    
    public int getVal02() {
        System.out.println("getVal02");// (6)
        return 10;
    }
    
    public A02() {// 构造器
        // 隐藏
        // super()
        // 普通代码和普通属性的初始化......
        System.out.println("A02 的构造器");// (7)
    }
}

class B02 extends A02 { // 子类
    private static int n3 = getVal03();
    
    static {
        System.out.println("B02 的一个静态代码块..");// (4)
    }
    
    public int n5 = getVal04();
    
    {
        System.out.println("B02 的第一个普通代码块..");// (9)
    }
    
    public static int getVal03() {
        System.out.println("getVal03");// (3)
        return 10;
    }
    
    public int getVal04() {
        System.out.println("getVal04");// (8)
        return 10;
    }
    
    // 一定要慢慢的去品..
    public B02() {// 构造器
        // 隐藏了
        // super()
        // 普通代码块和普通属性的初始化...
        System.out.println("B02的构造器");// (10)
        // TODO Auto-generated constructor stub
    }
}

class C02 {
    private int n1 = 100;
    private static int n2 = 200;
    
    private void m1() {}
    
    private static void m2() {}
    
    static {
        // 静态代码块，只能调用静态成员
        // System.out.println(n1);错误
        System.out.println(n2);// ok
        // m1();//错误
        m2();
    }
    
    {
        // 普通代码块，可以使用任意成员
        System.out.println(n1);
        System.out.println(n2);// ok
        m1();
        m2();
    }
}

posted @ 2025-08-09 21:56 *珍惜当下* 阅读(5) 评论(0) 收藏举报

刷新页面返回顶部

ming-Infinite-progress

8 面向对象编程

8 面向对象编程

8.2 理解main方法语法

8.2.1 深入理解main方法

8.2.2特别提示：

8.3代码块

8.3.1基本介绍

8.3.2 基本语法

10.3.3 代码块的好处和案例演示

8.3.4 代码块使用注意事项和细节讨论 CodeBlockDetail01.java

公告