谁能解释一下static的用法和静态代码块的用法  还有参数的传递的用法 最好带例子  谢谢

1. 1.     静态方法
   
2. 通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法
   
3.    声明为static的方法有以下几条限制：
   
4. · 它们仅能调用其他的static 方法。
   
5. · 它们只能访问static数据。
   
6. · 它们不能以任何方式引用this 或super。
   
7. class Simple {
   
8.     static void go() {
   
9.        System.out.println("Welcome");
   
10.     }
    
11. }
    
12. 
    
13. public class Cal {
    
14.     public static void main(String[] args) {
    
15.        Simple.go();
    
16.     }
    
17. }
    
18.     调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。
    
19. 
    
20. 2. 静态变量
    
21. 声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了
    
22. class Value {
    
23.     static int c = 0;
    
24. 
    
25.     static void inc() {
    
26.        c++;
    
27.     }
    
28. }
    
29. 
    
30. public class Count2 {
    
31.     public static void prt(String s) {
    
32.        System.out.print(s);
    
33.     }
    
34. 
    
35.     public static void main(String[] args) {
    
36.        Value v1, v2;
    
37.        v1 = new Value();
    
38.        v2 = new Value();
    
39.        prt("v1.c=" + v1.c + "  v2.c=" + v2.c);
    
40.        v1.inc();
    
41.        prt(" v1.c=" + v1.c + "  v2.c=" + v2.c);
    
42.     }
    
43. }
    
44. 结果为：v1.c=0  v2.c=0 v1.c=1  v2.c=1
    
45. 由此可以证明它们共享一块存储区。static变量有点类似于C中的全局变量的概念。
    
46. 
    
47. 值得探讨的是静态变量的初始化问题。
    
48.        如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块：
    
49. class Value3 {
    
50.     static int c = 0;
    
51. 
    
52.     Value3() {
    
53.        c = 15;
    
54.     }
    
55. 
    
56.     Value3(int i) {
    
57.        c = i;
    
58.     }
    
59. 
    
60.     static void inc() {
    
61.        c++;
    
62.     }
    
63. }
    
64. 
    
65. public class Count {
    
66.     public static void prt(String s) {
    
67.        System.out.println(s);
    
68.     }
    
69. 
    
70.     Value3 v = new Value3(10);
    
71.     static Value3 v1, v2;
    
72.     static {//此即为static块
    
73.        prt("v1.c=" + v1.c + "  v2.c=" + v2.c);
    
74.        v1 = new Value3(27);
    
75.        prt("v1.c=" + v1.c + "  v2.c=" + v2.c);
    
76.        v2 = new Value3(15);
    
77.        prt("v1.c=" + v1.c + "  v2.c=" + v2.c);
    
78.     }
    
79. 
    
80.     public static void main(String[] args) {
    
81.        Count ct = new Count();
    
82.        prt("ct.c=" + ct.v.c);
    
83.        prt("v1.c=" + v1.c + "  v2.c=" + v2.c);
    
84.        v1.inc();
    
85.        prt("v1.c=" + v1.c + "  v2.c=" + v2.c);
    
86.        prt("ct.c=" + ct.v.c);
    
87.     }
    
88. }
    
89. 
    
90.    结果为：v1.c=0  v2.c=0
    
91. v1.c=27  v2.c=27
    
92. v1.c=15  v2.c=15
    
93. ct.c=10
    
94. v1.c=10  v2.c=10
    
95. v1.c=11  v2.c=11
    
96. ct.c=11
    
97.           这个程序展示了静态初始化的各种特性。如果你初次接触Java，结果可能令你吃惊。可能会对static后加大括号感到困惑。首先要告诉你的是，static定义的变量会优先于任何其它非static变量，不论其出现的顺序如何。正如在程序中所表现的，虽然v出现在v1和v2的前面，但是结果却是v1和v2的初始化在v的前面。在static{后面跟着一段代码，这是用来进行显式的静态变量初始化，这段代码只会初始化一次，且在类被第一次装载时。如果你能读懂并理解这段代码，会帮助你对static关键字的认识。在涉及到继承的时候，会先初始化父类的static变量，然后是子类的，依次类推。
    
98. 
    
99. 3．静态类
    
100.          通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。
     
101. public class StaticCls {
     
102.     public static void main(String[] args) {
     
103.        OuterCls.InnerCls oi = new OuterCls.InnerCls();
     
104.     }
     
105. }
     
106. 
     
107. class OuterCls {
     
108.     public static class InnerCls {
     
109.        InnerCls() {
     
110.            System.out.println("InnerCls");
     
111.        }
     
112.     }
     
113. }
     
114.     结果为：InnerCls

复制代码

static的用法:用来修饰成员的修饰符,使该成员随着类的加载而加载,生命周期和类一样.可以直接用:类名.成员属性(或成员函数)    进行调用.
静态代码块的用法:用来对类进行初始化,调用类的时候静态代码块最先执行.
以下代码体现了static和静态代码块的用法.

1. class testStatic
   
2. {
   
3.         public static void main(String[] args)
   
4.         {        /*这里是为了体现出static代码块的运行优先级.结果为:
   
5.                 静态代码块
   
6.                 构造代码块
   
7.                 构造函数*/
   
8.                 test a = new test();
   
9. 
   
10.                 //static属性的类名调用
    
11.                 System.out.println(test.name);
    
12. 
    
13.                 //static函数的类名调用
    
14.                 test.print();
    
15. 
    
16.         }
    
17. }
    
18. 
    
19. class test
    
20. {
    
21.         static String name = "静态属性";
    
22.         static{
    
23.                 System.out.println("静态代码块");
    
24.         }
    
25.         test(){
    
26.                 System.out.println("构造函数");
    
27.         }
    
28.         {
    
29.                 System.out.println("构造代码块");
    
30.         }
    
31.         public static void print()
    
32.         {
    
33.                 System.out.println("静态方法");
    
34.         }
    
35. }

复制代码

static 关键字既可以修饰变量，也可以修饰方法。被 static 修饰的变量（方法）只会在内存中保存一份，不同变量间共享这份数据，这样做得好处是可以节省内存空间。例如下面的代码：

1.   class Person
   
2.   {
   
3.       String              name;
   
4.       static String       country = "CN";
   
5.   
   
6.       public static void show()
   
7.       {
   
8.           System.out.println(country);
   
9.       }
   
10.   }

复制代码

上面的代码定义了一个类，对于该类的每一个对象，其 country 变量（[url=]第4行[/url]）的值都是“CN”，所有的对象共享一份 country 数据。

被 static 关键字修饰的变量（方法）除了可以被对象调用外，还可以直接通过类名调用，例如：

1. System.out.println(Person.country);
   
2. Persion.show();

复制代码

在类中，被 static 修饰的变量成为类变量，没有被 static 修饰的变量称为实例变量。这两种变量有以下几点区别：

• 存放位置不同。实例变量存放在堆内存中。
• 生命周期不同。在类加载以后，类变量就存在于内存中。而实例变量只有在对象创   建后在存在，即类变量的生命周期长于实例变量。
  

使用 static 的注意事项：1. 静态方法只能访问静态成员（包括静态方法和静态变量）。

1. class Person
   
2.      {
   
3.          String              name;
   
4.          static String       country = "CN";
   
5.      
   
6.          public static void show()
   
7.          {
   
8.              System.out.println(name + country); (ref:illegal)
   
9.          }
   
10.      }

复制代码

[url=]第8行[/url]错误，因为 name 是实例变量，不能被静态方法调用。因为静态方   法先于实例变量而存在。


2. 静态方法中不可以引用 this, super 关键字。因为 this, super 是对对   象的引用。