同一个类中，有两个非静态方法a，b。如果a方法中有一个内部类，内部类中有一个非静态方法c，那么b方法如何能调用到内部类中的方法c呢？我
建立对象调用失败了
class Outer
{
        public void method_a()
       {
              System.out.println("method_a run");
              class Inner
              {
                       public void method_c()
                       {
                               System.out.println("method_c run");
                        }
              }
         }
        public void method_b()
         {
                 new Inner().method_c();//建立对象调用失败，提示在Outer类中找不到Inner符号
                 System.out.println("method_b run");
         }
}
class  Test2
{
        public static void main(String[] args)
        {
                 new Outer().method_b();
        }
}

不知道怎么回事代码乱了，大家见谅

1. class Outer
   
2. {
   
3.         public void method_a()
   
4.         {
   
5.                 System.out.println("method_a run");
   
6.                 class Inner
   
7.                 {
   
8.                          public void method_c()
   
9.                          {
   
10.                                    System.out.println("method_c run");
    
11.                          }
    
12.                  }
    
13.          }
    
14.          public void method_b()
    
15.          {
    
16.                    new Inner().method_c();//建立对象调用失败，提示在Outer类中找不到Inner符号
    
17.                    System.out.println("method_b run");
    
18.           }
    
19. }
    
20. class Test2
    
21. {
    
22.           public static void main(String[] args)
    
23.           {
    
24.                     new Outer().method_b();
    
25.           }
    
26. }
    

复制代码

重新发一下

emos-c 发表于 2013-6-14 22:19
重新发一下

1. class Outer
   
2. {
   
3.            public void method_a()
   
4.            {
   
5.                   System.out.println("method_a run");
   
6.            }
   
7.           class Inner
   
8.           {
   
9.                  public void method_b()
   
10.                 {
    
11.                        System.out.println("method_b run");
    
12.                 }
    
13.          }
    
14.          public void method_c()
    
15.         {
    
16.                  new Inner().method_b();//要想访问Inner内部成员方法，则必须创建Inner对象。
    
17.                 /*等价于
    
18.                Inner in = new Inner();
    
19.                in.method_b();
    
20.                */
    
21.                //new Inner().method2();我觉得是哥们你打错了，这里不是“2”而是“_b”,上文代码中没有method2()的方法。
    
22.               System.out.println("method3 run");
    
23.        }
    
24. }
    
25. class Test2
    
26. {
    
27.            public static void main(String[] args)
    
28.             {
    
29.                     new Outer().method_c();
    
30.             }
    
31. }
    
32. //不知道解决了哥们的问题没？
    

复制代码

楼主你把Inner类放在方法method_a定义的，所以Inner类只能在method_a方法中使用呀。如果你想在方法method_c对其实例化，只需要把Inner类的定义直接放在Outer类中就可以了。也就像楼上那样做就可以了。

同学你好，我写了一下，不知道是不是你想要的结果，你可以运行一下！

class Outer
{
public void method_b()
{
  System.out.println("method_b run");
         
  class Inner
  {
   public void method_c()
   {
    System.out.println("method_c run");
   }
   
  }
         
  {
          Inner i=new Inner();
                   i.method_c();
  }
}
public void method_a()
{
        System.out.println("method-a run");
  
                method_b();
}
}
class  Test2
{
public static void main(String[] args)
{
                Outer o=new Outer();
                o.method_a();
       
}
}

苑永志 发表于 2013-6-14 23:11
楼主你把Inner类放在方法method_a定义的，所以Inner类只能在method_a方法中使用呀。如果你想在方法method_c ...

“Inner类只能在它所在的方法即method_a中使用""。你这句话的意思就是说一个a方法中的 内部类中的 c方法只能由内部类所在的a方法建立对象调用，其它外部方法（如b方法）是无法直接调用到的对吗?还有一个问题就是内部类是随着所在函数的执行结束而消失吗？
昨天时间很紧，代码写的乱七八糟，但是你都看懂我的意思了，今天自己看着都费劲，又重新编辑了一下。以后我一定会注意……

emos-c 发表于 2013-6-15 17:55
“Inner类只能在它所在的方法即method_a中使用""。你这句话的意思就是说一个a方法中的 内部类中的 c方法 ...

没错的，一个a方法中的 内部类中的 c方法只能由内部类所在的a方法建立对象调用，其它外部方法（如b方法）无法访问到该类，内部类也是会随着所在函数的执行结束而消失（Inner类的定义实际上也是一段代码对吧，方法执行的时候加载到内存中，执行完之后就释放了）

emos-c 发表于 2013-6-15 17:55
“Inner类只能在它所在的方法即method_a中使用""。你这句话的意思就是说一个a方法中的 内部类中的 c方法 ...

之前的回答有误，对你造成的错误引导表示歉意。作为弥补，我跟你详细的剖析一下这个Inner类。
下面是我写改动之后的代码，旨在演示Inner类是能够在方法外部使用到的：

1. class Outer {
   
2.         Object referenceOfInner = null;
   
3.         
   
4.         public void method_a() {
   
5.                 //System.out.println("method_a run");
   
6.                 class Inner {
   
7.                         public void method_c() {
   
8.                                 System.out.println("method_c run");
   
9.                         }
   
10.                 }
    
11.                 referenceOfInner = new Inner();
    
12.         }
    
13. 
    
14.         public void method_b() throws Exception {
    
15.                 method_a();
    
16.                
    
17.                 Method m = referenceOfInner.getClass().getMethod("method_c");
    
18.                 m.invoke(referenceOfInner);
    
19.                
    
20.                 //System.out.println("method_b run");
    
21.         }
    
22.         
    
23.         public static void main(String[] args) throws Exception {
    
24.                 new Outer().method_b();
    
25.         }
    
26. }

复制代码

我们知道一个对象创建之后，它是放在堆内存的，我们对它的访问值通过该对象类型的引用变量进行。无论类的定义是放在哪里，只要我们拥有该类对象的引用，我们就能对它进行操作。对于上面的代码，我们通过Object类型的变量referenceOfInner（作为类的属性声明）指向一个Inner类型的变量（在Inner所在方法中创建该对象，因为Inner类的定义我们只能在method_a方法中才能访问到），
在方法method_b中，我们首先调用method_a使referenceOfInner指向堆内存中的Inner对象。
method_a执行完之外，我们虽然已经不能够再使用Inner类定义，但是我们却可以对Inner对象的引用referenceOfInner，进而调用其方法。
因为不能够将referenceOfInner强制转型为Inner类型，我们使用反射机制进行操作，如上所示。