static关键字的使用

静态变量

在程序中如果用static声明变量的话，则此变量称为静态变量。那么什么是静态变量？使用静态变量又有什么好处呢？读者先来看一下下面的范例：

范例：TestStaticDemo1.java
01 class Person
02 {
03      String name ;
04      String city ;
05      int age ;
06      public Person(String name, String city, int age)
07     {
08         this.name = name ;
09         this.city = city ;
10         this.age = age ;
11      }
12      public String talk()
13     {
14        return "我是："+this.name+"，今年："+this.age+"岁，来自："+this.city; 
15     }
16 }
17 public class TestStaticDemo1
18 {
19      public static void main(String[] args)
20     {
21         Person p1 = new Person("张三",25,"中国") ;
22         Person p2 = new Person("李四",30,"中国") ;
23         Person p3 = new Person("王五",35,"中国") ;
24         System.out.println(p1.talk()) ;
25         System.out.println(p2.talk()) ;
26         System.out.println(p3.talk()) ;
27     }
28 }

输出结果：
我是：张三，今年：25岁，来自：中国
我是：李四，今年：30岁，来自：中国
我是：王五，今年：35岁，来自：中国

程序说明：
1、程序1~16行声明一个名为Person的类，含有三个属性：name、age、city。
2、程序6~11行声明Person类的一个构造方法，此构造方法分别为各属性赋值。
3、程序12~15行声明一talk()方法，此方法用于返回用户信息。
4、程序21~23行分别实例化三个Person对象。
5、程序24~26行分别调用类中的talk()方法，输出用户信息。
由上面的程序可以发现，所有的Person对象都有一个city属性，而且所有的属性也全部相同。

读者可以试着想一想，现在假设程序产生了50个Person对象，如果想修改所有人的city属性的话，是不是就要调用50遍city属性，进行重新修改，显然太麻烦了。所以在java中提供了static关键字，用它来修饰类的属性后，则此属性就是公共属性了。将TestStaticDemo1.java程序稍作修改就形成了范例TestStaticDemo2.java，如下所示：

范例：TestStaticDemo2.java
01 class Person
02 {
03     String name ;
04     static String city = "中国";
05     int age ;
06     public Person(String name,int age)
07    {
08         this.name = name ;
09         this.age = age ;
10     }
11     public String talk()
12     {
13         return "我是："+this.name+"，今年："+this.age+"岁，来自："+city;
14     }
15 }
16 public class TestStaticDemo2
17 {
18     public static void main(String[] args)
19     {
20         Person p1 = new Person("张三",25) ;
21         Person p2 = new Person("李四",30) ;
22         Person p3 = new Person("王五",35) ;
23        System.out.println("修改之前信息："+p1.talk()) ;
24        System.out.println("修改之前信息："+p2.talk()) ;
25        System.out.println("修改之前信息："+p3.talk()) ;
26        System.out.println(" ************* 修改之后信息 **************");
27        // 修改后的信息
28        p1.city = "美国" ;
29        System.out.println("修改之后信息："+p1.talk()) ;
30        System.out.println("修改之后信息："+p2.talk()) ;
31        System.out.println("修改之后信息："+p3.talk()) ;
32     }
33 }

输出结果：
修改之前信息:我是：张三，今年：25岁，来自：中国
修改之前信息:我是：李四，今年：30岁，来自：中国
修改之前信息:我是：王五，今年：35岁，来自：中国
************* 修改之后信息 **************
修改之后信息:我是：张三，今年：25岁，来自：美国
修改之后信息:我是：李四，今年：30岁，来自：美国
修改之后信息:我是：王五，今年：35岁，来自：美国

程序说明：
1、程序1~15行声明一个名为Person的类，含有三个属性：name、age、city。其中city为static类型。

2、程序6~10行声明Person类的一个构造方法，此构造方法作用是分别为name、age属性赋值。
3、程序11~14行声明一talk()方法，此方法用于返回用户信息。
4、程序20~22行分别实例化三个Person对象。
5、程序23~25行分别调用类中的talk()方法，输出用户信息。
6、程序28行修改了p1中的city属性。
从上面的程序中可以发现，程序只在第28行修改了city属性，而且只修改了一个对象的city属性，但再次输出时，发现全部的对象的city值都发生了一样的变化，这就说明了用static声明的属性是所有对象共享的。

，所有的对象都指向同一个city属性，只要当中有一个对象修改了city属性的内容，则所有对象都会被同时修改。
另外，读者也需要注意一点，用static方式声明的属性，也可以用类名直接访问，拿上面的程序来说，如果想修改city属性中的内容，可以用如下方式：
Person.city = “美国” ;
所以有些书上也把用static类型声明的变量，称之为“类变量” 。
静态方法

static既可以在声明变量时使用，也可以用其来声明方法，用它声明的方法有时也被称为“类方法”，请看下面的范例：

范例：TestStaticDemo4.java
01 class Person
02 {
03      String name ;
04      private static String city = "中国";
05      int age ;
06      public Person(String name,int age)
07     {
08         this.name = name ;
09         this.age = age ;
10      }
11      public String talk()
12     {
13         return "我是："+this.name+"，今年："+this.age+"岁，来自："+city;
14     }
15      public static void setCity(String c)
16     {
17         city = c ;
18     }
19 }
20 public class TestStaticDemo4
21 {
22      public static void main(String[] args)
23     {
24         Person p1 = new Person("张三",25) ;
25         Person p2 = new Person("李四",30) ;
26         Person p3 = new Person("王五",35) ;
27         System.out.println("修改之前信息："+p1.talk()) ;
28         System.out.println("修改之前信息："+p2.talk()) ;
29         System.out.println("修改之前信息："+p3.talk()) ;
30         System.out.println(" **************修改之后信息**************");
31        // 修改后的信息
32        Person.setCity("美国") ;
33       System.out.println("修改之后信息："+p1.talk()) ;
34       System.out.println("修改之后信息："+p2.talk()) ;
35       System.out.println("修改之后信息："+p3.talk()) ;
36     }
37 }

输出结果：
修改之前信息：我是：张三，今年：25岁，来自：中国
修改之前信息：我是：李四，今年：30岁，来自：中国
修改之前信息：我是：王五，今年：35岁，来自：中国
**************修改之后信息**************
修改之后信息：我是：张三，今年：25岁，来自：美国
修改之后信息：我是：李四，今年：30岁，来自：美国
修改之后信息：我是：王五，今年：35岁，来自：美国

程序说明：
1、程序1~19行声明一个名为Person的类，类中含有一个static类型的变量city，并对此对象进行了封装。
2、 15~18行声明一个static类型的方法，此方法也可以用类名直接调用，用于修改city属性的内容。
3、程序第32行由Person调用setCity()方法，对city的内容进行修改。
注意：
在使用static类型声明的方法时需要注意的是：如果在类中声明了一static类型的属性，则此属性既可以在非static类型的方法中使用，也可以在static类型的方法中使用。但用static类型的属性调用非static类型的属性时，则会出现错误。

public class PersonStatic
{
     String name = "张三" ;
     static String city = "中国";
     int age ;
     public PersonStatic(String name,int age)
    {
          this.name = name ;
          this.age = age ;
     }
     public static void print()
    {
         System.out.println(name);
    }
    public String talk()
   {
        return "我是："+this.name+"，今年："+this.age+"岁，来自："+city;
    }
}

编译结果：
PersonStatic.java:13: non-static variable name cannot be referenced from a static context
System.out.println(name);
^
1 error
可以发现，程序中print()方法是static类型的，而name属性是非static类型的，所以print在调用非static类型的name属性时就出现了错误。