java中static关键字的用法

《Think in Java》中有关于static的解释：static方法就是没有this关键字的方法。在static方法的内部不能调用非静态方法，反过来倒是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。

为什么说static方法就是没有this关键字的方法？

因为this指的是当前对象，当类加载进内存时this所指对象还没产生，而static修饰 的内容一起被加载了。既然static加载时this所指对象不存在，那this就没有任何意义。

static关键字的用法：

1.声明static属性

如果希望一个属性被所有对象所 共同拥有，则将其声明为static类型，声明成static类型的属性和方法之后此属性、方法称之为类属性、类方法，可由类名称直接调用

class Person{
String name;
int age;
static String country = "北京";
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void print(){
System.out.println("城市："+country+" 姓名："+name+" 年龄："+age);
}
}
public class StaticDemo01{
public static void main(String[] args){
Person p1 = new Person("Jack",30);
Person p2 = new Person("Rose",25);
p1.print();
p2.print();
//通过p1修改static属性
System.out.println("----通过p1修改static country属性之后----");
p1.country = "哈尔滨";
p1.print();
p2.print();
}
}

输出结果:

城市：北京 姓名：Jack 年龄：30

城市：北京 姓名：Rose 年龄：25

----通过p1修改static country属性之后----

城市：哈尔滨 姓名：Jack 年龄：30

城市：哈尔滨 姓名：Rose 年龄：25

每个对象都拥有各自的堆栈空间，堆内存保存的各自的属性，但是所有的static属性是保存在全局数据区的，所有对象指向全局数据区的一个内容，所以当p1对象修改coutry之后，p2调用country也会发生变化。



但实际上一般是通过类名直接调用static属性，即采用“类名称.属性”，所以这里用  Person.country = "哈尔滨";   更合适
2.声明static方法
如果一个方法使用了static关键字声明，则此方法 可以直接使用类名称调用。

class Person{
String name;
int age;
private static String country = "北京";//对country属性进行封装
public static void setCountry(String c){
country = c;
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void print(){
System.out.println("城市："+country+" 姓名："+name+" 年龄："+age);
}
}
public class StaticDemo02{
public static void main(String[] args){
Person p1 = new Person("Jack",30);
Person p2 = new Person("Rose",25);
p1.print();
p2.print();
System.out.println("----通过调用static方法修改之后----");
Person.setCountry("哈尔滨");
p1.print();
p2.print();
}
}

特别注意的是：使用static方法，不能调用非static属性和方法，因为static方法或属性可以在对象还没实例化时就可以调用了。所以要想在不创建对象的情况下调用某个方法，就可以将这个方法设为static。这里也就能说明为什么main()方法为什么是static的了，因为在执行main()时没有 创建任何对象。

3.声明static代码块
静态代码块：直接使用static关键字声明的代码块就是静态代码块

class Demo{
{//构造块
System.out.println("构造块");
}
static{//在普通类中声明静态代码块
System.out.println("静态代码块");
}
public Demo(){
System.out.println("构造方法");
}
}
public class StaticDemo03{
static{
System.out.println("在主方法所在类中声明的静态代码块");
}
public static void main(String[] args){
new Demo();
new Demo();
new Demo();
}
}

输出结果：
在主方法所在类中声明的静态代码块

静态代码块

构造块

构造方法

构造块

构造方法

构造块

构造方法
可见，主方法所在类中静态代码块优先于主方法执行，普通类中静态代码块优先于构造块执行，构造块优先于构造方法执行，并且无论实例化多少对象，静态代码块只执行一次构造块会执行多次。静态代码块的主要功能就是静态属性初始化。
4.声明static内部类
要想在其他类中访问内部类，此时可以使用static声明此内部类
我们看一下下面两段程序的区别：
程序一：

class Outer{
private String info = "hello world";
class Inner{
public void print(){
System.out.println(info);//内部类获取外部类私有属性
}
}
public void fun(){
new Inner().print();//实例化内部类对象，并调用内部类方法
}
}
public class StaticDemo04{
public static void main(String[] args){
new Outer().fun();//实例化外部类对象，调用外部类的fun()方法
}
}

程序二：

class Outer{
private String info = "hello world";
class Inner{
public void print(){
System.out.println(info);//内部类获取外部类私有属性
}
}
}
public class StaticDemo04{
public static void main(String[] args){
new Outer.Inner().print();
}
}

程序一正确，程序二错误。程序二要想通过其他类访问内部类的方法必须用static声明内部类才行，即：

class Outer{
private static String info = "hello world";
static class Inner{
public void print(){
System.out.println(info);//内部类获取外部类私有属性
}
}
}
public class StaticDemo04{
public static void main(String[] args){
new Outer.Inner().print();
}
}

可以这样理解，如果一个内部类使用static关键字声明，则此内部类可以看成一个外部类，或者看成一个独立的类，可以直接通过外部类.内部类进行访问，但是如果要想访问外部类的属性，则此属性也必须声明成static。