求输出结果是为什么

[xiaozhuaizhuai]

class Singleton {
	private static Singleton s = new Singleton();
	public static int a;
	public static int b = 0;

	private Singleton() {
		a++;
		b++;
	}

	public static synchronized Singleton getInstance() {
		return s;
	}
}

public class Test {
	public static void main(String[] args) {
		Singleton s = Singleton.getInstance();
		System.out.println("Singleton.a=" + Singleton.a);
		System.out.println("Singleton.b=" + Singleton.b);
	}
}

[rumlee]

这个问题以前确实没有考虑过，学习了。

[lzbang]

Java 中变量和方法的初始化顺序

为了对java中各成员的初始化顺序，有全面的了解，写了这么一个小小的测试程序
class A0 {
A0() {
System.out.println("父类的构造函数被调用（初始化父类）");
}
}
class A1 extends A0 {
static final int b = print1();
static {
System.out.println("静态块被执行");
}
int a = print();
{
System.out.println("非静态块被执行");
}
A1() {
System.out.println("A1 的构造函数被调用");
}
private int print() {
System.out.println("A1中非静态变量被初始化");
return 1;
}
final static int print1() {
System.out.println("A1中静态变量被初始化");
return 1;
}
}
class A2 extends A1 {
A2() {
System.out.println("A2构造函数被调用");
}
}
public class DeriveDemo {
public static void main(String[] args) {
System.out.println("这是A1类的初始化顺序");
A1 a = new A1();
System.out.println("\n这是A2类的初始化顺序");
A2 a1 = new A2();
System.out.println("\n这是A2类的初始化顺序（注意静态变量）");
A2 a2 = new A2();
System.out.println("");
System.out.println("我们还注意到静态变量被A2全盘继承下来了");
}
} 运行结果为
这是A1类的初始化顺序
A1中静态变量被初始化
静态块被执行
父类的构造函数被调用（初始化父类）
A1中非静态变量被初始化
非静态块被执行
A1 的构造函数被调用
这是A2类的初始化顺序
父类的构造函数被调用（初始化父类）
A1中非静态变量被初始化
非静态块被执行
A1 的构造函数被调用
A2构造函数被调用
这是A2类的初始化顺序（注意静态变量）
父类的构造函数被调用（初始化父类）
A1中非静态变量被初始化
非静态块被执行
A1 的构造函数被调用
A2构造函数被调用
我们还注意到静态变量被A2全盘继承下来了

[IT农夫]

需出结果为：
Singleton.a=1
Singleton.b=0
执行顺序如下：private static Singleton s = new Singleton();被分为两步：
private static Singleton s;
执行public static int a; 给a付默认值0。
执行public static int b = 0;给b付值为0.
然后执行
s = new Singleton();
调用
private Singleton() {
a++;
b++;
}
这时候 a和b的值都为1.

再执行
public static int a; 不该变a的值。
再执行
public static int b = 0;b的值变为0.

[javaxiaobai]

[Quote=引用 7 楼 bloodcorbie 的回复:]
引用 6 楼 xiaojiezi 的回复:
程序首先执行构造方法语句new Singleton();此时a=1,b=1
之后 执行 public static int a;
public static int b = 0;
所以 最后a=1,b=0

呃..照这样说,岂不是会在a,b定义之前用到它们?会次会报错?
[/Quote]
private static Singleton s = new Singleton();
其实这一句分两步，private static Singletion s为第一步，此时a=0,b=0;new Singleton()为第二步，此时a=1,b=1;然后再public static int a;
public static int b = 0;

[IT农夫]

需出结果为：
Singleton.a=1
Singleton.b=0
更正：
执行顺序如下：private static Singleton s = new Singleton();被分为两步：
private static Singleton s;
执行public static int a; 不是给a付默认值,只收集变量信息，如果不是static，则会付初始值。
执行public static int b = 0;不是给b付值为0,只收集变量信息，如果不是static，则会付值。
然后执行
s = new Singleton();
调用
private Singleton() {
a++;
b++;
}
这时候 a和b的值都为1.

