package test; 程序开发，操作系统，服务器，源码下载，Linux,Unix,BSD,PHP,Apach,asp,下载,源码,黑客,安全,技术社区,技术论坛7P2J:P#W+y1b
&] f(Y1{4@.p5a
public class TestStaticCon { tech.techweb.com.cn(W/Q4g:E,l/_2P
public static int a = 0; 6d1C%c _6p/N2q

)G-]$f)x'I3G;F"X(l{
5i:{$s8K*K-r程序开发，操作系统，服务器，源码下载，Linux,Unix,BSD,PHP,Apach,asp,下载,源码,黑客,安全,技术社区,技术论坛a = 10; TechWeb-技术社区2G:w2r6K'A)M"E*L.A.i4Y
System.out.println("父类的非静态代码块在执行a=" + a);
8G!d:s3L:F(\*s"a4X} tech.techweb.com.cn2?%L!P$R+L1r7q,D&@ I

;c:u"T'm4x,y!Ypublic TestStaticCon() {
.n$O,v M-].G1Y5?6Z,v!{2] J5j-K3K
this("a在父类带参构造方法中的值：" + a); // 调用另外一个构造方法
;H0A.|7s$^7HSystem.out.println(a); ;P$w!q5]5p3w*]5u
System.out.println("父类无参构造方法在执行a=" + a);
'V"_8z2Q:~9G9n5n*r7y} 程序开发，操作系统，服务器，源码下载，Linux,Unix,BSD,PHP,Apach,asp,下载,源码,黑客,安全,技术社区,技术论坛#L!j*I0q+j"Y*y$q5C

/T1l7i-s:Ftech.techweb.com.cnpublic TestStaticCon(String n) {
$l0E+x F'y:V2w,wtech.techweb.com.cnSystem.out.println(n);
*L5V"C:p8p [3d(O.]'e:v%Gtech.techweb.com.cn程序开发，操作系统，服务器，源码下载，Linux,Unix,BSD,PHP,Apach,asp,下载,源码,黑客,安全,技术社区,技术论坛%^-R;e#P;{-b l7n)w
} 4@.|:B&u-i&c-E$z3}

$k.t*R:q-j i7];Q7P6Stech.techweb.com.cnpublic static void main(String[] args) {
&@6| v-N)E%R)kTestStaticCon tsc = new TestStaticCon(); *B(i5u.F%D6Y
} 5M&d#L6@'c$a
} 程序开发，操作系统，服务器，源码下载，Linux,Unix,BSD,PHP,Apach,asp,下载,源码,黑客,安全,技术社区,技术论坛7T/y.~!x3@.I4A3s

