Java面试细节：静态变量和静态块静态方法静态类的底层实现原理

Posted 黄小斜

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java面试细节：静态变量和静态块静态方法静态类的底层实现原理相关的知识，希望对你有一定的参考价值。

Java静态变量的初始化（static块的本质）

在网上看到了下面的一段代码：


public class Test    
    static    
         _i = 20;   
        
    public static int _i = 10;   
       
    public static void main(String[] args)    
         System.out.println(_i);   
        
  
public class Test  static  _i = 20;  public static int _i = 10; public static void main(String[] args)  System.out.println(_i);

上述代码会打印出什么结果来呢？10还是20？本文将以此代码为引子，着重讨论一下静态变量的初始化问题。

问题1：静态变量如何初始化

Java类中可以定义一个static块，用于静态变量的初始化。如：


public class Test    
    public static int _i;   
    static    
         _i = 10;   
        
  
public class Test  public static int _i; static  _i = 10;

当然最常用的初始化静态变量的操作是在声明变量时直接进行赋值操作。如：


public class Test    
    public static int _i = 10;   
  
public class Test  public static int _i = 10;

那么上述两例在本质上有什么区别吗？回答是没有区别。两例代码编译之后的字节码完全一致，通过 “javap -c”查看到的字节码如下：

public class Test extends java.lang.Object
public static int _i;

public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return

static ;
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: return

通过字节码还可以看出，当类的定义中不含有static块时，编译器会为该类提供一个默认的static块。当然这是在含有静态变量初始化操作的前 提下。如果静态变量没有初始化操作，则编译器不会为之提供默认的static块。如：


public class Test    
    public static int _i;   
  
public class Test  public static int _i;

其字节码的表现形式为：

public class Test extends java.lang.Object
public static int _i;

public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return

由于静态变量是通过赋值操作进行初始化的，因此可以通过静态函数返回值的方式为其初始化。如：


public class Test    
    public static int _i = init();   
       
    private static int init()    
        return 10;   
        
  
public class Test  public static int _i = init(); private static int init()  return 10;

其本质与下面的代码相同：


public class Test    
    public static int _i;   
    static    
         _i = init();   
        
       
    private static int init()    
        return 10;   
        
  
public class Test  public static int _i; static  _i = init();  private static int init()  return 10;

问题2：JDK如何处理static块

类定义中可以存在多个static块吗？回答是可以。如：


public class Test    
    public static int _i;   
    static    
         _i = 10;   
        
       
    public static void main(String[] args)    
        
       
    static    
         _i = 20;   
        
  
public class Test  public static int _i; static  _i = 10;  public static void main(String[] args)   static  _i = 20;

此类编译之后的字节码为：

public class Test extends java.lang.Object
public static int _i;

public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return

public static void main(java.lang.String[]);
Code:
0: return

static ;
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: bipush 20
7: putstatic #2; //Field _i:I
10: return

观察static部分可以看出，上例的代码与下面的代码效果一致：


public class Test    
    public static int _i;   
       
    public static void main(String[] args)    
        
       
    static    
         _i = 10;   
         _i = 20;   
        
  
public class Test  public static int _i; public static void main(String[] args)   static  _i = 10; _i = 20;

此例可以证明，不仅类定义中可以有多个static块，而且在编译时编译器会将多个static块按照代码的前后位置重新组合成一个static 块。

问题3：如何看待静态变量的声明

静态变量存放在常量池之中。如何证明呢？如：


public class Test    
    public static int _i = 10;   
  
public class Test  public static int _i = 10;

使用“javap -c -verbose”查看其字节码的内容如下：

public class Test extends java.lang.Object
SourceFile: "Test.java"
minor version: 0
major version: 49
Constant pool:
const #1 = Method #4.#14; // java/lang/Object."<init>":()V
const #2 = Field #3.#15; // Test._i:I
const #3 = class #16; // Test
const #4 = class #17; // java/lang/Object
const #5 = Asciz _i;
const #6 = Asciz I;
const #7 = Asciz <init>;
const #8 = Asciz ()V;
const #9 = Asciz Code;
const #10 = Asciz LineNumberTable;
const #11 = Asciz <clinit>;
const #12 = Asciz SourceFile;
const #13 = Asciz Test.java;
const #14 = NameAndType #7:#8;// "<init>":()V
const #15 = NameAndType #5:#6;// _i:I
const #16 = Asciz Test;
const #17 = Asciz java/lang/Object;


public static int _i;


public Test();
Code:
Stack=1, Locals=1, Args_size=1
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
LineNumberTable: 
line 2: 0

static ;
Code:
Stack=1, Locals=0, Args_size=0
0: bipush 10
2: putstatic #2; //Field _i:I
5: return
LineNumberTable: 
line 3: 0

我们看到，常量池中const #2指向的就是Test._i，也就是静态变量。静态变量被保存到常量池中的工作原理这里不深入讨论。在此需要注意的是：

  • 静态变量的声明与初始化是两个不同的操作；
  • 静态变量的声明在编译时已经明确了内存的位置。

如：


public class Test    
    public static int _i = 10;   
  
public class Test  public static int _i = 10;

上述代码的本质可以视为：


public class Test    
    // 静态变量的声明   
    public static int _i;   
  
    // 静态变量的初始化   
    static    
         _i = 10;   
        
  
public class Test  // 静态变量的声明 public static int _i; // 静态变量的初始化 static  _i = 10;

