首页 > 试题广场 >

检查程序,是否存在问题,如果存在指出问题所在,如果不存在,说

[单选题]
检查程序,是否存在问题,如果存在指出问题所在,如果不存在,说明输出结果。
public class HelloB extends HelloA 
{
 public HelloB()
 {
 }
 {
     System.out.println("I’m B class");
 }
 static
 {
     System.out.println("static B");
 }
 public static void main(String[] args)
 {
     new HelloB();
 }
}
class HelloA
{
 public HelloA()
 {
 }
 {
     System.out.println("I’m A class");
 }
 static
 {
     System.out.println("static A");
 }
}

  • static A
    I’m A class
    static B
    I’m B class
  • I’m A class
    I’m B class
    static A
    static B
  • static A
    static B
    I’m A class
    I’m B class
  • I’m A class
    static A
    I’m B class
    static B
推荐
其中涉及:静态初始化代码块、构造代码块、构造方法
当涉及到继承时,按照如下顺序执行:
1、执行父类的静态代码块
static {
        System.out.println("static A");
    }
输出:static A
2、执行子类的静态代码块
static {
        System.out.println("static B");
    }
输出:static B
3、执行父类的构造代码块
{
        System.out.println("I’m A class");
    }
输出:I'm A class
4、执行父类的构造函数
public HelloA() {
    }
输出:无
5、执行子类的构造代码块
{
        System.out.println("I’m B class");
    }
输出:I'm B class
6、执行子类的构造函数
public HelloB() {
    }
输出:无

那么,最后的输出为:
static A
static B
I'm A class
I'm B class
正确答案:C
编辑于 2015-02-02 14:50:41 回复(20)
1.静态代码块 2.构造代码块3.构造方法的执行顺序是1>2>3;明白他们是干嘛的就理解了。
1.静态代码块:是在类的加载过程的第三步初始化的时候进行的,主要目的是给类变量赋予初始值。
2.构造代码块:是独立的,必须依附载体才能运行,Java会把构造代码块放到每种构造方法的前面,用于实例化一些共有的实例变量,减少代码量。
3.构造方法:用于实例化变量。
1是类级别的,2、3是实例级别的,自然1要优先23.
在就明白一点:对子类得主动使用会导致对其父类得主动使用,所以尽管实例化的是子类,但也会导致父类的初始化和实例化,且优于子类执行。
发表于 2015-08-10 16:29:50 回复(9)
Java程序初始化工作可以在许多不同的代码块中来完成,它们的执行顺序如下:
父类的静态变量、父类的静态代码块、子类的静态变量、子类的静态代码块、
父类的非静态变量、父类的非静态代码块、父类的构造函数
子类的非静态变量、子类的非静态代码块、子类的构造函数。
发表于 2015-09-16 15:52:54 回复(14)
只要记住,不论怎样,必定先执行静态代码,子由父生,所以父类必先执行,由此可以筛选出答案C
发表于 2015-07-27 23:03:34 回复(0)
子由父生,执行顺序为:
父类的静态代码块>子类的静态代码块>父类的构造代码块>父类的构造函数>子类的构造代码块>子类的构造函数
发表于 2016-05-27 15:16:01 回复(0)
静态块比构造方法先执行
发表于 2015-06-23 23:40:22 回复(0)
代码执行顺序:
1. 父类静态代码块、静态变量
2. 子类静态代码块、静态变量
3. 父类局部代码块、成员变量
4. 父类构造函数
5. 子类局部代码块、成员变量
6. 子类构造函数
发表于 2022-02-19 20:08:57 回复(3)
7c头像 7c
静态代码块,在类加载时运行,而构造代码块是在实例化对象时运行,调用时先加载父类的静态代码块,在执行构造函数.
发表于 2015-07-27 22:03:14 回复(1)
发表于 2016-01-08 09:29:00 回复(3)
先静态方法执行。当newHelloB();时,先执行父类的。
父类的类加载。加载的过程中执行父类的静态方法。
然后子类进行加载,执行子类的静态的方法。
然后new创建对象,时候。执行构造函数,先执行父类的构造函数,然后执行子类的构造函数。
发表于 2015-11-20 21:26:34 回复(1)
这题考察类初始化顺序:
1、静态块>非静态块>构造函数
2、 比较 同一初始化项目时,父类永远>子类,例如:父类静态块>子类静态块