,q$D7h(m+u"I6B6g结果： 7D%_0L:m2~8b
程序开发，操作系统，服务器，源码下载，Linux,Unix,BSD,PHP,Apach,asp,下载,源码,黑客,安全,技术社区,技术论坛1t%[3?'M$m)[
父类的非静态代码块在执行a=10 %A9y/m(q6R9m(L:H&w)d
a在父类带参构造方法中的值：0    （这个地方为什么是0  不是10 ？？？？？？？？？？？？？？？？） 3F/l6i0c7k
10
-l7L t$s$n程序开发，操作系统，服务器，源码下载，Linux,Unix,BSD,PHP,Apach,asp,下载,源码,黑客,安全,技术社区,技术论坛父类无参构造方法在执行a=10

public TestStaticCon() {

this("a在父类带参构造方法中的值：" + a); // 调用另外一个构造方法
System.out.println(a);
System.out.println("父类无参构造方法在执行a=" + a);
}

中变量a 是一个形式参数 所以 输出的时候是0

那你如何解释这个呢    肯定不是参数问题啊

Jedey 00:40:18
package test;

public class Sub {
public static int a = 0;
{
a = 10;// 10
System.out.println("父类的非静态代码块在执行。。。a=" + a);
}

static {
a = 20;//
System.out.println("父类的静态代码块在执行。。。a=" + a);
}

// 带参构造方法
public Sub(String n) {
System.out.println(n);
}

// 无参构造方法
public Sub() {
this("a在父类带参构造方法中的值：" + a); // 调用另外一个构造方法
System.out.println("父类无参构造方法在执行。。。a=" + a);
}

public void nonStaticMethod() {
a = 30;
System.out.println("父类的非静态方法在执行。。。a=" + a);
}

public static void staticMethod() {
a = 40;
System.out.println("父类的静态方法在执行。。。a=" + a);
}

public static void main(String[] args) {
// TODO Auto-generated method stub
Sub.staticMethod();
Sub.staticMethod();
System.out.println("声明对象前TestInitial.a：" + Sub.a);// 40
System.out.println("声明对象前TestInitial.a：" + Sub.a);// 40
Sub testA = new Sub();
Sub testB = new Sub();
System.out.println("对象testA.a：" + testA.a);// 10
System.out.println("对象testB.a：" + testB.a);// 10
System.out.println("声明对象后TestInitial.a：" + Sub.a);// 20
}
}

Jedey 00:40:47
结果：
父类的静态代码块在执行。。。a=20
父类的静态方法在执行。。。a=40
父类的静态方法在执行。。。a=40
声明对象前TestInitial.a：40
声明对象前TestInitial.a：40
父类的非静态代码块在执行。。。a=10
a在父类带参构造方法中的值：40
父类无参构造方法在执行。。。a=10
父类的非静态代码块在执行。。。a=10
a在父类带参构造方法中的值：10
父类无参构造方法在执行。。。a=10
对象testA.a：10
对象testB.a：10
声明对象后TestInitial.a：10

没有人能够回答吗  这到底怎么调用的啊

Java code
[Quote=引用楼主 hpjiang006 的帖子:]
package test;

public class TestStaticCon {
public static int a = 0;

//static
{
a = 10;
System.out.println("父类的非静态代码块在执行a=" + a); //4
}

public TestStaticCon() {

this("a在父类带参构造方法中的值：" + a); // 调用另外一个构造方法 2
System.out.println(a); //6
System.out.println("父类无参构造方法在执行a=" + a); //7
}

public TestStaticCon(String n) { //3
System.out.println(n); //5
}
public static void main(String[] args) {
TestStaticCon tsc = new TestStaticCon(); //1
}

[/Quote]





由于你没加static ,所以会从main先开始执行，去调用无参构造函数，然后调用有参构造函数，在执行第3步时，会去调用

Java code
{
a = 10;
System.out.println("父类的非静态代码块在执行a=" + a); //3
}



中的代码，但是我也不明白为什么这个时候调用这里面的代码，还有谁解释一下这种没有任何修饰写法用在什么情况下，起什么作用呀？？

只用过加static的静态初始化块，若是加上static,楼主就能得到想要的10了

楼主发的第二段代码，其实还是第一段代码的那个问题，就是调用无参构造，
然后调用有参构造，当有参构造接到传过来的参数时（String n 已经有值时），
就去调用了那段非静态初始化的代码，从而改变了a的值，但是String n 的
值此时却没有变。

谁能解释一下，为什么这个时候调用呀？？？
老紫竹在不？？

静态初始化块：使用关键字static定义的代码块。当类装载到系统时执行一次，静态初始化块只能初始化类的静态数据成员。

非静态初始化块：对每个要生成的对象执行一次。可以初始化静态数据成员以及实例数据成员。

一个类可以有多个初始化块，在同种类型情况下，它们将按照在程序中出现的顺序运行，但是有如下规则：

静态初始化块在非静态初始化块之前执行。

静态/非静态初始化块在构造函数之前执行。

当类创建一个对象了的初始顺序：
1．  父类静态成员和静态初始化块 ，按在代码中出现的顺序依次执行  
2．  子类静态成员和静态初始化块 ，按在代码中出现的顺序依次执行  
3．  父类实例成员和实例初始化块 ，按在代码中出现的顺序依次执行  
4．  父类构造方法  
5．  子类实例成员和实例初始化块 ，按在代码中出现的顺序依次执行  
6．  子类构造方法  

找了一下，是怪自己基功不扎实，自我检讨了。。。

希望楼主看完也明白了

关注~~~~~非静态代码块的执行顺序

首先声明一下:执行顺利为:静态代码块--非静态代码块(如果不执行构造函数,非静态代码块也不会执行)--构造函数
class TestStaticCon {
public static int a = 5;

{
a=10;
System.out.println("父类的非静态代码块在执行a=" + a);
}

public TestStaticCon() {
this(a); // 调用另外一个构造方法
System.out.println(a);
System.out.println("父类无参构造方法在执行a=" + a);
}

public TestStaticCon(int n) {
System.out.println("a在父类带参构造方法中的值：" +n);

}
public static void main(String[] args) {
TestStaticCon tsc = new TestStaticCon(TestStaticCon.a);
//先参数实例化.再执行非静态代码..再执行构造函数中的代码
}
}
结果为:
父类的非静态代码块在执行a=10
a在父类带参构造方法中的值：5

Java code
public class TestStaticCon {
public static int a = 0;


static {
a = 10;  //能改变a的值
System.out.println("父类的非静态代码块在执行a=" + a);
}

{
a = 10;  //不能改变a的值
System.out.println("父类的非静态代码块在执行a=" + a);
}


public TestStaticCon() {

this("a在父类带参构造方法中的值：" + a); // 调用另外一个构造方法
System.out.println(a);
System.out.println("父类无参构造方法在执行a=" + a);
}

public TestStaticCon(String n) {
System.out.println(n);

}

public static void main(String[] args) {
TestStaticCon tsc = new TestStaticCon();
}
}




刚跑了下，发现只有静态的代码快才能改变a的值……

如果不执行构造函数,非静态代码块也不会执行
估计于非静态代码快和构造函数的执行顺序有关。
其他其他答案……