再执行
public static int a; 不该变a的值。
再执行
public static int b = 0;b的值变为0

[xjun15]

up

[ychao0417]

[Quote=引用 18 楼 lzbang 的回复:]
Java 中变量和方法的初始化顺序

为了对java中各成员的初始化顺序，有全面的了解，写了这么一个小小的测试程序
class A0 {
A0() {
System.out.println("父类的构造函数被调用（初始化父类）");
}
}
class A1 extends A0 {
static final int b = print1();
static {
System.out.println("静态块被执行");
}
int a = print();
{
System.out.pri…
[/Quote]

收藏了 谢谢

[wxzyydy]

约定俗成

[loaferwang]

[Quote=引用 11 楼 b271737818 的回复:]
程序先执行构造方法语句：
private Singleton() {
a++;
b++;
}
执行后a1,b=1；然后执行：
private static Singleton s = new Singleton();
public static int a;
public static int b = 0;
这样a是1，b又被置为0了。所以你输出的是1和0。其实在你不知道程序怎么走的时候，自己打断点看一下就很清楚了。
[/Quote]

我比较认同这位楼主的看法呀
就是要自己处理呀,MYEclipse IDE都可以Debug进行打段点的,进行调试的呀!

[huangan0301]

感觉3楼说的很有道理~~~~

[zhaoqiang415362381]

首先你的方法是私有的，，外部类不能访问，，那么你在定义静态变量时，，在后面就会输出静态定义值，，，当你在没赋初值时它掉用privite方法，，，所以就会加一次

[fanchangyong]

[Quote=引用 3 楼 dreamhunter_lan 的回复:]
因为static的执行按顺序执行
private static Singleton s = new Singleton();
完a=1,b=1
但后面又b=0所以b是0
[/Quote]

正解

[Jackliu8722]

我也长见识了,以前只是觉得如此,今天体会了

[fengheyi]

Thank you.
class initialization order.
very good

[zhoutao198712]

class Singleton {
    private static Singleton s = new Singleton();
    public static int a = printf("a");
    public static int b = printf("b");

    private static int printf(String str){
    	System.out.println(str);
    	return 0;
    }
    private Singleton() {
    	System.out.println("constructor");
        a++;
        b++;
    }

    public static synchronized Singleton getInstance() {
        return s;
    }
}

public class Test {
    public static void main(String[] args) {
        Singleton s = Singleton.getInstance();
        System.out.println("Singleton.a=" + Singleton.a);
        System.out.println("Singleton.b=" + Singleton.b);
    }
}

输出结果：
constructor
a
b
Singleton.a=0
Singleton.b=0
可以看出执行的次序。最先是singleton构造函数，接下来是static a 再b，之后是main方法中的输出

[jongsuny]

LZ运行一下这个就知道了..

package com.pattern;

class Singleton {
	//    private static Singleton s = new Singleton();

	public static int a;
    public static int b = 0;
    private static Singleton s = new Singleton();

    private Singleton() {
    	System.out.println("a= "+a+" b= "+b);
        a++;
        b++;
    	System.out.println("a= "+a+" b= "+b);

    }

    public static synchronized Singleton getInstance() {
        return s;
    }
}

public class Test {
    public static void main(String[] args) {
        Singleton s = Singleton.getInstance();
        System.out.println("Singleton.a=" + Singleton.a);
        System.out.println("Singleton.b=" + Singleton.b);
    }
}

[leiziaitudou]

public static int a;
public static int b = 0;
a,b好像都是静态的 怎么在private Singleton() {
a++;
b++;
}
要想调用a，b的值必须实例化。
所以就编译不过去

[JAMES胖熊]

先运行的是构造函数 所以a，b都是1了 然后b赋值为0了。

[hnqjc]

又开眼了...

[Girl_my_lover]

长见识了。。。