【Java修饰符】（1）static修饰符详解

太过爱你忘了你带给我的痛 2022-07-13 13:14 215阅读 0赞

# **static 表示静态，它可以修饰属性，方法和代码块。** #

**1.static修饰属性（类变量），**那么这个属性就可以用类名.属性名来访问，也就是使这个属性成为本类的类变量，为本类对象所共有。这个属性就是全类公有。（共有的类变量与对象无关，只和类有关）。

类加载的过程，类本身也是保存在文件中（字节码文件保存着类的信息）的，java会通过I/O流把类的文件（字节码文件）读入JVM（java虚拟机），这个过程成为类的加载。JVM（java虚拟机）会通过类路径（CLASSPATH）来找字节码文件。

类变量，会在加载时自动初始化，初始化规则和实例变量相同。

**注意：**类中的实例变量是在创建对象时被初始化的，被static修饰的属性，也就是类变量，是在类加载时被创建并进行初始化，类加载的过程是进行一次。也就是类变量只会被创建一次。

**2.static修饰方法（静态方法），**会使这个方法成为整个类所公有的方法，可以用类名.方法名访问。

**注意：**static修饰的方法，不直接能访问本类中的非静态(static)成员（包括方法和属性），本类的非静态（static）方法可以访问本类的静态成员（包括方法和属性），可以调用静态方法。静态方法要慎重使用。在静态方法中不能出现this关键字。

**注意：**父类中是静态方法，子类中不能覆盖为非静态方法，在符合覆盖规则的前提下，在父子类中，父类中的静态方法可以被子类中的静态方法覆盖，但是没有多态。（在使用对象调用静态方法是其实是调用编译时类型的静态方法）

**注意：**父子类中，静态方法只能被静态方法覆盖，父子类中，非静态方法只能被非静态方法覆盖。

java中的main方法必须写成static的因为，在类加载时无法创建对象，因为静态方法可以不通过对象调用所以在类的main方法。所在在类加载时就可以通过main方法入口来运行程序。

**3.static修饰初始代码块，**这时这个初始代码块就叫做静态初始代码块，这个代码块只在类加载时被执行一次。可以用静态初始代码块初始化一个类。

动态初始代码块，写在类体中的“\{\}”，这个代码块是在生成对象的初始化属性是运行。这种代码块叫动态初始代码块。

类在什么时候会被加载，创建对象时会加载类，调用类中静态方法或访问静态属性也是会加载类的。在加载子类时必会先加载父类，类加载会有延迟加载原则，只有在必须加载时才会加载。

# [Java类的初始化顺序 （静态变量、静态初始化块、变量、初始...][Java_ _...] #

很有意思的一篇文章

1.没有继承

静态变量->静态初始化块->变量->变量初始化块->构造方法

2.有继承的情况

父类静态变量->父类静态初始化块->子类静态变量->子类静态变量初始化块->父类变量初始化->父类变量初始化块->父类构造方法->子类变量初始化->子类变量初始化块->子类构造方法

\--------------------------------------------------我是copy分割线---------------------------------------------------------

大家在去参加面试的时候，经常会遇到这样的考题：给你两个类的代码，它们之间是继承的关系，每个类里只有构造器方法和一些变量，构造器里可能还有一段代码对变量值进行了某种运算，另外还有一些将变量值输出到控制台的代码，然后让我们判断输出的结果。这实际上是在考查我们对于继承情况下类的初始化顺序的了解。   
  
我们大家都知道，对于静态变量、静态初始化块、变量、初始化块、构造器，它们的初始化顺序以此是（静态变量、静态初始化块）>（变量、初始化块）>构造器。我们也可以通过下面的测试代码来验证这一点：   
Java代码   
public class InitialOrderTest \{   
  
// 静态变量   
public static String staticField = "静态变量";   
// 变量   
public String field = "变量";   
  
// 静态初始化块   
static \{   
System.out.println(staticField);   
System.out.println("静态初始化块");   
\}   
  
// 初始化块   
\{   
System.out.println(field);   
System.out.println("初始化块");   
\}   
  
// 构造器   
public InitialOrderTest() \{   
System.out.println("构造器");   
\}   
  
public static void main(String\[\] args) \{   
new InitialOrderTest();   
\}   
\}   
  
运行以上代码，我们会得到如下的输出结果：   
  
静态变量   
静态初始化块   
变量   
初始化块   
构造器   
  
