黑马程序员技术交流社区

标题: 内部类访问外部类 [打印本页]
作者: 吴通    时间: 2012-8-29 20:33
标题: 内部类访问外部类
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();
        }
}

这种方式访问外部类中的方法为什么不行？应该怎样访问？
作者: 唐志兵    时间: 2012-8-29 21:36
本帖最后由 唐志兵 于 2012-8-29 21:55 编辑

我把你把错误修正了。

  2. public class Test6
  3. {
  4.         public static void main(String[] args){
  5.                 Outer out = new Outer();
  6.                 out.method();
  7.     }
  8. }

  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. }




复制代码
作者: 梁志冰    时间: 2012-8-29 21:59
本帖最后由 ice 于 2012-8-29 22:02 编辑

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();
        }
}



作者: 芦曦    时间: 2012-8-29 22:14
  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. }

  25. class Test6
  26. {
  27.          public static void main(String[] args)
  28.          {
  29.                  Outer out=new Outer();
  30.                  
  31.                 out.method();
  32.          }
  33. }
复制代码
作者: 王得新    时间: 2012-8-29 22:54
本帖最后由 王得新 于 2012-8-29 22:58 编辑

唉！来迟一步！大概总结下，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

作者: 吴通    时间: 2012-8-30 12:53
已解决  谢谢、




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2