Java筑基12-类变量和类方法

一、类变量

类变量是什么？

如何访问类变量

类变量使用注意事项

二、类方法

类方法介绍

类方法使用

类方法使用注意事项

三、main方法

深入理解main方法

main方法动态传值

/**
 * @author: 程序员飞扬
 * @description:
 */
public class main {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "]" + args[i]);
        }
    }
}

输出：

args[0]jack

args[1]tom

args[2]alice

四、代码块

代码块是什么

代码块使用注意

情况1：创建对象实例时，静态代码快被执行

/**
 * @author: 程序员飞扬
 * @description:1.创建对象实例时，静态代码快被执行
 */
public class CodeBlockDetail01 {

    public static void main(String[] args) {
        AA aa = new AA();
    }
}

class AA{
    static {
        System.out.println("AA类的静态代码快1被执行。。。");
    }
}

输出：AA类的静态代码快1被执行。。。

情况2：创建子类对象时，父类也会被加载

/**
 * @author: 程序员飞扬
 * @description:
 */
public class CodeBlockDetail01 {

    public static void main(String[] args) {
        BB bb = new BB();
    }
}

class AA{
    static {
        System.out.println("AA类的静态代码快1被执行。。。");
    }
}

class BB extends AA{

}

输出：AA类的静态代码快1被执行。。。

情况3：只使用类的静态成员时，普通代码快不会被调用，普通代码块被隐式的调用

/**
 * @author: 程序员飞扬
 * @description:
 */
public class CodeBlockDetail01 {

    public static void main(String[] args) {
        System.out.println(AA.age);//只使用类的静态成员时，普通代码快不会被调用
        System.out.println("=============");
        AA aa = new AA();//普通代码块被隐士的调用
    }
}

class AA{
    public static int age=25;
    {
        System.out.println("AA类的普通代码快执行了。。。");
    }

}

class BB extends AA{

}

输出：

25

=============

AA类的普通代码快执行了。。。

情况四：创建对象时，在一个类调用顺序是：静态代码快，普通代码快，构造方法

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        AA aa = new AA();
    }
}

class AA{
    public static int age=25;

    public AA() {
        System.out.println("AA的构造方法被执行了");
    }

    {
        System.out.println("AA类的普通代码快执行了。。。");
    }
    
    static {
        System.out.println("AA类的静态代码快1被执行。。。");
    }
    
}

输出：

AA类的静态代码快1被执行。。。

AA类的普通代码快执行了。。。

AA的构造方法被执行了

public class CodeBlockDetail03 {
    public static void main(String[] args) {

        AA aa = new AA();
    }
}

class BB{
    public BB(){
        System.out.println("BB的无参构造器执行了");
    }
}

class AA extends BB{
    public AA() {
        //super();执行本类代码块;
        System.out.println("AA的构造方法被执行了");
    }

    {
        System.out.println("AA类的普通代码快执行了。。。");
    }

}

输出：

BB的无参构造器执行了

AA类的普通代码快执行了。。。

AA的构造方法被执行了

/**
 * @author 程序员飞扬
 *  执行顺序（重点掌握）
 */
public class CodeBlockDetail04 {
    public static void main(String[] args) {

        A01 aa = new A01();
    }
}

class B01{
    public static int varB01 = getVarB01();
    public int varB02 = getVarB02();
    public B01(){
        System.out.println("父类的无参构造器");
    }

    public static int getVarB01(){
        System.out.println("父类的静态属性");
        return 10;
    }

    public int getVarB02(){
        System.out.println("父类的普通属性");
        return 10;
    }

    static{
        System.out.println("父类的静态代码块");
    }

    {
        System.out.println("父类的普通代码块");
    }
}

class A01 extends B01{
    public static int varA01 = getVarA01();
    public int varA02 = getVarA02();
    public A01(){
        System.out.println("子类的无参构造器");
    }

    public static int getVarA01(){
        System.out.println("子类的静态属性");
        return 10;
    }

    public int getVarA02(){
        System.out.println("子类的普通属性");
        return 10;
    }

    static{
        System.out.println("子类的静态代码块");
    }

    {
        System.out.println("子类的普通代码块");
    }

}

输出顺序：

父类的静态属性

父类的静态代码块

子类的静态属性

子类的静态代码块

父类的普通属性

父类的普通代码块

父类的无参构造器

子类的普通属性

子类的普通代码块

子类的无参构造器

---