代码化块又称为初始化块,属于类中的成员[即是类的一部分]，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。
但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。
注意:
1)修饰符可选，要写的话，也只能写static
2)代码块分为两类，使用static 修饰的叫静态代码块，没有static修饰的，叫普通代码块。
3)逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断等)
4);号可以写上，也可以省略。
理解:
1)相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作
2)场景:如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性
package com.hspedu.codeblock;
public class CodeBlock01 {
public static void main(String[] args) {
Movie movie01 = new Movie("复仇者联盟");
}
}
class Movie {
private String name;
private double price;
private String director;
// 代码快调用的顺序，优先于构造器
{
System.out.println("广告开始。。。");
System.out.println("广告结束。。。");
}
public Movie(String name) {
this.name = name;
}
public Movie(String name, double price) {
this.name = name;
this.price = price;
}
public Movie(String name, double price, String director) {
this.name = name;
this.price = price;
this.director = director;
}
}
细节
- static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。 如果是普通代码块，每创建一 个对象，就执行。
- 类什么时候被加载
①创建对象实例时(new)
②创建子类对象实例，父类也会被加载
③使用类的静态成员时(静态属性，静态方法)
- 普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用次。 如果只是使用类的静态成员时，普通代码块并不会执行。
小结:
1.static代码块是类加载时， 执行，只会执行一次
2.普通代码块是在创建对象时调用的，创建一次，调用一次
3.类加载的3种情况，需要记住
package com.hspedu.codeblock;
public class Detail01 {
public static void main(String[] args) {
// new AA();
// new BB();
System.out.println(Cat.n1);
}
}
class AA {
static {
System.out.println("AA的静态代码块");
}
}
class BB extends AA {
static {
System.out.println("BB的静态代码块");
}
}
class Cat {
public static int n1 = 999;
static {
System.out.println("Cat的静态代码块");
}
}
- 创建一个对象时，在一个类调用顺序是:(重点，难点)
①调用静态代码块和静态属性初始化(注意:静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)
package com.hspedu.codeblock;
public class Detail02 {
public static void main(String[] args) {
A a = new A();
}
}
class A {
private static int n1 = getN1();
static {
System.out.println("A的静态代码块");
}
public static int getN1() {
System.out.println("A的getN1");
return 100;
}
}
输出
A的getN1 A的静态代码块
②调用普通代码块和普通属性的初始化(注意:普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)
③调用构造方法。
5 构造器的最前面其实隐含了super(和调用普通代码块，静态相关的代码块，属性初始化，在类加载时，就执行完毕,因此是优先于构造器和普通代码块执行的。
package com.hspedu.codeblock;
public class Detail03 {
public static void main(String[] args) {
new BBB();
}
}
class AAA {
{
System.out.println("AAA的代码块");
}
public AAA() {
System.out.println("AAA的构造器");
}
}
class BBB extends AAA {
{
System.out.println("BBB的代码块");
}
public BBB() {
// 隐藏了 suoer()
System.out.println("BBB的构造器");
}
}
输出
AAA的代码块 AAA的构造器 BBB的代码块 BBB的构造器
- 我们看一下创建一个子类对象时(继承关系)，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下:
①父类的静态代码块和静态属性(优先级一样，按定义顺序执行)
②子类的静态代码块和静态属性(优先级一样，按定义顺序执行)
③父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
④父类的构造方法
⑤子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
⑥子类的构造方法
package com.hspedu.codeblock;
public class Detail04 {
public static void main(String[] args) {
new BBBB();
}
}
class AAAA {
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 AAAA() {// 构造器
// 隐藏
// super()
// 普通代码和普通属性的初始化......
System.out.println("A02 的构造器");//(7)
}
}
class BBBB extends AAAA {
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 BBBB() {// 构造器
// 隐藏了
// super()
// 普通代码块和普通属性的初始化...
System.out.println("B02 的构造器");//(10)
}
}
输出
getVal01 A02 的一个静态代码块.. getVal03 B02 的一个静态代码块.. A02 的第一个普通代码块.. getVal02 A02 的构造器 getVal04 B02 的第一个普通代码块.. B02 的构造器
- 静态代码块只能直接调用静态成员(静态属性和静态方法)，普通代码块可以调用任意成员。
