类中的static与创建对象的关系

看代码

 

1. class StaticTest1 {
2.     static int i = 47;
3. }
5. class Incrementable1 {
6.     static void increment() {
7.         StaticTest1.i++;
8.     }
9. }
11. public class OneStaticTest {
12.     @SuppressWarnings("static-access")
13.     public static void main(String[] args) {
14.         System.out.println("StaticTest1.i= " + StaticTest1.i);
15.         StaticTest1 st1 = new StaticTest1();
16.         StaticTest1 st2 = new StaticTest1();
17.         System.out.println("st1.i= " + st1.i);
18.         System.out.println("st2.i= " + st2.i);
19.         Incrementable1.increment();
20.         System.out.println("After Incrementable.increment() called: ");
21.         System.out.println("st1.i = " + st1.i);
22.         System.out.println("st2.i = " + st2.i);
23.         Incrementable1.increment();
24.         System.out.println("After Incrementable.increment called: ");
25.         System.out.println("st1.i = " + st1.i);
26.         System.out.println("st2.i = " + st2.i);
27.         st1.i = 3;
28.         System.out.println("After st1.i = 3, ");
29.         System.out.println("st1.i = " + st1.i);
30.         System.out.println("st2.i = " + st2.i);
31.         System.out.println("Create another StaticTest, st3.");
32.         /*
33.          * 一个static字段对每个类来说只有一份存储空间
34.          * 非static字段则是对每个对象有一个存储空间
35.          */
36.         StaticTest1 st3 = new StaticTest1();
37.         System.out.println("st3.i = " + st3.i);
38.     }
39. }

 

输出结果：

1. StaticTest1.i= 47
2. st1.i= 47
3. st2.i= 47
4. After Incrementable.increment() called: 
5. st1.i = 48
6. st2.i = 48
7. After Incrementable.increment called: 
8. st1.i = 49
9. st2.i = 49
10. After st1.i = 3, 
11. st1.i = 3
12. st2.i = 3
13. Create another StaticTest, st3.
14. st3.i = 3

 

由上边可以看出，当用static创建了一个静态域之后，它只和类有关系，即static域只有一个实例，与创建了多少个对象无关。

 

再看下边代码：

1. class Cup {
2.     Cup(int marker) {
3.         print("Cup(" + marker + ")");
4.     }
6.     void f(int marker) {
7.         print("f(" + marker + ")");
8.     }
9. }
11. class Cups {
12.     static Cup cup1;
13.     static Cup cup2;
14.     static {
15.         cup1 = new Cup(1);
16.         cup2 = new Cup(2);
17.     }
19.     Cups() {
20.         print("Cups()");
21.     }
22. }
24. public class ExplicitStatic {
25.     public static void main(String[] args) {
26.         print("Inside main()");
27.         Cups.cup1.f(99); // (1)
28.     }
29.     //先执行静态构造块，再执行构造函数。而且构造块只执行一次。
30.     static Cups cups1 = new Cups(); // (2)
31.     static Cups cups2 = new Cups(); // (2)
32. }

 

输出：

Cup(1)
Cup(2)
Cups()
Cups()
Inside main()
f(99)