以下程序怎么用内部类对象访问外部类成员？？外部类对象怎么访问内部类成员？？？？注意：内部类，外部类中成员名相同。
class Outer
{
        int m=1;
        public void get()
        {
                System.out.println("外部类中m="+m);
        }
        public void show()
        {
                System.out.println("外部类中非静态函数");
        }
        public static void show1()
        {
                System.out.println("外部类中静态函数");
        }

        static class Inner//内部类中出现静态成员，所以内部类也必须为静态
        {
                int m=2;
                public void show()
                {
                        System.out.println("内部类中非静态函数");
                }
                public static void show1()
                {
                        System.out.println("内部类中静态函数");
                }
                public void get()
                {
                        System.out.println("内部类中m="+m);
                }

        }
}

class  Test3
{
        public static void main(String[] args)
        {
                Outer.Inner in=new Outer.Inner();
                in.show();
                in.get();
                in.show1();
                Outer out=new Outer();
                out.show();
                out.get();
                out.show1();
        }
}

操作外部类的成员变量：操作Outer.this.成员变量名
操作内部类的成员变量：操作this.成员变量名
操作局部成员变量：直接操作成员变量名

在外部其他类中，如何直接访问static内部类的非静态成员呢？(static的类名调用)
new Outer.Inner().方法名;
在外部其他类中，如何直接访问static内部类的静态成员呢？
Outer.Inner.方法名;
以下是修改后的代码：

1. //以下程序怎么用内部类访问外部类成员？外部类怎么访问内部类成员？
   
2. //注意：内部类，外部类中成员名相同。
   
3. 
   
4. 
   
5. class Outer
   
6. {
   
7.         int m=1;
   
8.         public void get()
   
9.         {
   
10.                 System.out.println("外部类中m="+m);
    
11.         }
    
12.         public void show()
    
13.         {
    
14.                 System.out.println("外部类中非静态函数");
    
15.         }
    
16.         public static void show1()
    
17.         {
    
18.                 System.out.println("外部类中静态函数");
    
19.         }
    
20. 
    
21.         static class Inner//内部类中出现静态成员，所以内部类也必须为静态
    
22.         {
    
23.                 int m=2;
    
24.                 public void show()
    
25.                 {
    
26.                         System.out.println("内部类中非静态函数");
    
27.                 }
    
28.                 public static void show1()
    
29.                 {
    
30.                         System.out.println("内部类中静态函数");
    
31.                 }
    
32.                 public void get()
    
33.                 {
    
34.                         System.out.println("内部类中m="+m);
    
35.                 }
    
36.         }
    
37. }
    
38. 
    
39. class  Test3
    
40. {
    
41.         public static void main(String[] args)
    
42.         {
    
43.                                 System.out.println("外部类......");
    
44.                                 new Outer().show();
    
45.                                 new Outer().get();
    
46.                                 Outer.show1();
    
47. 
    
48.                                 System.out.println("内部类......");
    
49.                                 new Outer.Inner().show();//在外部其他类中直接访问static内部类的非静态成员
    
50.                                 new Outer.Inner().get();
    
51.                                 Outer.Inner.show1();//在外部其他类中直接访问static内部类的静态成员                                                               
    
52.         }
    
53. }
    
54. 
    
55. /*
    
56. 运行结果：
    
57. 外部类......
    
58. 外部类中非静态函数
    
59. 外部类中m=1
    
60. 外部类中静态函数
    
61. 内部类......
    
62. 内部类中非静态函数
    
63. 内部类中m=2
    
64. 内部类中静态函数
    
65. */

复制代码

侯国奇 发表于 2013-3-21 23:54
在外部其他类中，如何直接访问static内部类的非静态成员呢？(static的类名调用)
new Outer.Inner().方法名; ...

内部类对象访问外部类成员？？外部类对象怎么访问内部类成员？？？？

HM汪磊 发表于 2013-3-22 00:03
内部类对象访问外部类成员？？外部类对象怎么访问内部类成员？？？？

内部类与外部类的互访:
1，内部类可以直接访问外部类中的成员，包括私有。这是因为内部类中持有一个外部类的引用，格式：外部类名.this
2，外部类要访问内部类，必须建立内部类对象。
特殊情况：当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。

内部类中可以这样写：外部类.this.变量

1.                 public void get()
   
2.                 {
   
3.                         System.out.println("内部类中m="+m);
   
4.                         System.out.println("外部类中m="+Outer.this.m)
   
5.                 }

复制代码

内部类定义在不同位置上的访问格式的不同：
1,当内部类定义在外部类的成员位置上：
可以在外部其他类中。可以直接访问（建立）内部类对象。
格式：        外部类名.内部类名  变量名 = 外部类对象.内部类对象;
            Outer.Inner in = new Outer().new Inner();

还可以用成员修饰符来修饰：
比如：private：将内部类在外部类中进行封装。
          static:内部类就具备static的特性。

          当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

          在外部其他类中，如何直接访问static内部类的非静态成员呢？
          new Outer.Inner().function();  需要new对象。

      在外部其他类中，如何直接访问static内部类的静态成员呢？
          outer.Inner.function(); 不需要new对象，直接访问。

注意：当内部类中定义了静态成员，该内部类必须是static的。当外部类中的静态方法访问内部类时，内部类也必须是static的。


2:当内部类定义在局部时，
1，不可以被成员修饰符修饰
2，可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。