Java基础之：OOP——代码块 / 开普饭

代码块又称初始化块，是类中的成员(即类的一部分)，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来，也是通过调用执行。

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

基本语法

[修饰符]{

代码(方法体)

};

说明：

修饰符可选是否添加，但只能添加static
代码块分为两种，加了static的静态代码块，没加static的普通代码块
逻辑语句可以是任何逻辑语句(输入、输出、方法调用、循环、判断等)
结尾的“;”号可以不写，[建议不写]

代码块优点

代码块相当于另外一种形式的构造器(对构造器的补充机制)，可以作初始化的操作。

当构造器重载时，可以提取多个构造器重复执行的代码，放入代码块中。

简单案例

电影放映

public class CodeBlockTest02 {    public static void main(String[] args) {        new Movie();                System.out.println("----------------");        new Movie("唐人街探案3..");                System.out.println("---------------");        new Movie("我和我的祖国...", 80, "张艺谋");    }}class Movie {        private String name;    private double price;    private String director;        //代码块    {        System.out.println("电影开始播放广告...");        System.out.println("电影屏幕拉下来.");        System.out.println("电影播放.");    }        public Movie() {                    }    public Movie(String name) {            this.name = name;    }    public Movie(String name, double price, String director) {                        this.name = name;        this.price = price;        this.director = director;    }}

结果输出

代码块使用说明

static代码块又称静态代码块，静态代码块在类加载时就会执行且仅执行一次，和静态属性/静态方法相同。静态代码块的作用就是初始化类。
普通的代码块，每声明一个对象执行一次普通代码块，所以我们又可以将普通代码块看成构造器的一部分。
如果只使用类的静态成员，则不会执行普通代码块。因为只要不声明对象，普通代码块就不会执行。

什么时候类被加载：

创建对象时： Person p = new Person();
创建子类对象时，父类也会被加载：Student s = new Student(); (Student extends Person，Student和Person都会被加载)
使用类的静态成员(静态属性，静态方法)时：Student.totalFee; (private static double totalFee)

创建对象时，类的调用顺序

调用静态代码块和静态属性初始化(注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)
调用普通代码块和普通属性的初始化(注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)
调用构造方法。

构造方法(构造器) 的最前面其实隐含了 super()和调用普通代码块。

class Person{    public Person(){        super();        //调用普通代码块        System.out.println("Person");    }}

静态相关的代码块，属性初始化，在类加载时，就执行完毕, 因此是优先于构造器和普通代码块执行的。

静态代码块只能直接调用静态成员，普通代码块可以调用任意成员。(因为在静态代码块执行时，只有静态成员已经被加载了)

对象加载顺序案例

package codeBlock;public class Extends_blockTest {    public static void main(String[] args) {        new C();    }}class A{        private String name = nameA();    private static int age = ageA();        static {        System.out.println("A .... static Block");    }        {        System.out.println("A .... ordinary Block");    }        public String nameA() {        System.out.println("A .... ordinary Args");        return "AAA";    }        public static int ageA() {        System.out.println("A .... static Args");        return 18;    }    public A() {        System.out.println("A .... constructor");    }}class B extends A{        static {        System.out.println("B .... static Block");    }        private String name = nameB();    private static int age = ageB();        {        System.out.println("B .... ordinary Block");    }        public String nameB() {        System.out.println("B .... ordinary Args");        return "BBB";    }        public static int ageB() {        System.out.println("B .... static Args");        return 18;    }    public B() {        System.out.println("B .... constructor");    }}class C extends B{    private String name = nameC();    private static int age = ageC();        static {        System.out.println("C .... static Block");    }        {        System.out.println("C .... ordinary Block");    }        public String nameC() {        System.out.println("C .... ordinary Args");        return "CCC";    }        public static int ageC() {        System.out.println("C .... static Args");        return 18;    }    public C() {        System.out.println("C .... constructor");    }}

输出结果

A .... static Args

A .... static Block

B .... static Block

B .... static Args

C .... static Args

C .... static Block

A .... ordinary Args

A .... ordinary Block

A .... constructor

B .... ordinary Args

B .... ordinary Block

B .... constructor

C .... ordinary Args

C .... ordinary Block

C .... constructor

Java基础之：OOP——代码块