class Outer
{
        private int x=2;
        private static class Inner
        {
                int x=3;
                int y=5;
                void run()
                {
                        System.out.println("y="+y);       
                }

                Outer.function();  //这里应该怎样调用外部类中的function方法？

        void method()
        {
                Inner in=new Inner();
                in.run();
        }
        private static void function()
        {
                System.out.println("x="+x);
        }
}

class Test6
{
        public static void main(String[] args)
        {
                Outer out=new Outer();
               
                out.method();
        }
}

这种方式访问外部类中的方法为什么不行？应该怎样访问？

我把你把错误修正了。

1. 
   
2. public class Test6
   
3. {
   
4.         public static void main(String[] args){
   
5.                 Outer out = new Outer();
   
6.                 out.method();
   
7.     }
   
8. }
   
9. 
   
10. class Outer{
    
11.         private static int x=2;
    
12.         
    
13.         private class Inner{        //静态内部类的私有修饰去掉
    
14.                 int x=3;
    
15.         int y=5;
    
16.         public void run(){
    
17.                 System.out.println("y="+y);
    
18.                 Outer.function();  //这里应该怎样调用外部类中的function方法？      之前你这里写到了run方法的外面。改到run方面的里面 才可以。
    
19.         }
    
20.         }
    
21.         
    
22.         void method()   
    
23.     {
    
24.                 Inner in = new Inner();
    
25.                 in.run();
    
26.     }
    
27.     private static void function()
    
28.     {
    
29.         System.out.println("x=" + x);  //静态方法是不能访问当前类中的非静态成员变量的。所以需要把 x 改成静态的。
    
30.     }
    
31. }
    
32. 
    
33. 
    
34. 
    
35. 
    

复制代码

class Outer
{
        private static int x=2; //必须定义成静态，不然静态方法function无法访问
        private static class Inner
        {
                int x=3;
                int y=5;
                void run()
                {
                        System.out.println("y="+y);  
                        function(); // 放在这里调用。外部类中的function（）方法并不属于Inner类中的元素，所以它只能被Inner类的“行为”void run方法调用，否则Inner类不能识别
                }   
                //function();  //这里应该怎样调用外部类中的function方法？放在这里的话，Inner不能识别，因为它不符合类中成员元素的特性。
  }
        void method()
        {
                Inner in=new Inner();
                in.run();
        }
        private static void function()
        {
                System.out.println("x="+x);
        }
}
class Test6
{
        public static void main(String[] args)
     {
                Outer out=new Outer();
               
                out.method();
        }
}

1. class Outer
   
2. {
   
3.          private  static int x=2;//这里的x需要加上静态，不然引用不到
   
4.          private static  class Inner
   
5.         {
   
6.                  int x=3;
   
7.                  int y=5;
   
8.                  void run()
   
9.                  {
   
10.                          System.out.println("y="+y);        
    
11.         Outer.function();  //这里应该怎样调用外部类中的function方法？//[color=Red]这个方法调用应该放在run里面[/color]
    
12.         }                        
    
13.         }
    
14.         void method()
    
15.          {
    
16.                  Inner in=new Inner();
    
17.                  in.run();
    
18.          }
    
19.          private  static void function()
    
20.          {
    
21.                  System.out.println("x="+x);
    
22.          }
    
23. }
    
24. 
    
25. class Test6
    
26. {
    
27.          public static void main(String[] args)
    
28.          {
    
29.                  Outer out=new Outer();
    
30.                  
    
31.                 out.method();
    
32.          }
    
33. }

复制代码

唉！来迟一步！大概总结下，static关键字的使用特点、注意事项、以及什么时候使用static关键字吧：
特点：
1.被static修饰的成员（方法、变量）、代码块，会随着类的加载而加载，即随着类的存在而存在，消失而消失

2.优先于对象存在，静态是先存在，对象是后存在的

3.被所有对象所共享

4.可以直接被类名直接调用（此特点很实用。如果可以看到一个方法被一个类（类名.方法）直接调用，那么这个方法在那个类中一定是静态的，例如楼主代码中的function()方法。在main函数中可是直接这样调用，Outer.function()）

注意事项：
1. static修饰的方法，不能访问所属类的非static变量或方法（就像function()函数要访问x=2这个变量一样，它得是static修饰的才行）

2. 静态方法只能访问静态成员，非静态方法既可以访问静态（例如，Inner类中的run()方法访问function（）函数）也可以访问非静态的成员

3. 静态方法中不可有this、super关键字，因为（在特点2中已经说明）静态优先于对象存在，所以静态方法中不可以有this、super等关键字

4. 非静态的内部类中不可以声明static成员（呵呵，不过楼主的Inner类是静态的）

5.在静态内部类中，可以定义static成员（也只能在static内部类中才可以定义static成员），但是static方法只能应用外部类中的静态成员

6.类名是不可以用static（还有protected、private）修饰的（但是内部类却可以，楼主的Inner类就是的）
          多说点内部类：
                     内部类定义在方法中时，不可以被成员修饰符修饰；可以直接访问外部类中的成员，但不可以访问它所在方法中的局部变量，只能访问被final修饰的字段

什么时候使用static：
1. 静态变量，当对象中出现共享数据时，该数据可以被static修饰

2.静态函数，当功能内部没有访问到非static数据（即对象的特有数据），那么该功能可以定义成static

已解决  谢谢、