内部静态类问题

在hackerrank上面遇到了一道问题涉及到Java的内存机制。

代码如下：

package com.company;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.security.Permission;


public class Solution {

   public static void main(String[] args) throws Exception {
       DoNotTerminate.forbidExit();

       try{
           BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
           int num = Integer.parseInt(br.readLine().trim());
           Object o;// Must be used to hold the reference of the instance of the class Solution.Inner.Private
           o = new Inner().new Private();
           System.out.println(((Inner.Private) o).powerof2(num));
           System.out.println("An instance of class: " + o.getClass().getCanonicalName() + " has been created");
       }//end of try

       catch (DoNotTerminate.ExitTrappedException e) {
           System.out.println("Unsuccessful Termination!!");
       }
   }//end of main
   static class Inner{
       private class Private{
           private String powerof2(int num){
               return ((num&num-1)==0)?"power of 2":"not a power of 2";
           }
       }
   }//end of Inner

}//end of Solution

class DoNotTerminate { //This class prevents exit(0)

   public static class ExitTrappedException extends SecurityException {

       private static final long serialVersionUID = 1L;
   }

   public static void forbidExit() {
       final SecurityManager securityManager = new SecurityManager() {
           @Override
           public void checkPermission(Permission permission) {
               if (permission.getName().contains("exitVM")) {
                   throw new ExitTrappedException();
               }
           }
       };
       System.setSecurityManager(securityManager);
   }
}

其中Inner是static的，我一开始觉得第17行代码应该这么写：

o = Inner.new Private();

因为Inner是一个静态类。

结果编译器报错了。

查了一下discussion里面的留言，发现也有人遇到相同问题：

image.png

网友回复：

image.png

所以17行可以改为这样：

o = new Solution.Inner().new Private();

关于静态内部类实例化的解释：
非静态内部类是附属在外部类对象上的，需要先实例化一个外部类的对象，通过外部类对象才能实例化非静态内部类；
而静态内部类可以看做是直接附属在外部类上的，这个静态代表附属体是外部类，而不是外部类实例；
外部类在进程中是唯一的，而静态内部类不需要唯一，可以生成多个实例。

静态内部类不依赖于外围类的事例，而不是说不依赖于类的实例。

这样实际上使静态内部类成为了一个顶级类。