定义一个包含私有变量的类，在该类中在定义一个内部类。
问 ：1、内部类中的函数能否访问外部类的私有变量，还有外部类的函数呢？
        2、外部类中的函数能否访问内部类的变量与函数呢？

定义一个包含私有变量的类，在该类中在定义一个内部类。
问 ：1、内部类中的函数能否访问外部类的私有变量，还有外部类的函数呢？
                内部类又称为嵌套类，可以把内部类理解为外部类的一个普通成员。

        内部类访问外部类
        里面的可以自由访问外面的，规则和static一样。（访问非静态时必须先创建对象）
         
        具体如下：
         
        非静态内部类的非静态方法
        直接访问
         
        [java]  
        public class Outter {  
                int i = 5;  
                static String string = "Hello";  
                  
                class Inner1{  
                        void Test1 (){  
                                System.out.println(i);  
                                System.out.println(string);  
                        }  
                }  
        }<span style="font-family:Arial,Helvetica,sans-serif"> </span>         
2、外部类中的函数能否访问内部类的变量与函数呢？
         class Outer{

        Outer(){}

        public void method(){

                                        final String name="abc";

                                        final int age=26;

                                        class Inner{

                                                                        public void getValue(){

                                                                                                        System.out.println(name+":"+age);

                                                                        }

                                        }
                                        new Inner().getValue();//加上这句话就可以了
                        }        

        }

        class N1
        {
                        public static void main(String[] args)
                        {
                                        new Outer().method();               

                        }
        }
=----------------------------------------------------------------------------------
主要是得到内部类的对象，内部类对象创建有3中情况，
1.在外部类的一般方法中创建：直接使用Inner in = new Inner();
2.在外部类的静态方法中创建：以为静态方法无法访问非静态对象，所以Inner in = new Outer().new Inner();这样创建，即创建一个外部类的对象再用外部类对象去创建内部类对象。
3.在别的类中，使用Outer.Inner in = new Outer().new Inner();        创建

*内部类可以直接访问外部类的成员，包括私有
*外部类访问内部类，建立内部类对象
*内部类可以被私有修饰，当内部类在外部类的成员变量的位置的时候
*内部类可以访问外部类的成员，是因为内部类持有了一个外部类的引用，格式外部类.this.*;
外部类也可以访问内部类

1. class Outer {
   
2. private  int x=3;
   
3.    class Inter
   
4.    {
   
5.            int x=4;
   
6.            void fun()
   
7.            {   
   
8.                    int x=5;
   
9.                    System.out.println("内部类访问的是fun函数中的变量："+x);
   
10.                    System.out.println("内部类访问的是本内部类中的变量："+this.x);
    
11.                    System.out.println("内部类访问的是外部类中的变量："+Outer.this.x);
    
12.            }
    
13.    }
    
14.    void show()
    
15.    {
    
16.            Inter in=new Inter();
    
17.        in.fun();
    
18.            System.out.println("外部类可以内部类的成员变量  X："+in.x);
    
19.    }
    
20.        
    
21.         public static void main(String[] args) {
    
22.                 // TODO Auto-generated method stub
    
23.         Outer out =new Outer ();
    
24.         out.show();
    
25.         Outer.Inter in=new Outer().new Inter();//直接引用内部类
    
26.      }
    
27. }

复制代码

这是运行结果

内部类可以访问外部类中的成员，包括私有。
外部类要访问内部类，必须建立内部类对象
只是当外部类中的静态方法访问内部类时，内部类也必须是静态的

1. class Outer
   
2. {
   
3.         private int x = 3;//外部类中的私有变量
   
4.         class Inner//内部类
   
5.         {
   
6.                 int y = 5;//内部类变量
   
7.                 void function()//内部类调用外部类的私有成员变量
   
8.                 {
   
9.                         System.out.println("内部类调用外部类的私有成员变量"+x);
   
10.                 }
    
11.                 void function_1()
    
12.                 {
    
13.                         System.out.println("外部类调用内部类的函数");
    
14.                 }
    
15.                 void function_2()//内部类调用外部类的函数
    
16.                 {
    
17.                         method_2();
    
18.                 }
    
19.         }
    
20.         void method()//外部类调用内部类的函数
    
21.         {
    
22.                 Inner in = new Inner();
    
23.                 in.function_1();
    
24.         }
    
25.         void method_1()//外部类调用内部类的成员变量
    
26.         {
    
27.                 Inner in = new Inner();
    
28.                 System.out.println("外部类调用内部类的成员变量"+in.y);
    
29.         }
    
30.         void method_2()
    
31.         {
    
32.                 System.out.println("内部类调用外部类的函数");
    
33.         }
    
34. }
    
35. class InnerClassDemo
    
36. {
    
37.         public static void main(String[] args)
    
38.         {
    
39.                 Outer out = new Outer();
    
40.                 out.method();
    
41.                 out.method_1();
    
42.                 Outer.Inner in = new Outer().new Inner();
    
43.                 in.function();
    
44.                 in.function_2();
    
45.         }
    
46. }

复制代码

内部类的访问规则：
1，内部类可以直接访问外部类中的成员，包括私有。
2，外部类要访问内部类，必须建立内部类的对象。

内部类能访问外部类的所有成员，外部类要访问内部类必须先构造一个内部类实例对象

1.可以直接访问，包括私有；即内部类访问外部类不需要创建外部类的对象，因为内部类持有外部类的引用；外部类.this;
2.不可以直接访问；外部类访问内部类需要创建对象

1、        当内部类定义在外部类的成员位置上时，而且非私有，则可以在外部其他类中直接建立内部类对象
格式：外部类名.内部类名  对象名  =  new  外部类名().new 内部类名()；
2、        当内部类在外部类的成员位置上时，就可以被成员修饰符所修饰，比如，
private： 将内 部类在外部类中进行封装
static： 内部类就具备static的特性，这时内部类只能访问外部类中的static成员。
3、        在外部其他类中，如何直接访问静态内部类的非静态成员？
因为内部类为静态，会在外部类加载时直接加载，所以可以通过以下建立内部类对象的方式访问非静态的function函数：new Outer.Inner().function();
4、        在外部其他类中，如何直接访问静态内部类的静态成员？
因为内部类为静态，内部类方法也为静态，所以在外部类加载时就都加载了，所以可以直接调用：Outer.Inner.funtion();
5、        当内部类中定义了静态成员，该内部类必须是静态的
6、        当外部类中的静态方法访问内部类时，该内部类必须是静态的
7、        内部类定义在局部时，不可以被成员修饰符修饰，内部类的成员也不能被修饰。可以直接访问外部类成员，但是不可以访问它所在的局部中的变量，除非此变量被final修饰