自认为Java基础好的进来看看

Question

别用编译器，用脑子想想，下面代码打印出来的顺序应该是什么样的？public class Test2 extends Test1
{
    {
        System.out.print("1"); 
    }
 
    Test2()
    { 
        System.out.print("2"); 
    } 
    static
    {
        System.out.print("3"); 
    } 
    { 
        System.out.print("4"); 
    } 
    public static void main(String[] args)
    { 
        new Test2(); 
    } 
}

Answer 1

少了点东西，不好意思class Test1
{ 
    Test1()
    { 
        System.out.print("5");
    } 
    static
    {
        System.out.print("6");
    } 
}

Answer 2

3->1->4->2
静态优先，构造器最后

Answer 3

{ 
        System.out.print("4"); 
    }
这个编译不过去吧？

Answer 4

635142
父类静态->子类静态->父类构造->子类构造，　应该不是很难

Answer 5

我觉得不可能编译过去吧！public class Test2 extends Test1
{
    {
        System.out.print("1"); 
    }    //我想知道LZ这个可以编译过去吗，就红色的这算是什么啊？
     //如果可以编译过去的话，这是一个什么样的问题那
 
    Test2()
    { 
        System.out.print("2"); 
    } 
    static
    {
        System.out.print("3"); 
    } 
    { 
        System.out.print("4"); 
    } 
    public static void main(String[] args)
    { 
        new Test2(); 
    } 
}

Answer 6

为什么可以只有方法体，没有方法名！！（刚学java不久，看了这题，？号脑边乱飞）

Answer 7

SCJP经常有这种题目，考得就是基础。顶！

Answer 8

幸好不是问的Class.forName(XXX)与XXX.class的区别，那就有的玩了~

Answer 9

楼上的看看这个就全都明白了,先说名这个程序不是我写的，也是我在别人那看到的，如果本人看到了，请原谅，拿出来大家一起学习吗，呵呵
class Parent {   
    // 静态变量   
    public static String p_StaticField = "父类--静态变量";   
    // 变量   
    public String p_Field = "父类--变量";   
  
    // 静态初始化块   
    static {   
        System.out.println(p_StaticField);   
        System.out.println("父类--静态初始化块");   
    }   
  
    // 初始化块   
    {   
        System.out.println(p_Field);   
        System.out.println("父类--初始化块");   
    }   
  
    // 构造器   
    public Parent() {   
        System.out.println("父类--构造器");   
    }   
}   
  
public class SubClass extends Parent {   
    // 静态变量   
    public static String s_StaticField = "子类--静态变量";   
    // 变量   
    public String s_Field = "子类--变量";   
    // 静态初始化块   
    static {   
        System.out.println(s_StaticField);   
        System.out.println("子类--静态初始化块");   
    }   
    // 初始化块   
    {   
        System.out.println(s_Field);   
        System.out.println("子类--初始化块");   
    }   
  
    // 构造器   
    public SubClass() {   
        System.out.println("子类--构造器");   
    }   
  
    // 程序入口   
    public static void main(String[] args) {   
        new SubClass();   
    }   
}  
运行一下上面的代码，结果马上呈现在我们的眼前： 父类--静态变量 
父类--静态初始化块 
子类--静态变量 
子类--静态初始化块 
父类--变量 
父类--初始化块 
父类--构造器 
子类--变量 
子类--初始化块 
子类--构造器 

Answer 10

继承体系的类加载,static型的不管是static变量,还是static代码块都是属于类的.顺序嘛谁在前面先初始化谁. 
类加载完毕,才会开始准备生成继承体系的对象,从顶层类开始Object,非static变量,非static代码块,构造器的调用,一个父类的对象出来了，处于可用状态,马上开始下一级的对象的生成工作,一直到没有子类的那个类的对象生成出来. 
对象生成工作OVER!

Answer 11

无聊呀无聊
你怎么不问别人system.out.println（“a”）；
和import了system包以后
out.println（“a”）；哪个执行更快呢？

Answer 12

635142,1、static类型(先父类,后子类)
       2、游离块（先父类，后子类）
        3、构造函数（先父类，后子类）

Answer 13

635142 
父类静态->子类静态->父类构造->子类构造，　应该不是很难

Answer 14

6-》3-》5-》1->4->2原则：
1，先父类，后子类
2，先静态，后实例，最后构造函数