Java｜static关键字的使用详解
文章目录
- static关键字
-
- 类属性
- 静态方法
- 静态代码块
static关键字
static 表示静态，共有的含义
static可修饰的内容：
1.修饰属性，类属性，类变量
2.修饰方法，类方法。工具方法
3.static修饰代码块，静态代码块
4.static修饰内部类，静态内部类
今天主要讲前三种，static修饰内部类，后续会在讲到内部类的时候单独解释
类属性
static修饰的属性称为类属性，类变量，所有对象共享
代码示例：
class Person{
//成员变量或者说实例变量必须通过该类的对象来访问
String name;
int age;
String sex;
String country;
//成员方法，也是必须通过对象来访问
void show(){
System.out.println("name = " + name + ", age = " + age + ", country = " + country);
}
}
为什么要使用static关键字修饰属性？
country是成员变量，所有对象都在堆中保存有自己的country属性
有可能所有对象的这个值都是同一个值，比如中国人的所有对象的country = “中国”
假设有一天，中国光复了日本，那么对日本来说，所有对象的country属性值都要改成China
对country来说，有很多对象的属性值都是一样的，因此可以设置成共享，于是使用static修饰这个属性，该属性就称为静态属性
当一个成员属性/实例变量被static关键字修饰，他就表示类的属性，该类的所有对象共享这个属性，所有对象的属性值大家都一样
被static修饰的属性在JVM方法区中存储，所有该类对象共享此属性，也就是说该类的所有对象都只是使用了这个属性的值而已
被static修饰后的属性，可以直接通过类名称就可以访问，无需通过对象访问，不过通过对象也可以访问
Person.country = China;
内存图：
想调用new Person()来产生Person对象，得先要有Person类才能产生对象
因此创建对象的时候：
首先将Person类加载到内存中，Person中的所有static变量就会被加载到方法区中
static修饰的属性是全局唯一的，所有对象共享的，修改一个对象的属性值，就相当于把所有对象的属性值都该改变了
public static void main(String[] args) {
Person per1 = new Person();
Person per2 = new Person();
per1.name = "hello";
per1.age = 18;
per2.name = "hi";
per2.age = 20;
per1.show();//执行结果 name = hello, age = 18, country = Japan
per2.show();//执行结果 name = hi, age = 20, country = Japan
per2.country = "China";
per1.show();//执行结果 name = hello, age = 18, country = China
per2.show();//执行结果 name = hi, age = 20, country = China
}
class Person{
String name;
int age;
static String country = "Japan";
void show(){
System.out.println("name = " + name + ", age = " + age + ", country = " + country);
}
}
前面我们提到类属性保存在方法区中，那么方法区里还有什么呢？
方法区内存储的内容：
类中的所有方法的信息都存储在方法区，当方法被调用的时候，就被压入栈帧
所有常量、静态变量都存储在方法区中
能否在方法中定义一个static变量
public static void main(String[] args) { static int a = 10;//编译报错 }
一定不能在方法中定义static静态变量
方法中定义的变量全是局部变量，局部变量都在栈中存储，方法调用结束后，所有变量都是要销毁的，因此不可能定义出一个即在栈中又在方法区中的属性
final和static有什么区别？
class Person{
final int age = 18;//成员常量，都在堆中存储
static String country = "China";//静态变量，在方法区中存储
}
内存图：
类中定义的final修饰的是成员常量，这些成员常量存储在堆中，这和前面提到的方法区中存有常量似乎有一些矛盾。
但实际上，方法区中存储的常量指的是字面量，比如18这个数字，而final修饰的成员常量依然是存储在堆中
成员常量在定义的时候就要初始化
final int age;//error
final int age = 18;
若在类中定义了一个常量，我们通常情况下都会把static和final共同使用，称为类的常量
原因如下：
比如上述代码中的age这个属性是成员常量,在类定义的时候就被赋值为18，Person的所有对象都有age属性，且属性值均为18，而同一个值没必要重复存储多次，何不定义成静态变量，让所有对象共享，这样就只在内存中存储了1次
final关键字这就像是个给我们的天然的共享概念，因此为避免在每个对象中都存储一次，导致空间的浪费，可以直接定义为静态常量，使得所有对象都能共享这个属性，全局唯一
综上所述：在类中定义常量，一般会使用全局常量，由static final共同修饰
常量的命名规则：
所有单词全部大写，多个单词使用下划线分隔
static final String STUDENT_SCHOOL = "清华大学";
能否通过null引用访问static变量？笔试题常考！
Person per = null;
System.out.println(per.country);
//编译通过
static属性称为类属性，通过类名称即可直接访问，也就是说，没有对象也能调用，包括该类的null引用
per是Person类型的引用，哪怕是per没有存任何东西，也能通过Person类访问到类属性
这么理解：
创建引用类型变量per的时候，就已经和Person类建立了一种关系，即Person是变量per的类型，通过对象访问类属性的时候，实际上是通过per的类型Person去访问到类属性的，因此程序访问类属性的时候不会去在意引用类型变量里存的是不是null，而是直接根据per的类型去访问类属性
实际上这个案例就说明了，静态属性和对象无关
static、final总结：
static变量称为类属性，在方法区中存储，该类的所有对象共享此变量
若在类中定义了常量，一般我们使用static和final共同修饰，全局常量
要使用类属性，我们通常直接通过类名称.属性名称定义，不推荐使用对象来调用类属性，不规范
类属性可以通过类名称直接访问，包含该类的null引用
静态方法
static修饰方法 - 类方法/工具方法/静态方法
static修饰的方法同样也是通过类名称直接访问，没有对象也能访问
思考几个问题
public static void main(String[] args) {}
- 为什么Java中主方法是个静态方法？
主方法是一个程序的入口，如果主方法是个成员方法，得通过对象调用，创建对象又需要一个入口来创建，而现在连入口都没有，更何谈产生对象
程序从主方法开始执行，主方法要能调用起来，需要静态方法来直接调用，而无需产生对象
- 静态方法能否访问成员属性和成员方法？
从static的语义来看，静态方法是静态的，无需产生对象就能调用的方法，或者说静态方法是没有对象的
成员域（即成员方法和成员变量）必须通过对象来调用，而静态方法没有对象或者说没有通过对象调用方法，必然无法直接访问成员变量和方法
- 成员方法能否访问静态变量和静态方法？
静态变量和方法在没有对象的情况下就能访问，不在乎有没有对象
代码示例：
public class Test {
public static void main(String[] args) {
Person.fun();
}
}
class Person{
String name;
int age;
static String country = "China";
void show(){
System.out.print("调用非静态方法：");
System.out.println("name = " + name + ", age = " + age + ", country = " + country);
}
static void fun(){
System.out.println("调用静态方法");
show();//error
System.out.println(Person.country);//编译通过
}
}
为什么在静态方法中调用非静态方法会出错
其实这个问题和静态方法中访问成员属性类似，fun是静态方法，调用时没有通过对象来引用，想要在静态方法内部执行的成员方法，需要通过对象调用，所以这里不能被调用，编译报错
相反，如果是static属性，可以在static修饰的方法中调用，因为都属于静态域，不需要对象就能访问
根据上面的内容，可以总结出：
在静态方法中只能调用静态方法或者静态属性，static家族之间可以相互调用。不能直接调用成员方法和成员属性，必须通过对象来调用
在成员方法中既可以调用成员方法，也可以调用静态方法（此时都已经产生了该类对象，一定能够访问静态域）
什么时候设置static变量、方法
共享的变量如country属性，我们设计为静态变量
而工具类的方法一般设计为static方法，比如
Array.sort(int [])
普通类能否使用static关键字修饰
类定义出来是为了产生对象的，然后通过对象调用类里面定义的内容
假设static能修饰一个类，那么这个类甚至不需要创建对象就能调用了
“类本身”这种东西是不会保存在内存里的。他的作用就是告诉编译器怎么样生成代码，编译完了就没用了。就像其他简单的类型int或结构体，也是一样的
既然内存中都不存在“类”，那么用static去定义类是完全没有意义的
静态代码块
静态代码块是指定义在类中，使用static修饰的代码块，在类加载的时候执行一次，只会执行一次
代码示例：
public class Test {
public static void main(String[] args) {
Animal animal1 = new Animal("dog");
Animal animal2 = new Animal();
}
}
class Animal{
String name;
{
name = "test";
System.out.println("2.Animal的构造块");
}
public Animal(){
System.out.println("1.Animal的无参构造");
}
public Animal(String name){
this.name = name;
System.out.println("1.Animal的有参构造");
}
static{
System.out.println("3.Animal的静态代码块");
}
}
//执行结果 32121
3.Animal的静态代码块
2.Animal的构造块
1.Animal的有参构造
2.Animal的构造块
1.Animal的无参构造
静态代码块在类加载时执行一次，于对象无关，无论产生多少对象，都只执行一次，并且静态代码块在加载内存的时候就执行了，相比构造块、构造方法都要快
如果是定义在主类中的静态代码块，其执行顺序甚至要比main主方法更早
主类中的静态方法：
public class Test {
static {
System.out.println("主类中的静态代码块");
}
public static void main(String[] args) {
System.out.println("进入主方法");
}
}
//执行结果
主类中的静态代码块
进入主方法
结论：
主类中的静态块优先于主方法执行，JVM要执行主方法，首先得加载主类，主类一加载， 静态块就执行了
如果类中定义了静态属性和静态代码块：
public class Test {
public static void main(String[] args) {
System.out.println(Animal.age);
}
}
class Animal{
String name;
static int age = 10;
static{
age = 100;
System.out.println("3.Animal的静态代码块");
}
}
//执行结果
3.Animal的静态代码块
100
静态属性存在于方法区中，类定义的时候就会有初始值，初始值为10，这个类就被放入方法区，此时这个类只是定义了，还没有加载
当主方法中使用了Animal，也就是当程序读取到Animal的时候，就需要把Animal类从方法区加载内存，类在加载时，静态代码块就执行了，于是age就被静态代码块里的100给覆盖了
在主方法执行之前， 类就已经定义好了，其中的类属性也已经被定义，只有当类被调用的时候，类才会加载到内存中，于是类中的静态代码块在加载的过程中执行了，当加载结束后，再依次执行成员代码块和构造方法（如果有的话）