Java中静态变量的适用场景

Java类中的静态变量在程序运行期间，其内存空间对所有该类的对象实例而言是共享的，有些时候可以认为是全局变量。因此在某些时候为了节省系统内存开销、共享资源，可以将类中的一些变量声明为静态变量，通过下面的例子，你可以发现合理应用静态变量带来的好处：

 

Java代码

1. public class WeekA{   
2.   
3.        static class Data {    
4.   
5.              private int week;   
6.              private String name;   
7.              Data(int i, String s) {   
8.                    week= i;   
9.                    name = s;   
10.              }   
11.        }   
12.   
13.        Data weeks[] = {   
14.              new Data(1, "Monday"),   
15.              new Data(2, "Tuesay"),   
16.              new Data(3, "Wednesday"),   
17.              new Data(4, "Thursday"),   
18.              new Data(5, "Friday"),   
19.              new Data(6, "Saturday"),   
20.              new Data(7, "Sunday")   
21.        };   
22.   
23.        public static void main(String args[]) {   
24.   
25.              final int N = 10000;   
26.              WeekA weekinstance;   
27.              for (int i = 1; i <= N; i++){   
28.                    weekinstance = new WeekA ();   
29.              }   
30.   
31.        }   
32.   
33. }  

public class WeekA{

       static class Data { 

             private int week;
             private String name;
             Data(int i, String s) {
                   week= i;
                   name = s;
             }
       }

       Data weeks[] = {
             new Data(1, "Monday"),
             new Data(2, "Tuesay"),
             new Data(3, "Wednesday"),
             new Data(4, "Thursday"),
             new Data(5, "Friday"),
             new Data(6, "Saturday"),
             new Data(7, "Sunday")
       };

       public static void main(String args[]) {

             final int N = 10000;
             WeekA weekinstance;
             for (int i = 1; i <= N; i++){
                   weekinstance = new WeekA ();
             }

       }

}

 

在上面这段代码中，没有将Data weeks声明为静态变量，因此当创建WeekA对象时将会得到10 000个weeks对象的副本，这些对象被保存在内存中，但是weeks对象中的数据却从来没有被更改过，而且十分稳定。因此，如果能使所有对象共享该数据对象是个不错的解决办法，请看下面的代码：

Java代码

1. public class WeekB{   
2.   
3.       static class Data {    
4.   
5.              private int week;   
6.              private String name;   
7.              Data(int i, String s) {   
8.                    week= i;   
9.                    name = s;   
10.             }   
11.   
12.       }   
13.   
14.       static Data weeks[] = {   
15.              new Data(1, "Monday"),   
16.              new Data(2, "Tuesay"),   
17.              new Data(3, "Wednesday"),   
18.              new Data(4, "Thursday"),   
19.              new Data(5, "Friday"),   
20.              new Data(6, "Saturday"),   
21.              new Data(7, "Sunday")   
22.       };   
23.   
24.       public static void main(String args[]) {   
25.   
26.              final int N = 10000;   
27.              WeekB weekinstance;   
28.              for (int i = 1; i <= N; i++){   
29.                    weekinstance = new WeekB ();   
30.              }   
31.      }   
32.   
33. }      

public class WeekB{

      static class Data { 

             private int week;
             private String name;
             Data(int i, String s) {
                   week= i;
                   name = s;
            }

      }

      static Data weeks[] = {
             new Data(1, "Monday"),
             new Data(2, "Tuesay"),
             new Data(3, "Wednesday"),
             new Data(4, "Thursday"),
             new Data(5, "Friday"),
             new Data(6, "Saturday"),
             new Data(7, "Sunday")
      };

      public static void main(String args[]) {

             final int N = 10000;
             WeekB weekinstance;
             for (int i = 1; i <= N; i++){
                   weekinstance = new WeekB ();
             }
     }

}    

 请注意在类WeekB中，在Data weeks[]之前添加了static关键字，将该对象变量声明为静态的，因此当你创建10 000个WeekB对象时系统中只保存着该对象的一份拷贝，而且该类的所有对象实例共享这份拷贝，这无疑节约了大量的不必要的内存开销，同时实现了要完成的系统功能。

那么是不是我们应该尽量地多使用静态变量呢？其实不是这样的，因为静态变量生命周期较长，而且不易被系统回收，因此如果不能合理地使用静态变量，就会适得其反，造成大量的内存浪费，所谓过犹不及。因此，建议在具备下列全部条件的情况下，尽量使用静态变量：

（1）变量所包含的对象体积较大，占用内存较多。

（2）变量所包含的对象生命周期较长。

（3）变量所包含的对象数据稳定。

（4）该类的对象实例有对该变量所包含的对象的共享需求。

如果变量不具备上述特点建议你不要轻易地使用静态变量，以免弄巧成拙。

 

标签： 软件工程师  java培训  软件培训  Java培训班  软件编程  软件开发培训  软件工程师培训