总得来说顺序是这样:
父类静态块>子类静态块>父类非静态块>父类构造函数>子类非静态块>子类构造函数
发表于 2016-07-08 11:50:10 回复(0)
JVM类加载过程分为:加载 、链接 、初始化 、使用 、卸载 这五个阶段,其中链接阶段又包括: 验证 、 准备 、 解析 。 加载 :通过类的完全限定名,查找此类的二进制字节码文件,通过该字节码文件创建Class对象。 链接 :包含 验证 、 准备 、 解析 三个阶段: 验证 :确保Class文件复合虚拟机规定的Class文件格式,包含文件格式验证、元数据验证、字节码验证、引用符号验证。 准备 :为类的静态变量分配内存并设置初始化值,注:这里不包含final修饰的静态变量,因为final修饰的静态变量是在编译期分配。 解析 :将常量池的间接引用转换为直接引用,解析包含字段解析、接口解析、方法解析。 初始化 :初始化静态变量和静态块,先初始化父类,再初始化当前类,只有对类主动时才会初始化。 使用 :程序代码执行时使用,new出对象程序中使用。 卸载 :程序代码退出、异常、结束等,执行垃圾回收。
发表于 2023-01-03 18:38:34 回复(0)
代码块执行顺序:静态代码块>构造代码块>构造函数>普通代码块
                            创建子类对象时,先实例化父类,再实例化子类。
静态代码块:程序一加载就执行,且仅执行一次
构造代码块:只要涉及到该类就执行
普通代码块:其他代码块执行完成后才执行,不同类中按照规则顺序执行,同一个类中按照书写顺序执行
发表于 2022-02-16 16:43:18 回复(0)
java代码执行顺序:
父类静态方法->
子类静态方法->
父类构造代码块->
父类构造方法->
子类构造代码块->
子类构造方法
发表于 2020-10-17 15:13:36 回复(0)
规则:
(1)静态代码块在类加载时就会被执行;
(2)子类的构造方法中会默认加上调用父类构造器的方法super(),并且加在构造器代码的第一行;
(3)普通代码块的方***被编译进构造器,并加在super()的后面;
(4)调用类中的其他方***默认加上this。
根据规则1,先执行父类的静态方法,在执行子类的静态方法;根据规则3,先执行父类普通代码块,在执行子类普通代码块。

发表于 2019-09-10 17:40:22 回复(0)

类的加载顺序

(1) 父类静态代码块(包括静态初始化块,静态属性,但不包括静态方法)

(2) 子类静态代码块(包括静态初始化块,静态属性,但不包括静态方法 )

(3) 父类非静态代码块( 包括非静态初始化块,非静态属性 )

(4) 父类构造函数

(5) 子类非静态代码块 ( 包括非静态初始化块,非静态属性 )

(6) 子类构造函数

其中:类中静态块按照声明顺序执行,并且(1)和(2)不需要调用new类实例的时候就执行了(意思就是在类加载到方法区的时候执行的)

发表于 2018-08-16 14:19:44 回复(0)
初始化顺序:
1. 初始化父类中的静态成员变量和静态代码块 ;
2. 初始化子类中的静态成员变量和静态代码块 ;
3.初始化父类的普通成员变量和代码块,再执行父类的构造方法;
4.初始化子类的普通成员变量和代码块,再执行子类的构造方法;
发表于 2017-07-27 15:19:50 回复(0)
优先顺序:父类静态代码块,子类静态代码块,父类构造代码块,父类的构造函数,子类的构造代码块,子类的构造函数。
1.静态代码块:是在类的加载过程的第三步初始化的时候进行的,主要目的是给类变量赋予初始值。
2.构造代码块:是独立的,必须依附载体才能运行,Java会把构造代码块放到每种构造方法的前面,用于实例化一些共有的实例变量,减少代码量。
3.构造方法:用于实例化变量。
1是类级别的,2、3是实例级别的,自然1要优先23.
在就明白一点:对子类得主动使用会导致对其父类得主动使用,所以尽管实例化的是子类,但也会导致父类的初始化和实例化,且优于子类执行。
发表于 2017-04-22 19:54:42 回复(0)
初始化过程: 
1. 初始化父类中的静态成员变量和静态代码块 ; 
2. 初始化子类中的静态成员变量和静态代码块 ; 
3.初始化父类的普通成员变量和代码块,再执行父类的构造方法;
4.初始化子类的普通成员变量和代码块,再执行子类的构造方法;
发表于 2017-01-11 11:21:24 回复(0)
首先明确一下优先级:
静态代码块》普通构造代码块》构造函数

父级别》子级别

同一类级别的构造代码块和构造函数先后执行,不分开

那么执行顺序就很简单了:
执行父级别静态代码块

执行子级别静态代码块

执行父类的普通代码块+构造函数

执行子类的普通代码块+构造函数

由此得出结论
发表于 2016-12-04 08:11:57 回复(0)
初始化顺序为:父类静态代码块 > 子类静态代码块 
                      > 父类非静态代码块 > 父类构造函数 
                      > 子类非静态代码块 > 子类构造函数
发表于 2016-08-01 22:09:18 回复(0)