这与上文中说的完全符合。那么对于继承情况下又会怎样呢？我们仍然以一段测试代码来获取最终结果：   
Java代码   
class Parent \{   
// 静态变量   
public static String p\_StaticField = "父类--静态变量";   
// 变量   
public String p\_Field = "父类--变量";   
  
// 静态初始化块   
static \{   
System.out.println(p\_StaticField);   
System.out.println("父类--静态初始化块");   
\}   
  
// 初始化块   
\{   
System.out.println(p\_Field);   
System.out.println("父类--初始化块");   
\}   
  
// 构造器   
public Parent() \{   
System.out.println("父类--构造器");   
\}   
\}   
  
public class SubClass extends Parent \{   
// 静态变量   
public static String s\_StaticField = "子类--静态变量";   
// 变量   
public String s\_Field = "子类--变量";   
// 静态初始化块   
static \{   
System.out.println(s\_StaticField);   
System.out.println("子类--静态初始化块");   
\}   
// 初始化块   
\{   
System.out.println(s\_Field);   
System.out.println("子类--初始化块");   
\}   
  
// 构造器   
public SubClass() \{   
System.out.println("子类--构造器");   
\}   
  
// 程序入口   
public static void main(String\[\] args) \{   
new SubClass();   
\}   
\}   
  
运行一下上面的代码，结果马上呈现在我们的眼前：   
  
父类--静态变量   
父类--静态初始化块   
子类--静态变量   
子类--静态初始化块   
父类--变量   
父类--初始化块   
父类--构造器   
子类--变量   
子类--初始化块   
子类--构造器   
  
现在，结果已经不言自明了。大家可能会注意到一点，那就是，并不是父类完全初始化完毕后才进行子类的初始化，实际上子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。   
  
那么对于静态变量和静态初始化块之间、变量和初始化块之间的先后顺序又是怎样呢？是否静态变量总是先于静态初始化块，变量总是先于初始化块就被初始化了呢？实际上这取决于它们在类中出现的先后顺序。我们以静态变量和静态初始化块为例来进行说明。   
  
同样，我们还是写一个类来进行测试：   
Java代码   
public class TestOrder \{   
// 静态变量   
public static TestA a = new TestA();   
  
// 静态初始化块   
static \{   
System.out.println("静态初始化块");   
\}   
  
// 静态变量   
public static TestB b = new TestB();   
  
public static void main(String\[\] args) \{   
new TestOrder();   
\}   
\}   
  
class TestA \{   
public TestA() \{   
System.out.println("Test--A");   
\}   
\}   
  
class TestB \{   
public TestB() \{   
System.out.println("Test--B");   
\}   
\}   
  
运行上面的代码，会得到如下的结果：   
  
Test--A   
静态初始化块   
Test--B   
  
大家可以随意改变变量a、变量b以及静态初始化块的前后位置，就会发现输出结果随着它们在类中出现的前后顺序而改变，这就说明静态变量和静态初始化块是依照他们在类中的定义顺序进行初始化的。同样，变量和初始化块也遵循这个规律。

了解了继承情况下类的初始化顺序之后，如何判断最终输出结果就迎刃而解了。

静态块与静态成员的初始化工作与实例化过程无关，实例化必须先执行静态块和静态成员，但并不代表实例化一定会执行静态块和静态成员。只有当实例化的对应的类为加载入虚拟机的时候，才会进行这种操作。有些时候执行静态块或者初始化静态成员不一定就是实例化该类对象才会进行的，例如调研该类的某静态成员或者静态方法，又例如该类的子类被实例化或者调用了静态成员或静态方法等。  
  
还有实例化的实际顺序其实是(省略类初始化过程)  
1、进入当前类构造方法。  
2、进入父类构造方法递归直到java.lang.Object类构造方法。  
3、执行java.lang.Object类构造方法，顺序依次为成员变量初始与初始化块(安装上下文顺序)，对应调用的构造方法体。  
4、执行java.lang.Object类的直接子类的构造函数，这个过程递归到当前类。  
5、当前类执行顺序与前面java.lang.Object类相同。  
  
构造方法的本质其实就是一个普通的无返回参数的名字叫做<init>的方法，不过虚拟机调用这个方法的指令与其它方法不同而已，它的调用指令与调用private方法的指令相同。  
在虚拟机中存在三种方法的调用指令，这三种调用指令在效率上不同。  
接口方法的指令调用，这种调用速度最慢。  
普通类方法的调用指令，这种调用速度中等。  
构造方法与私有方法调用指令，这种调用速度最快。

Please call me JiangYouDang!

> ## 欢迎关注公众号： ##
> 
> # ![70][] #

[Java_ _...]: http://www.cnblogs.com/luckygxf/p/4796955.html
[70]: /images/20220713/3357f638b6c5476e93a4e44dcb20eeb5.png