class Test {

public static void main(String[] args) {
  A a = new A();
  A.B b = a.new B();  
  
  a.name = "aaa";
  b.name = "bbb";
  
  a.fun();
  b.fun();
}
}
class A {
String name;
void fun() {
  System.out.println("A.fun(), name is " + name);
} //内部类可以访问外部类的成员变量，只要加A.this.name就可以了，
  //那外部类能不能访问内部类的成员变量呢？要怎么访问

class B {   
  String name;
  void fun() {
   String name = "ccc";
   System.out.println("B.fun(), name is " + this.name + ", Outer class name is " + A.this.name);  
   A.this.fun();
  }
}
}

内部类访问特点：
1，内部类可以直接访问外部类中的成员。
2，外部类要访问内部类，必须建立内部类的对象。

1. class Outer
   
2. {
   
3.         private static int num = 23;
   
4.         static class Inner// 内部类。
   
5.         {
   
6.                 void show()
   
7.                 {
   
8.                         System.out.println("show run..."+num);//内部类可以直接访问外部类中的成员
   
9.                 }
   
10.                 /*static void function()//如果内部类中定义了静态成员，该内部类也必须是静态的。
    
11.                 {
    
12.                         System.out.println("function run ...."+num);
    
13.                 }
    
14.                 */
    
15.         }
    
16.         public void method()
    
17.         {
    
18.                 Inner in = new Inner();//外部类要访问内部类，必须建立内部类的对象
    
19.                 in.show();
    
20.         }
    
21. }
    

复制代码

建立内部类的对象啊

外部类要想访问内部类的成员必须要建立内部类的对象！

1. class aa {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 A a = new A();
   
5.                 A.B b = a.new B(); //实例化了内部类的对象；
   
6.                 a.name = "aaa";
   
7.                 b.name = "bbb";
   
8. 
   
9.                 a.fun();
   
10.                 b.fun();   //这里访问了内部类B的方法；
    
11.                 System.out.println(b.name);  //这里访问了内部类B的name变量；
    
12.                
    
13.         }
    
14. }
    
15. 
    
16. class A {
    
17.         String name;
    
18. 
    
19.         void fun() {
    
20.                 B inner = new B();    //要想访问内部类的成员变量，首先实例化内部类；
    
21.                 System.out.println(inner.name); //访问内部类的成员变量；
    
22.                 inner.fun(); //访问内部类的方法；
    
23.                 System.out.println("A.fun(), name is " + name);
    
24.         } // 内部类可以访问外部类的成员变量，只要加A.this.name就可以了，
    
25. 
    
26.         // 那外部类能不能访问内部类的成员变量呢？要怎么访问
    
27. 
    
28.         class B {
    
29.             String name = "333";
    
30. 
    
31.                 void fun() {
    
32.                         String name = "ccc";
    
33.                         System.out.println("B.fun(), name is " + this.name
    
34.                                         + ", Outer class name is " + A.this.name);
    
35.                 }
    
36.         }
    
37. }

复制代码

class Test {

        public static void main(String[] args) {
                A a = new A();
                A.B b = a.new B();

                a.name = "aaa";
                b.name = "bbb";

                a.fun();
                b.fun();
        }
}

class A {
        String name;

        void fun() {
                System.out.println("A.fun(), name is " + name);
        } // 内部类可以访问外部类的成员变量，只要加A.this.name就可以了，
                // 那外部类能不能访问内部类的成员变量呢？要怎么访问

        class B {
                String name;

                void fun() {
                        String name = "ccc";
                        System.out.println("B.fun(), name is " + this.name
                                        + ", Outer class name is " + A.this.name);
                        A.this.fun();
                }
        }
}
//不能访问的，因为内部类是外部类的成员类，内部类就想是局部变量一样，如果想访问内部类可以创建内部类对象
//用对象来访问内部成员

内部类的存在使外部类的数据访问更为简单。外部类的数据内部类可以访问到的，包括外部类的私有成员。外部类访问内部类成员是要通过对象的。这时候我们可以在内部类写方法访问内部类自己的数据，通过对象调用方法来显示：
class Outer{
        String name="Outer";
        void show(){
                new Inner().Show();
        }
                 class Inner{
                        String name="Inner";
                         void Show(){
                                System.out.println("Inner's show…………"+name);
                        }       
                }       
}
public class Test2 {
    public static void main(String[] args)
    {
            Outer o=new Outer();
            o.show();
    }
}
如果内部类是静态的，则方法是非静态的则：
class Outer{
        private String name="Outer";
                static class Inner{
                                 static String name="Inner";
                                  void Show(){
                                        System.out.println("Inner's show…………"+name);
                                }       
                }
}
public class Test2 {
    public static void main(String[] args)
    {
            new Outer.Inner().Show();
    }
}