阿里面试题:
class HelloA {
//构造方法
public HelloA(){
System.out.println("1.Hello A!父类构造方法");
}
//非静态代码块
{
System.out.println("2.i'm A class.父类非静态代码块");
}
//静态代码块
static{
System.out.println("3.static A 父类静态代码块");
}
}
public class HelloB extends HelloA {
//构造方法
public HelloB(){
System.out.println("4.Hello B! 构造方法");
}
//非静态代码块
{
System.out.println("5.i'm B class.非静态代码块");
}
//静态代码块
static{
System.out.println("6.static B 静态代码块");
}
public static void main(String[] args) {
System.out.println("7.---start---");
new HelloB();
new HelloB();
System.out.println("8.---end---");
}
}
问:请写出上述代码的输出。
解析:
先从main方法入口,
类加载时,要用到HelloB这个类就加载它的静态类,然后又发现HelloB这个类继承自HelloA,所以先加载HelloA的静态块,在加载HelloB的静态块,
继续往下走,输出“—start—”这条语句,
再然后看见new关键字,new了HelloB的对象,
HelloB中有构造块和构造方法,但是HelloB继承自HelloA,
HelloA中也有构造快和构造方法,所以先输出HelloA中的构造块,再输出HelloA的构造方法,再输出HelloB的构造块,再输出HelloB的构造方法,
因为new了两次,所以继续再按顺序输出一次A和B中的构造块和构造方法。
最后输出“—end—”语句。
运行结果如下:
3.static A 父类静态代码块
6.static B 静态代码块
7.---start---
2.i'm A class.父类非静态代码块
1.Hello A!父类构造方法
5.i'm B class.非静态代码块
4.Hello B! 构造方法
2.i'm A class.父类非静态代码块
1.Hello A!父类构造方法
5.i'm B class.非静态代码块
4.Hello B! 构造方法
8.---end---
分析是按自己思路来的,可能有些绕,不过我们熟悉概念后,再结合代码去看,就会很容易的理解代码块的用法及概念。
代码块
代码块定义:使用 { } 定义的一段代码。
根据代码块定义的位置以及关键字,又可分为以下四种:
- 普通代码块
- 构造快
- 静态块
- 同步代码块
1.普通代码块
出现在方法中的代码块,解决变量重命名的问题。代码块一定要写在方法变量命名前。
范例:观察普通代码块
public class Test{
public static void main(String[] args) {
{ //直接使用{}定义,普通方法块
int x = 10 ;
System.out.println("x = " +x);
}
int x = 100 ;
System.out.println("x = " +x);
}
}
2.构造块
定义在类中代码块,不加任何修饰符。
优先于类中的构造方法执行,并且有多少对象产生,就调用多少次构造块。
范例:
class Person{
{ //定义在类中,不加任何修饰符,构造块
System.out.println("1.Person类的构造块");
}
public Person(){
System.out.println("2.Person类的构造方法");
}
}
public class Test{
public static void main(String[] args) {
new Person();
new Person();
}
}
运行结果:
1.Person类的构造块
2.Person类的构造方法
1.Person类的构造块
2.Person类的构造方法
通过上述代码我们可以发现:构造块优先于构造方法执行,每产生一个新的对象就调用一次构造块,构造块可以进行简单的逻辑操作(在调用构造方法前)
3.静态代码块
定义在类中的代码块,并且使用static修饰的代码块。
根据静态块所在的类的不同又可分为以下两种类型
- 在非主类中
- 在主类中
3.1在非主类中的静态块(和对象无关)
优先于构造块执行,无论有多少对象产生,静态块只执行一次(在类加载时执行:加载到JVM中,要用到这个类,就加载)。
范例:观察非主类中的静态块
class Person{
{ //定义在类中,不加任何修饰符,构造块
System.out.println("1.Person类的构造块");
}
public Person(){
System.out.println("2.Person类的构造方法");
}
static { //定义在非主类中的静态块
System.out.println("3.Person类的静态块");
}
}
public class Test{
public static void main(String[] args) {
System.out.println("--start--");
new Person();
new Person();
System.out.println("--end--");
}
}
运行结果:
--start--
3.Person类的静态块
1.Person类的构造块
2.Person类的构造方法
1.Person类的构造块
2.Person类的构造方法
--end--
通过以上代码我们可以发现:
- 静态块优先于构造块执行。
- 无论产生多少实例化对象,静态块都只执行一次。
静态块的主要作用是为static属性进行初始化
3.2在主类中的静态块
在主类中的静态块优先于主方法执行。
范例:定义在主类中的代码块
public class Test{
{
System.out.println("1.Test的构造块");
}
public Test(){
System.out.println("2.Test的构造方法");
}
static{
System.out.println("3.Test的静态块");
}
public static void main(String[] args) {
System.out.println("--start--");
new Test();
new Test();
System.out.println("--end--");
}
}
运行结果:
3.Test的静态块
--start--
1.Test的构造块
2.Test的构造方法
1.Test的构造块
2.Test的构造方法
--end--
通过上述代码我们可以发现:在主类中定义的静态块,优先于主方法(main)执行。