1. class Outer
   
2. {
   
3.         class Inner
   
4.         {
   
5.                 void function()
   
6.                 {
   
7.                         //如何在这个函数中访问Inner1中的x？
   
8.                 }
   
9.         }
   
10.        
    
11.         class Inner1
    
12.         {
    
13.                 int x=9;
    
14.         }
    
15.        
    
16. }

复制代码

问题在代码中

首先在你的代码的基础上完成了一个简单实例，编译和运行都是成功，你可以先试一下，如下：
class Outer
{
Outer.Inner inner1 = new Outer.Inner();
class Inner
{
  void function()
  {
   Outer.Inner1 inner = new Outer.Inner1();//由于Inner1类本质还是一个类，要调用%

1.     class Outer
   
2.     {
   
3.             class Inner extends Inner1//使用继承就好了
   
4.             {
   
5.                     void function(int y)
   
6.                     {
   
7.                            y=x; //如何在这个函数中访问Inner1中的x？
   
8.                     }
   
9.             }
   
10.            
    
11.             class Inner1
    
12.             {
    
13.                    int x=9;
    
14.             }
    
15.            
    
16.     }

复制代码

使用继承不就好了，使用继承之后，Inner就继承了Inner1中的非私有成员x，这时就可以使用x的值了

class Outer{
        public void print(){
                new Inner().function();//调用这个方法可以测试打印出获取的值。
        }
        class Inner{
                void function(){
                        Outer.Inner1 inner = new Outer.Inner1();
                        System.out.println(inner.x);
                }
        }
        class Inner1{
                int x = 9;
        }
}

1. 
   
2. class Outer
   
3. {
   
4.         class Inner
   
5.         {
   
6.                 void function()
   
7.                 {
   
8.                         //如何在这个函数中访问Inner1中的x?
   
9.                         Outer.Inner1 in = Outer.this.new  Inner1();  //关键是这里，要拿了Inner1的对象就可以用了。
   
10.                         //根据成员内部类的实例规则，必须用外部类的实例来  外部类实例.new 内部类  才能产生个对象的。
    
11.                         //而这个函数中，也是在另一个外部内部类中，所以不能直接用this，而要用Outer.this 来获取外部类实例
    
12.                         System.out.println("拿到Inner1的x了，x="+in.x);
    
13.                 }
    
14.         }
    
15.         
    
16.         class Inner1
    
17.         {
    
18.                 int x=9;
    
19.         }
    
20.         
    
21.         public static void main(String[] args){
    
22. 
    
23.                 Outer out = new Outer();
    
24.                 Outer.Inner in = out.new Inner();
    
25.                 in.function();
    
26.         }
    
27. }
    

复制代码

//如何在这个函数中访问Inner1中的x?
                        Outer.Inner1 in = Outer.this.new  Inner1();  //关键是这里，要拿了Inner1的对象就可以用了。
                        //根据成员内部类的实例规则，必须用外部类的实例来  外部类实例.new 内部类  才能产生个对象的。
                        //而这个函数中，也是在另一个外部内部类中，所以不能直接用this，而要用Outer.this 来获取外部类实例
                        System.out.println("拿到Inner1的x了，x="+in.x);

void function()

                {

                    System.out.println(new Inner1().x);

                }

首先在你的代码的基础上完成了一个简单实例，编译和运行都是成功，你可以先试一下，如下：
class Outer
{
Outer.Inner inner1 = new Outer.Inner();
class Inner
{
  void function()
  {
   Outer.Inner1 inner = new Outer.Inner1();//由于Inner1类本质还是一个类，要调用它的成员，必须首先你必须实例化一个Inner1类，然后你就可以通过Inner1类对象inner调用x了。具体分析在下边
      System.out.println(inner.x);
   }
  }
        
  class Inner1
{
   int x=9;
  }
        
        
}
class InnerDemo
{
public static void main(String[] args)
  {
   Outer out = new Outer();
    out.inner1.function();
  }
}
执行的结果为：9
解释如下：
内部类相同于外部类的一个成员，和外部类的其他成员是同级的。Java编译器在创建内部类对象时，隐式的把其外部类对象的引用也传了进去并一直保存着，这样就使得内部类对象始终可以访问其外部类对象，同时外部类成员的作用域是整个外部类，包括内部类。所以内部类（除了静态内部类）可以访问外部类的任意成员，只不过访问的方式不同。你这里的Inner和Inner1两个内部类都是外部类Outer的成员，它们又都不是静态的，所以它们彼此可以互相访问。内部类访问外部类成员需要借助于：“外部类名.this“，但这里要访问的成员是类，如果还用外部类名.this会报错，而访问格式应该是：外部类名。
注意：要想调用内部类成员或者创建内部类对象，必须先创建外部类对象。