一、 知识清单
类的成员之四：代码块（初始化块）
- 代码块的作用：用来初始化类、对象
- 代码块如果有修饰的话，只能使用static
- 分类：静态代码块 vs 非静态代码块
- 静态代码块
>内部可以有输出语句
>随着类的加载而执行，而且只执行一次
>作用初始化类的信息
>如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
>静态代码块的执行要优于非静态代码块的执行
>静态代码块内只能调用静态的属性、静态的方法、不能调用非静态的结构 - 非静态代码块
>内部可以有输出语句
>随着对象的创建而执行
> 每创建一个对象，就执行一次非静态代码块
>作用：可以在创建对象时，对对象的属性等进行初始化
>如果一个类中定义了多个非静态代码块、则按照声明的先后顺序执行
>非静态代码块内可以调用静态的属性、静态的方法、或非静态的属性、非静态的方法
静态代码块、非静态代码块、构造器执行的先后顺序：静态代码块(类加载时执行一次)>非静态代码块(每创建对象就执行一次)>构造器(每创建对象就执行一次)
二、静态代码块和构造代码块的不同点演示
1、静态代码块内只能调用静态的属性、静态的方法、不能调用非静态的结构；非静态代码块内可以调用静态的属性、静态的方法、或非静态的属性、非静态的方法。
class Person{
//这样写是错的方法体内可以
// int a;
// a=10;
//属性
String name;
int age;
static String desc="我是一个人";
//构造器
public Person(){
}
public Person(String name,int age){
this.name=name;
this.age=age;
}
//非static的代码块
{
System.out.println("hello,block-2");
}
{
System.out.println("hello,block-1");
//调用非静态结构
age=1;
eat();
//调用静态结构
desc="我是一个爱学习的人1";
info();
}
//static的代码块
static {
System.out.println("hello,static block-2");
}
static{
System.out.println("hello,static block-1");
//调用静态结构
desc="我是一个爱学习的人2";
info();
//不可以调用非静态结构
// eat();
// name="Tom";
}
public void eat(){
System.out.println("吃饭");
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
public static void info(){
System.out.println("我是一个快乐的人");
}
}
2、静态代码块随着类的加载而执行，而且只执行一次。非静态代码块每创建一个对象，就执行一次非静态代码块。看如下代码：
class Person{
//这样写是错的方法体内可以
// int a;
// a=10;
//属性
String name;
int age;
static String desc="我是一个人";
//构造器
public Person(){
}
public Person(String name,int age){
this.name=name;
this.age=age;
}
//非static的代码块
{
System.out.println("hello,block-2");
}
{
System.out.println("hello,block-1");
//调用非静态结构
age=1;
eat();
//调用静态结构
desc="我是一个爱学习的人1";
info();
}
//static的代码块
static {
System.out.println("hello,static block-2");
}
static{
System.out.println("hello,static block-1");
//调用静态结构
desc="我是一个爱学习的人2";
info();
//不可以调用非静态结构
// eat();
// name="Tom";
}
public void eat(){
System.out.println("吃饭");
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
public static void info(){
System.out.println("我是一个快乐的人");
}
}
创建一个类进行测试：
public class BlockTest extends Person {
public static void main(String[] args) {
String desc=Person.desc;
System.out.println(desc);
System.out.println("---------");
Person p1=new Person();
System.out.println("---------");
Person p2=new Person();
/*
* hello,static block-2
hello,static block-1
我是一个快乐的人
我是一个爱学习的人2
---------
hello,block-2
hello,block-1
吃饭
我是一个快乐的人
---------
hello,block-2
hello,block-1
吃饭
我是一个快乐的人
*/
}
}
从上面代码我们可以看到关于静态代码块、非静态代码块、构造器的执行顺序是：静态代码块（类加载时只执行一次）如果有多个静态代码块就会按照声明的先后顺序执行；非静态代码块在构造器执行之前调用，如果有多个非静态代码块则按照声明先后顺序执行，且每创建一个对象都会执行一次。所以执行的先后顺序是：静态代码块(类加载时执行一次)>非静态代码块(每创建对象就执行一次)>构造器(每创建对象就执行一次)
三、静态代码块、非静态代码块、构造器在有继承关系的类的执行顺序
示例一：
class Root{
static{
System.out.println("Root的静态初始化块");
}
{
System.out.println("Root的普通初始化块");
}
public Root(){
super();
System.out.println("Root的无参数的构造器");
}
}
class Mid extends Root{
static{
System.out.println("Mid的静态初始化块");
}
{
System.out.println("Mid的普通初始化块");
}
public Mid(){
super();
System.out.println("Mid的无参构造器");
}
public Mid(String msg){
//通过this调用同一类中重载的构造器
this();
System.out.println("Mid的带参数构造器，其参数值："+msg);
}
}
class Leaf extends Mid{
static{
System.out.println("Leaf的静态初始化块");
}
{
System.out.println("Leaf的普通初始化块");
}
public Leaf(){
//通过super调用父类中有一个字符串参数的构造器
super("刘瘦瘦");
System.out.println("Leaf的构造器");
}
}
public class LeafTest {
public static void main(String[] args) {
new Leaf();
/*
* 执行结果：
Root的静态初始化块
Mid的静态初始化块
Leaf的静态初始化块
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参构造器
Mid的带参数构造器，其参数值：刘瘦瘦
Leaf的普通初始化块
Leaf的构造器
*/
}
}
要想理解本部分请先看：类加载、调用构造器、执行方法的过程
说明：首先程序会加载LeafTest类，然后去调用LeafTest中的main方法，程序执行new Leaf();时会调用Leaf的空参构造器：
public Leaf(){
//通过super调用父类中有一个字符串参数的构造器
super("刘瘦瘦");
System.out.println("Leaf的构造器");
}
就会去加载Leaf类，当加载Leaf类时，发现Leaf类继承了Mid类，就去加载Mid（此时Leaf还没加载）类，加载Mid类时发现继承了Root类（此时Mid类还没加载呢），加载Root类又发现Root类继承了Object类（此时Root类还没加载呢），然后加载Object类，Object类加载完没有静态代码块中的输出，然后往回加载，加载Root类的静态代码块时会执行静态代码块
static{
System.out.println("Root的静态初始化块");
}
然后加载Mid类中的静态代码块：
static{
System.out.println("Mid的静态初始化块");
}
然后加载Leaf中的静态代码块
static{
System.out.println("Leaf的静态初始化块");
}
至此，类全部加载完成，开始执行构造器，执行Leaf构造器
public Leaf(){
//通过super调用父类中有一个字符串参数的构造器
super("刘瘦瘦");
System.out.println("Leaf的构造器");
}
中super(“刘瘦瘦”);又会调用父类Mid的带参构造器：
public Mid(String msg){
//通过this调用同一类中重载的构造器
this();
System.out.println("Mid的带参数构造器，其参数值："+msg);
}
执行this()又会调用Mid类重载的空参构造器：
public Mid(){
super();
System.out.println("Mid的无参构造器");
}
执行到super时又会调用Mid的父类Root的构造器
public Root(){
super();
System.out.println("Root的无参数的构造器");
}
执行到super时，又会调用Root的父类Object的构造器，Object构造器执行完毕（object的构造器时空参的，所以啥都不输出），开始往回走，执行Root的空参构造器的输出语句之前，会先调用非静态代码块中的输出语句其次是构造器中的输出语句：
public Root(){
super();
System.out.println("Root的无参数的构造器");
}
执行Mid空参构造器的输出语句时，也会先调用非静态代码块的输出语句，然后执行空参构造器中的输出语句，然后是带参构造器中的输出语句：
{
System.out.println("Mid的普通初始化块");
}
public Mid(){
super();
System.out.println("Mid的无参构造器");
}
public Mid(String msg){
//通过this调用同一类中重载的构造器
this();
System.out.println("Mid的带参数构造器，其参数值："+msg);
}
执行到Leaf构造器是也会先执行非静态代码块中的输出语句，在执行构造器中的输出语句。此时对象创建完成，程序结束。
以上的执行可以概况为一句话：“由父及子，静态先行”
示例二
class Father {
static {
System.out.println("11111111111");
}
{
System.out.println("22222222222");
}
public Father() {
System.out.println("33333333333");
}
}
public class Son extends Father {
static {
System.out.println("44444444444");
}
{
System.out.println("55555555555");
}
public Son() {
System.out.println("66666666666");
}
public static void main(String[] args) { // 由父及子 静态先行
System.out.println("77777777777");
// System.out.println("************************");
// new Son();
// System.out.println("************************");
// new Son();
// System.out.println("************************");
// new Father();
}
}
上述代码会输出什么？不会吧不会吧，你竟然说啥输出"777777777"？看下面的输出结果：
原因和上个示例代码一样的：我们知道main方法是程序执行的入口对吧，但main方法执行之前必须也得先加载这个类（不接受反驳），所以第一步会先加载Son类，加载Son类时发现Son继承自Father，然后加载Father（此时Son类还没加载呢），加载Father发现Father继承自Object，然后加载Object类，然后发现Object没有静态代码块的输出，然后往回走，加载Father类，发现Father中的静态代码块，我们知道静态代码块加载时都执行了：
static {
System.out.println("11111111111");
}
Father加载完毕，加载Son类输出Son中静态代码块的语句：
static {
System.out.println("44444444444");
}
然后程序入口main方法会执行，执行过输出语句.。
示例三
该实例就是把上面注释的给打开了
class Father {
static {
System.out.println("11111111111");
}
{
System.out.println("22222222222");
}
public Father() {
System.out.println("33333333333");
}
}
public class Son extends Father {
static {
System.out.println("44444444444");
}
{
System.out.println("55555555555");
}
public Son() {
System.out.println("66666666666");
}
public static void main(String[] args) { // 由父及子 静态先行
System.out.println("77777777777");
System.out.println("************************");
new Son();
System.out.println("************************");
new Son();
System.out.println("************************");
new Father();
}
}
输出：
这个自己分析把：提示一点呀，构造器的首行如果没有显示的调用本类重载的构造器，也没有显示的调用父类的带参的构造器，则默认可是调用了父类无参的空构造器。
231
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
