想在主函数内调用 function() ，看了半天觉得根本就没法调用。是不是啊？
class outer
{
        int x = 3;
        void method(final int y)
        {
                final int x=4;
                class Inner
                {       
                        void function()
                        {
                                System.out.println(outer.this.x );
                        }
                }         
        }               
}

class day0904
{
        public static void main(String[] args)
        {                 
                outer ou = new outer();
                ou.method(5);
                ou.method(6);
        }
}

内部类可以直接访问外部类成员的，吧outer.this.x 直接写成x多好,这个时候打印出的4，而如果不改则打印出的是3

class outer
{
        int x = 3;
        void method(final int y)
        {
                final int x=4;
                class Inner
                {        
                        void function()
                        {
                                System.out.println(outer.this.x );
                                System.out.println(x );
                             
                        }
                }   
                Inner inner = new Inner();
                inner.function();
        }               
}

class day0904
{
        public static void main(String[] args)
        {                 
                outer ou = new outer();
                ou.method(5);
                ou.method(6);
               
               
               
               
        }
}

在外部类的调用方法内实例化内部类对象，然后调用就可以了。

内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
外部类要访问内部类，必须建立内部类对象。
访问格式：
        当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。
可以直接建立内部类对象。
格式
        外部类名.内部类名  变量名 = 外部类对象.内部类对象;
        Outer.Inner in = new Outer().new Inner();
代码如下：

class outerc//外部类
{
        private int x=3;
       
         class Inner//内部类
        {
                int x=4;
                void function()
                {
                        int x=6;
                        System.out.println("inner:"+this.x);
                }
        }
        void method()//在外部类的方法中建立内部类的对象对其访问   就可以访问内部类
        {
                //System.out.println(x);
                Inner in=new Inner();
                in.function();
        }
}
public class neibuleiDemo {
        public static void main(String[] args)
        {
                //outerc out=new outerc();//建立外部类对象
                //out.method();//调用外部类方法访问内部类方法
                //直接访问内部类中的成员    内部类不被私有修饰时可以
                outerc.Inner in=new outerc().new Inner();
                in.function();
               
        }

}

定义在成员方法体中的内部类，不能在外部其他类中直接创建内部类实例化对象，
进而用实例化对象调用内部类方法，
也就是说，在你上边的程序主函数中不能如下这样定义：

1. class day0904 //(这里你有一个小失误)类名首字母要大些
   
2. {
   
3.         public static void main(String[] args)
   
4.         {                 
   
5.                 outer ou = new outer();
   
6.                 ou.method(5);
   
7.                 ou.method(6);
   
8.                         Outer.Inner in = new Outer().new Inner();//编译失败       
   
9.         }
   
10. }

复制代码

这也是我遇到的问题，在相关书上也没找到一些有关讲解，后来自己琢磨：
1.Javc这种面相对象程序设计语言，一个显著的特点就是“封装”。
类将数据和操作数据的方法结合成一个单位。既可以方便维护升级，
也可以数据存储的权限问题
2.既然把内部类分为 定义外部类成员位置上的内部类，和成员方法体中的内部类，
各有各的特点，用途以及使用范围。

1)外部类成员位置上的内部类，可以在外部其他类中创建内部类实例对象，并调用其方法
访问格式如下：

Outer.Inner in = new Outer().new Inner();//非静态内部类

Outer.Inner in = new Outer.Inner();//静态内部类


2)外部类成员方法体中的内部类，只能在方法体中创建内部类实例，并访问其内部类成员。
该内部类不能在外部其他类中创建实例对象，这就是与成员内部类的不同。
因为使用方法不同，所以才有这两大种内部类
简写格式如下：

1. class Outer
   
2. {
   
3.         void method()
   
4.         {
   
5.                 class Inner
   
6.                 {
   
7.                         void function(){}
   
8.                 }
   
9.                 Inner in = new Inner();
   
10.                 in.function();
    
11.         }
    
12. }

复制代码

你这个代码 在主函数中进行实例化时，其实这样的写法有问题class day0904
{
        public static void main(String[] args)
        {                 
                outer ou = new outer();
                ou.method(5);
                ou.method(6);
        }
}
应该改成这样：class day0904
{
        public static void main(String[] args)
        {                 
                outer.method ou = new outer().new method();//修改成这个，按照你这样写，就得在内部类里先创建一个对象.
                ou.method(5);
                ou.method(6);
        }
}
从上面的例子不难看出，内部类其实严重破坏了良好的代码结构，但为什么还要使用内部类呢？

因为内部类可以随意使用外部类的成员变量（包括私有）而不用生成外部类的对象，这也是内部类的唯一优点

如同心脏可以直接访问身体的血液，而不是通过医生来抽血。
程序编译过后会产生两个.class文件，分别是oter.class和Outer$method.class

outer.method ou = new outer().new method()可以用来生成内部类的对象，这种方法存在两个小知识点需要注意

　　1.开头的Outer是为了标明需要生成的内部类对象在哪个外部类当中.

　　2.必须先有外部类的对象才能生成内部类的对象，因为内部类的作用就是为了访问外部类中的成员变量.

   内部类是：包含在类中的类，所以内部类也称为“嵌套类”，包含内部类的类又称为“外部类”。
   A.在封装它的类的内部使用内部类，与普通类的使用方式相同，但在外部引用内部类时，则必须在内部类名前冠以其所属外部类的名字才能使用。
   B.在用new运算符创建内部类时，也要在new前面冠以对象变量。

  另外你的程序里也没有用内部类创建对象，这样没法调用内部类的方法的。

明白了，谢了