class OutTer{
private String str = "hello" ;  //定义属性
public void fun (final int temp){  //定义方法
  class InNer{  //在方法中定义内部变量
   public void prin(){   //定义内部类方法
    System.out.println("访问外部类中的属性:"+str) ;
    System.out.println("外部类方法的参数:"+temp) ;
   }
  }
   new InNer().prin() ;
}
}
public class InnerDemo6{
public static void main(String args[]){
  new OutTer().fun(30) ; //实例化
  //  new OutTer().fun().InNer().prin() ;  为什么不能实例化方法中的内部类方法
}
}
运行结果：

new OutTer().fun(30) ; //实例化
  //  new OutTer().fun().InNer().prin() ;  为什么不能实例化方法中的内部类方法

你的意思应该是问为什么第二句不能用一个 方法点方法 的方式调用吧?
你没注意,可以用这种方式实现的情况是: 作为调用者的方法是有返回值类型的,而且被调用的方法是调用者的返回类型所具有的方法

我把你程序中这句拿出来单独跟你讲：
//  new OutTer().fun().InNer().prin() ;  为什么不能实例化方法中的内部类方法

首先，前面部分new OutTer().fun()这个方法的调用就是错误的，因为你在程序中定义
了一个是带参数的fun(int temp)方法，而并没有定义无参数的fun()方法，所以你这个
语法本身就是有问题的。

其次即使你把程序改成调用的是带参数的fun(int temp)方法，还是会报错，那是因为
带参数的fun(int temp)方法返回的类型是void，一个返回类型为void的方法怎么可以
调用其他方法或属性呢？

这样跟你解释，不知道你能明白不？

new OutTer().fun().InNer().prin() ;  为什么不能实例化方法中的内部类方法
要问应该也是这样问吧new OutTer().fun(30).InNer().prin() ;  定义一个实例对象，调用自己的方法：new OutTer().fun(30)；这样本身就已经结束语句了，没有任何返回值，只是方法体中的打印语句。
InNer().prin()这个只能是在prin()为static的时候才能用，现在程序只能是用new Iner().prin();
上面两个都是单独的，不能混在一起

内部类通常由成员方法创建其实例。通常有两种方法：
第一种：在方法体里面去new。就像你现在做的一样 class OutTer{
private String str = "hello" ;  //定义属性
public void fun (final int temp){  //定义方法
  class InNer{  //在方法中定义内部变量
   public void prin(){   //定义内部类方法
    System.out.println("访问外部类中的属性:"+str) ;
    System.out.println("外部类方法的参数:"+temp) ;
   }
  }
   new InNer().prin() ;其实你是在这里实例化的}
}
public class InnerDemo6{
public static void main(String args[]){
  new OutTer().fun(30) ; //实例化}
}
第二种：直接在参数括号中new一个内部类对象，作为期参数。在awt编程的事件监听中，有很多适配器，通常是这样的情况，比如：
        frame.addWindowListener(new WindowAdapter(){
                        public void windowClosing(WindowEvent e){
                                System.exit(0);
                        }
                });

1. class Outer{
   
2.         private String str = "hello" ;  //定义属性
   
3.         public void fun (final int temp){  //定义方法
   
4.     class Inner{  //在方法中定义内部变量
   
5.                 void prin(){   //定义内部类方法
   
6.                         System.out.println("访问外部类中的属性:"+str) ;
   
7.                         System.out.println("外部类方法的参数:"+temp) ;
   
8.             }
   
9.         }
   
10.         new InNer().prin();// 这不是已经实例化了吗
    
11.         }
    
12. }
    
13. public class InnerDemo6{
    
14.         public static void main(String args[]){
    
15.         new Outer().fun(30) ; //实例化
    
16.         //new Outer().fun().Inner().prin() ;  //为什么不能实例化方法中的内部类方法
    
17.         }
    
18. }
    

复制代码

new InNer().prin();// 这不是已经实例化了吗
难道在Outer类内部实例化一次，然后再main方法中实例化一次吗？

要在外部实例化，我只能想到这种方法，即Inner类是类中定义的内部类，内部类通过创建对象从外部类之外被调用。代码：

1. class Outer{
   
2.         private String str = "hello" ;  //定义属性
   
3.         
   
4.     public class Inner{
   
5.                 void prin(){   //定义内部类方法
   
6.                         System.out.println("访问外部类中的属性:"+str) ;
   
7.             }
   
8.         }
   
9. }
   
10. public class InnerDemo7{
    
11.         public static void main(String args[]){
    
12.         new Outer().new Inner().prin();// 相当于Outer outer = new Outer();Outer.Inner inner = outer.new Inner();inner.prin();
    
13.         }
    
14. }
    

复制代码