Java static修饰符

Java static修饰符

static修饰符是静态修饰符，大家写Java第一次接触static就是主函数中的pubic static void main的声明了。

那么static有什么用？本文来详细说说。

static成员与普通成员的区别

static表示全局或静态的意思，用来修饰类的成员变量和成员方法。

我们知道，程序中代码都是在编译的过程中由编译器自动分配的内存，而static类型就指其修饰的变量、方法在编译后就一直存在，直到程序结束才会释放内存。而我们知道Java是纯面向对象语言，万事万物都存在于类当中。 对于一个类而言，如果要使用它的成员变量、成员函数，普通情况下必须先实例化对象之后，通过对象的引用才能够访问这些成员。但是用static修饰的成员可以直接通过'.'访问标识符访问。

被static修饰的成员变量和成员方法独立于该类的任何对象，也就是说，static成员不依赖于特定的实例，而是被该类的所有对象共享，且不会被垃圾回收。

那么，只要这个类的代码被编译器编译了，static成员就可以直接通过类名访问（调用），无需引用任何对象。

static方法

静态方法可以直接通过类名访问，这也解释了为什么主函数是static方法了，因为我们不需要利用public类来实例化后才找到主函数入口。

1. 静态方法可以直接通过类名调用，任何对象也可以调用，因此静态方法中不存在this和super关键词；

2. 静态方法不可以访问所属类的实例变量和实例方法（非静态）！因为实例变量和方法都是与对象相关的，而静态方法是独立于对象的；

3. static方法必须被实现，不可以抽象。

4. 静态方法可以直接调用同类的其他的静态成员（包括变量和方法）

5. 虽然静态方法不可以调用非静态成员，但是对象可以调用静态方法。

class Student{
    // 静态方法
    static void print(){
        System.out.println("I am a student!");
    }
}

public class Test{
    public static void main(Sting[] args){
        Student.print();
    }
}

// output
// I am a student!

static变量

静态变量不依附于类，而是从编译结束到程序退出一直都存在，所以不会被回收。虽然Java中没有这个概念，但是我们可以看作static变量为一种全局变量。

1. 静态变量可以被构造器和实例方法调用
2. 静态变量属于整个类而不是某一个对象
3. 静态变量不会被回收

class Student{
    static int number = 0;  // 静态变量
    private int _num;  // 私有变量
    Student(){
        _num = ++number;
        System.out.println(_number);
    }
}

public class Test{
    public static void main(Sting[] args){
        Student a = new Student();
        Student b = new Student();
    }
}

/* output
	1
	2
*/

可以看见，static变量一直存在，而不会每创建一个对象就重新赋值为0。

static的修饰符

static也可以被修饰和再修饰。例如static final就是指一个不可以被更改的静态变量。

这里特别说一下private 和 public。

1. 被private static修饰的成员，仅仅可以被本类中的方法调用。
2. 被public static修饰的成员，可以看作全局方法（变量），可以被类名和外部创建的对象直接调用。

static 代码块

静态代码块很简单，就是一段不依赖于类和方法的代码。

static{
    // code here
}

• 静态代码块在类被加载的的时候运行且只运行一次。

• 静态代码块优先于主函数执行。静态代码块还是写在类中，由类调用。

• 静态代码块中的变量是局部变量，和普通方法中的变量没有区别

public class Test{
    public static void main(Sting[] args){
        System.out.println("Main Method Code");
    }

     static{
        System.out.prinln("Test Class Static Code");
    }
}

/*
Output

Test Class Static Code
Main Method Code

*/

可以看见，即使主函数写在static之前，也是会先执行static代码块内部的内容。

• 静态代码块没有继承这个说法，因为静态代码块运行且只运行一次，就是在类加载的时候

class Person{
	static {
		System.out.println("I am a person");
	}

	public Person() {
		System.out.println("Constructor");
	}
}

public class Test {
	public static void main(String[] args) {
		Person a = new Person();
		Person b = new Person();
		Person c = new Person();
	}
}

/*
output

I am a person
Constructor
Constructor
Constructor

*/

如上所见，对象创建了三个，构造方法调用了三遍，而静态代码块只调用了一遍。

所以可以看见，一个类被加载时，代码实现顺序是 静态代码块 > 构造方法 > 类方法

如果涉及到了继承，遵循静态优先执行，基类先于派生类的原则。

class Person{
	static {
		System.out.println("I am a Person");
	}

	public Person() {
		System.out.println("Base Constructor");
	}
}

public class Student extends Person{
	static {
		System.out.println("I am a Student");
	}

	public Student() {
		System.err.println("Derived Constructor");
	}
}

public class Test {
	public static void main(String[] args) {
		Student a = new Student();
	}
}

/*
output

Derived Constructor
I am a Person
I am a Student
Base Constructor

*/

可以看见，创建派生类对象时，先调用了基类静态代码块、基类构造方法然后调用派生类静态代码块、派生类构造方法。