java中static的用法

一、static的作用范围及用法

修饰类的成员：

1. 静态变量：某些特定的数据在内存中只有一份，而且能被一个类的所有实例对象共享。可以使用类名.变量名的形式来访问。当然也可以先实例化对象在用对象.变量名访问
   注意： static关键字只用于修饰 成员变量，不能用于修饰局部变量

class Student{
			static String schoolName;
}
public class Demo{
		public static void main(String[] args){
			Student.schoolName="SUST";//不创建对象就可以访问变量
			Student s1=new Student();//创建学生对象
			Student s2=new Student();
			System.out.println("我的学校:"+s1.schoolName);//两个对象可以共享静态变量
			System.out.println("我的学校:"+s2.schoolName);
			/*如果没有static修饰的变量，则应该给每一个对象都要进行赋值操作：
			s1.schoolName="SUST";
			s2.schoolName="SUST";
			System.out.println("我的学校:"+s1.schoolName);
			System.out.println("我的学校:"+s2.schoolName);
			*/
			}
}

2. 静态方法：可以在不创建对象的情况下调用某个方法，使方法和对象解绑。用类名.方法名（） 来调用方法
   注意： 静态方法中 只能访问用static 修饰的成员，因为非静态成员需要创建对象才能访问，但静态方法被调用时可以不创建对象，此时会矛盾。

class Person{
	public static void hello(){
		System.out.println("Hello");
	}
}
public class Demo{
	public static void main(String[] args){
		Person.hello();//直接用类名调用
		
		Person person=new Person();//也可以通过实例化对象调用
		person.hello();
	}
}

补充：静态方法也可以用实例名.方法名()被访问，只是在实现底层，仍然会被转为类名.方法名（）

实例.方法():

class Test {
    public static void hello() {
        System.out.println("hello");
    }
}

public class MyApplication {
    public static void main(String[] args) {
// TODO Auto-generated method stub
        Test test=null;
        test.hello();
    }

}

反编译后实际运行：

public class MyApplication {
    public MyApplication() {
    }

    public static void main(String[] args) {
        Test test = null;
        Test.hello();
    }
}

3. 静态代码块:当类被加载时，静态代码块会执行一次，因为一个类只加载一次，所以静态代码块只执行一次。通常使用静态代码块对类的成员变量进行初始化。
   注意： 在静态代码块中只能访问static修饰的成员

class Person{
	static String country;//静态变量
	static{//静态代码块
		country="China";//静态代码块中只能访问静态成员
		System.out.println("Person类中的静态代码块执行了");
}
public class Demo{
	static{
		System.out.println("测试类的静态代码块执行了");
	}
	public static void main(String[] args){
		Person p1=new Person();
		Person p2=new Person();
		}
}

代码运行结果：可以看出静态代码块是最先执行的，而且虽然创建了两个对象，但Person类的静态代码块只执行一次

补充：
在静态代码块中访问非static修饰的成员变量，编译器直接报错了

4.静态内部类：在类的内部定义一个类，用static修饰。可以在不创建外部类对象的情况下被实例化
创建静态内部类的语法格式:
外部类名.内部类名 变量名=new 外部类名.内部类名()

class Outer{
	private static int num=6;
	static class Inner{
		void show(){
			System.out.println("num="+num);
		}
	}
}
public class Demo{
	public static void main(String[] args){
		Outer.Inner inner=new Outer.Inner();//创建内部类对象
		inner.show();
	}
}

二、static关键字的应用—单例模式

单例模式是Java一种设计模式，要求在设计一个类时，保证在整个运行期间针对该类只存在一个实例对象。就像世界只有一个月亮一样。先看看示例代码：

class Single{
	private Single(){}//私有化构造方法
	private static Single INSTANCE=new Single();//创建一个对象
	public static Single getInstance(){//提供返回该对象的静态方法
	return INSTANCE;
	}
}
public class Demo{
	public static void main(String[] args){
		Single s1=Single.getInstance();//利用getInstance()方法获取实例对象
		Single s2=Single.getInstance();
		System.out.println(s1==s2);//结果是 true，表明引用同一对象。
		}
}
	

从上边代码可以看出单利模式的特点：
1.构造方法私有化private：这样就不能在类外部使用new来创建实例对象了
2.在类内部有实例化对象： 在类内部创建一个该类的实例对象，并用静态变量引用该对象（为了能在getIntence()方法中访问该变量），再加上private修饰，这样可以禁止外界直接访问变量
3.设有外部获取Single类实例对象的唯一方法： 为了让类外部能获得类的实例对象，定义静态方法getInstance()（可以通过类名.方法名来访问）

三、关于静态变量、静态方法、静态内部类使用的注意事项

1.static方法：方法体内可以调用其他静态方法，不能调用非静态方法；只可以访问方法外部的static变量；不能定义静态变量，可以定义非静态变量。
2.非static方法：方法体内部不能定义static变量；能调用static方法；能调用非static方法。
3.static关键字只能用于修饰成员变量，不能修饰局部变量（如形参、方法体内部变量）。
4.静态内部类中只能访问外部类的静态成员
5.静态内部类中可以定义静态成员，而非静态的内部类中不允许定义静态成员
从上面的几条注意事项可以看出，静态好像总是与非静态处于一种不包容的关系。其实这是因为在类加载时，静态属性也会开始加载，而非静态的属性只有在类加载完成后才开始初始化，开始实例对象。这就导致static可以直接用，而非static的还要先创建对象才能使用，如果二者混在一起，会产生矛盾。。