JAVA 代码块
代码块
1.基本介绍
代码化块又称为初始化块,属于类中的成员[即是类的一部分]，类似于方法,将逻辑语句封装在方法体中,通过{}包围起来。
- 但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时,或创建对象时隐式调用。
基本语法
[修饰符]{
代码
};
说明注意：
- 修饰符可选，要写的话，只能写static
- 代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块
- 逻辑语句可以为任意逻辑语句(输入，输出，方法调用，循环，判断等)
- ;号可以写上，也可以省略
2.应用场景
- 相当于构造器的一个补充机制，可以做初始化的操作
- 且他的优先级，要比构造器要高
- 故如果构造器中有重复的语句，可以抽取到初始化代码块中，提高代码的复用性
package com.hspedu.codeblock;
public class CodeBlock01 {
public static void main(String[] args) {
Movie movie = new Movie("疯狂的石头");
Movie movie1 = new Movie("唐人街探", 66.6, "小龙");
}
}
class Movie{
private String name;
private double price;
private String director;//导演
{
System.out.println("电影屏幕打开...");
System.out.println("广告开始...");
System.out.println("电影正式开始...");
}
//构造器
//下面的三个构造器都有想用的语句，
//1.这时可以将相同的语句放入到一个代码块中即可
//2.当我们调用这个构造器时，都会调用代码块的内容
//3.代码块的顺序优先于构造器..
public Movie(String name) {
/* System.out.println("电影屏幕打开...");
System.out.println("广告开始...");
System.out.println("电影正式开始...");*/
this.name = name;
System.out.println("Movie(String name)构造器被调用~");
}
public Movie(String name, double price) {
/* System.out.println("电影屏幕打开...");
System.out.println("广告开始...");
System.out.println("电影正式开始...");*/
this.name = name;
this.price = price;
System.out.println("Movie(String name, double price)");
}
public Movie(String name, double price, String director) {
/* System.out.println("电影屏幕打开...");
System.out.println("广告开始...");
System.out.println("电影正式开始...");*/
this.name = name;
this.price = price;
this.director = director;
}
}
3.使用注意事项和细节讨论
-
static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。因为类只会加载一次
- 如果是普通代码块，只有在创建一个对象，才执行。
- 没创建一次就执行一次和类加载了没有什么关系
- 如果是普通代码块，只有在创建一个对象，才执行。
-
类什么时候被加载[重要背!]
- 创建对象实例时(new)
- 创建子类对象实例时，父类也会被加载，且父类先被加载，子类后被加载
- 使用类的静态成员时(静态属性，静态方法)，
小结：
- static代码块是类加载时，执行，只会执行一次
- 普通代码块是在创建对象时调用的，创建一次调用一次
- 类加载3中情况需要记住
package com.hspedu.codeblock;
public class CodeBlockDetail01 {
public static void main(String[] args) {
//1.创建对象实例时(new),
//AA aa = new AA();
//2.创建子类对象实例时，父类也会被加载，
// 且父类先被加载，子类后被加载
BB bb = new BB();
System.out.println("========");
System.out.println("Cat num1=" + Cat.num1);
System.out.println("========");
//static的代码块只会执行一次,static代码块在类加载的时候执行的
DD dd = new DD();
DD dd1 = new DD();
//如果使用类的静态成员时，普通代码块是不会被执行的
System.out.println(DD.n1);
}
}
class DD{
public static int n1 = 100;//静态属性
static {
System.out.println("DD的静态代码块被执行~~");
}
//普通代码块创建的时候才执行
{
System.out.println("DD的普通代码块被执行~~");
}
}
class AA{
private String name = "小龙";
private static int age = 21;
//静态代码块
// 1.static的代码块只会执行一次
// 2.普通代码块，new一个对象执行一次
static {
System.out.println("AA的静态代码块被执行~~");
}
public AA(String name) {
this.name = name;
}
public AA() {
}
}
class BB extends AA{
//静态代码块
static {
System.out.println("BB的静态代码块被执行~~ ");
}
}
class Animal{
static{
System.out.println("Animal的静态代码块被执行~~ ");
}
}
class Cat extends Animal{
public static int num1 = 10;
static{
System.out.println("Cat的静态代码被执行~~");
}
}
-
创建一个对象时，在一个类的调用顺序是：(重点，难点)
- 调用静态代码块和静态属性初始化时注意：他们的优先级是一样的，根据定义的顺序来进行调用
- 调用普通代码块和普通属性的初始化： 他们的优先级是一样的，根据定义的顺序来进行调用
- 最后才调用构造器
-
构造器的最前面其实隐含了super()和调用普通代码块
package com.hspedu.codeblock;
public class CodeBlockDetail03 {
public static void main(String[] args) {
new BBB();
//输出
//（1）AAA 的普通代码块~~
//（2）AAA 构造器被调用~~
//（3）BBB 的普通代码块被调用~~
//（4）BBB() 构造器被调用~~
}
}
class AAA {
{
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() 构造器被调用~~");
}
}
-
我们看一下创建一个子类对象时(继承关系)，他们的静态代码块，静念属性礼始化，普通代码块,普通属性初始化，构造方法的调用顺序如下:
①父类的静态代码块和静态属性(优先级一样,按定义顺序执行)
②子类的静态代码块和静态属性(优先级一样,按定义顺序执行)
③父类的普通代码块和普通属性初始化(优先级一样,按定义顺序执行)
④父类的构造方法
⑤子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
⑥子类的构造方法/面试题
-
静态代码块只能直接调用静态成员(静态属性和静态方法)，普通代码块可以调用任意成员