由于静态变量的声明在编译时已经明确，所以静态变量的声明与初始化在编码顺序上可以颠倒。也就是说可以先编写初始化的代码，再编写声明代码。如：


public class Test    
    // 静态变量的初始化   
    static    
         _i = 10;   
        
       
    // 静态变量的声明   
    public static int _i;   
  
public class Test  // 静态变量的初始化 static  _i = 10;  // 静态变量的声明 public static int _i;

对初始问题的解答

解答了上述三个问题，让我们再来看看开篇提到的问题。代码如下：


public class Test    
    static    
         _i = 20;   
        
    public static int _i = 10;   
       
    public static void main(String[] args)    
         System.out.println(_i);   
        
  
public class Test  static  _i = 20;  public static int _i = 10; public static void main(String[] args)  System.out.println(_i);

其本质可以用下面的代码表示：


public class Test    
    static    
         _i = 20;   
        
    public static int _i;   
    static    
         _i = 10;   
        
       
    public static void main(String[] args)    
         System.out.println(_i);   
        
  
public class Test  static  _i = 20;  public static int _i; static  _i = 10;  public static void main(String[] args)  System.out.println(_i);

再简化一下，可以表示为：


public class Test    
    public static int _i;   
       
    static    
         _i = 20;   
         _i = 10;   
        
       
    public static void main(String[] args)    
         System.out.println(_i);   
        
  
public class Test  public static int _i; static  _i = 20; _i = 10;  public static void main(String[] args)  System.out.println(_i);

至此，代码已经明确告诉我们打印结果是什么了！

PS : java类的成员变量有俩种：一种是被static关键字修饰的变量，叫类变量或者静态变量；另一种没有static修饰，为实例变量。
　　在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。
　　在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

接下来再看看静态内部类的实现原理

Java内部类原理分析（静态内部类和成员内部类）

5 静态内部类
有时，使用内部类只是为了把一个类隐藏在另一个类的内部，并不需要内部类引用外围类对象。为此，可以将内部类声明为static，以便取消产生的引用。下面的例子中，minmax函数需要同时返回数组中的最小值和最大值，为此需要定义Pair类描述这种返回类型，为了防止产生名字冲突，将其定义为ArrayAlg的内部公有类，通过ArrayAlg.Pair访问它：

public class StaticInnerClassTest 
    public static void main(String[] args)
    
        double[] d = new double[20];
        for (int i = 0; i < 20; i++)
        
            d[i] = 100 * Math.random();
        
        ArrayAlg.Pair p = ArrayAlg.minmax(d);
        System.out.println("min = " + p.getFirst());
        System.out.println("max = " + p.getSecond());
    


class ArrayAlg

    /**
     * A pair of floating-point numbers
     */
    public static class Pair
    
        private double first;
        private double second;
        /**
         * 构造一对浮点数
         * @param f first number
         * @param s second number
         */
        public Pair(double f,double s)
        
            first = f;
            second = s;
        
        /**
         * 返回第一个数字
         * @return first number
         */
        public double getFirst()
        
            return first;
        
        /**
         * 返回第二个数组
         * @return second number
         */
        public double getSecond()
        
            return second;
        

    
    /**
     * 同时计算数组的最小值和最大值
     */
    public static Pair minmax(double[] values)
    
        double min = Double.POSITIVE_INFINITY;
        double max = Double.NEGATIVE_INFINITY;
        for (double v : values)
        
            min = Math.min(min, v);
            max = Math.max(max, v);
        
        return new Pair(min,max);
   



只有内部类可以声明为static，与常规内部类不同，只有静态内部类可以用于静态域和静态方法，而声明在接口中的内部类自动成为static和public类。
————————————————
版权声明：本文为CSDN博主「pissjello」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_42416780/article/details/109183703

测试类

产生的Class

javap -verbose -p TestClass

使用查看测试类会自己添加2个方法一个access$0和access$1这个是根据你内部类访问的成员如果只访问一个就自己产生一个

访问多个就产生多个(why 注：名称看来是为了安全) 注：有写工具看不到这2个方法还是用javap才是原生。

javap -verbose -p TestClass$StaticInner

看以看到静态内部类是不会有外层类的引用存在的，args_size=1表示自己的this引用

访问只能访问静态属性还是通过调用父类的.access$0获取的(不是直接类名)

从这个看来没有引用就不可以调用成员变量

javap -verbose -p TestClass$Inner

成员内部类 自己生成了一个外部类的引用final的this$0变量 所以他是可以调用非静态的变量的

掉用的时候是用access$1注意是传参进去的这样安全还可以调用private变量

注意：在成员内部内不能定义static 变量方法 why？（javac自己在里面定义了一个外部类的引用 所以必须是得存在外部类的对象才可以用这内部类）

所以调用的时候（new TestClass().new Inner()）你如果内部类可以有静态的说明可以直接类名调用和这个有冲突

以上是关于Java面试细节：静态变量和静态块静态方法静态类的底层实现原理的主要内容，如果未能解决你的问题，请参考以下文章

java面试基础知识总结

java类的加载顺序，静态块 非静态块 构造器属性方法等

java中的静态变量，静态方法与静态代码块详解

Java 核心基础之static静态代码块和静态方法

Java类的各种成员初始化顺序如：父子类继承时的静态代码块,普通代码块,静态方法,构造方法,等先后顺

Java初始化顺序（静态变量静态初始化块实例变量实例初始化块构造方法）