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。