1. class Outer{
   
2.          private static final int b = 0;
   
3. //   public static void m() {
   
4.         class Inner {
   
5.                 int a = b; //不报错
   
6.                 public void fun(){
   
7.                  System.out.println(b);//输出b
   
8.                 }
   
9.         }
   
10.      //   System.out.println(b);//不报错
    
11.   //  }
    
12.     public static void print(){
    
13.         new Inner().fun() ;   //此处错误
    
14.     }
    
15. }
    
16. public class Demo6{
    
17.         public static void main(String args[]){
    
18.                 Outer out = new Outer() ;
    
19.                 out.print() ;
    
20.         }
    
21. }
    
22. 
    

复制代码

内部类是写在外部类中的一个类，但它同时也是外部类中的一个成员。
所以创建内部类对象的时候要先创建外部类对象，才能创建内部类对象。
也即是：new Outer().new Inner();
一般情况下，在外部类中创建内部类对象是可以省去new Outer()直接创建的，因为这里有个隐式的this引用。
但如果在静态方法里，就不能直接创建了，因为静态方法里是不能有this引用的。
所以你把

1. public static void print(){
   
2.    new Outer().new Inner().fun() ;   //此处错误，要先new Outer
   
3. }

复制代码

的static去掉就可以了。

package learn;

class Outer{

    private static final int b = 0;

//public static void m() {

   class Inner {

           int a = b; //不报错

           public void fun(){

            System.out.println(b);//输出b

           }

   }

//   System.out.println(b);//不报错

//  }

public  void print(){   //此处把static去掉即可，改静态函数建立时，内存中还没有Inner类，所以不能建立

    new Inner().fun();
}

}

public class learn{

   public static void main(String args[]){

           Outer out = new Outer() ;

           out.print() ;

   }

}

问题出在你的print()函数是静态的，而你的内部类却不是静态的。静态函数在内存一直存在，所以在调用该方法的时候，无法创建Inner 对象。只需要把print()函数的static去掉即可

你这代码号乱，看不清，大体感觉你的内部类时定义在方法中的，可见性很小，就像方法中定义的一个局部变量，外部类的方法是访问不到的

给你改了下代码

1. public class Help {
   
2. public static void main(String[] args) {
   
3.         Outer.print();
   
4. }
   
5. }
   
6. class Outer{
   
7.     private static final int b = 0;
   
8. //   public static void m() {
   
9.    class Inner {
   
10.            int a = b; //不报错
    
11.            public void fun(){
    
12.             System.out.println(b);//输出b
    
13.            }
    
14.    }
    
15. //   System.out.println(b);//不报错
    
16. //  }
    
17. public static void print(){
    
18.    new Outer().new Inner().fun() ;   //此处错误，要先new Outer
    
19. }
    
20. }
    

复制代码

        class Outer{
        private static final int b = 0;
//   public static void m() {
       class Inner {
               int a = b; //不报错
               public void fun(){
                System.out.println(b);//输出b
               }
       }
    //   System.out.println(b);//不报错
//  }
   public void print(){
       new Inner().fun() ;   //此处错误
   }
}
public class Demo6{
       public void main(String args[]){
               Outer out = new Outer() ;
               out.print() ;
       }
类名点只能调用静态的 不能调用非静态的

        class Outer{
        private static final int b = 0;
//   public static void m() {
       class Inner {
               int a = b; //不报错
               public static void fun(){   //把static 去掉就OK了
                System.out.println(b);//输出b
               }
       }
    //   System.out.println(b);//不报错
//  }
   public static void print(){                //把static 去掉就OK了
       new Inner().fun() ;   //此处错误
   }
}
public class Demo6{
       public void main(String args[]){
               Outer out = new Outer() ;
               out.print() ;
       }


主函数也写错了[]在String后面

• public class Demo6{
•         public static void main(String arg[]){
•                 Outer out = new Outer() ;
•                 out.print() ;
•         }
• }
  

• public class Demo6{
•         public static void main(String[] args){
•                 Outer out = new Outer() ;
•                 out.print() ;
•         }
• }
•