有谁可以解释一下呢

完全可以。如果不是静态内部类，那没有什么限制！

如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员，例如，下面的代码：

class Outer

{

   static int x;

   static class Inner

   {

         void test()

         {

               syso(x);

         }

   }

}

内部类可以任意调用其他包的类，方法如下

1. package Heima001_DumpAndDown100;
   
2. 
   
3. import Heima001_DumpAndDown200.Test2;
   
4. 
   
5. 
   
6. public class Test {
   
7.         public static void main(String[] args)  {
   
8.                 System.out.println("*****************************");
   
9.                 System.out.println("我只要调用Outer");
   
10.                 new Outer();
    
11.                 System.out.println("*****************************");
    
12.                 System.out.println("我要使用内部类");
    
13.                 new Outer("我要使用内部类");
    
14.                 System.out.println("*****************************");
    
15.                 System.out.println("我要使用内部类并调用其他包的类");
    
16.                 new Outer("我要使用内部类","并调用其他包的类");
    
17.                 System.out.println("*****************************");
    
18.         }
    
19. }
    
20. 
    
21. class Outer{
    
22.         private String s;
    
23.         private String s2;
    
24.        
    
25.         public Outer(String s) {
    
26.                 new Inner();
    
27.         }
    
28.        
    
29.         public Outer(String s, String s2) {
    
30.                 new Inner(s);
    
31.         }
    
32. 
    
33. 
    
34.         public String getS() {
    
35.                 return s;
    
36.         }
    
37. 
    
38.         public void setS(String s) {
    
39.                 this.s = s;
    
40.         }
    
41. 
    
42.         public Outer() {
    
43.                 System.out.println("Outer被调用了");
    
44.         }
    
45.        
    
46.         class Inner{
    
47.                 private String s;
    
48.                
    
49.                
    
50.                 public Inner(String s) {
    
51.                         System.out.println("内部类被调用了");
    
52.                         Test2 test2= new Test2();
    
53.                 }
    
54. 
    
55.                 public Inner() {
    
56.                         System.out.println("内部类被调用了");                       
    
57.                 }
    
58.                
    
59.         }
    
60. }

复制代码

其他包的类：

1. package Heima001_DumpAndDown200;
   
2. 
   
3. 
   
4. public class Test2 {
   
5.         int t2;
   
6.         public Test2(int t2) {
   
7.                 super();
   
8.                 this.t2 = t2;
   
9.         }
   
10.         public int getT2() {
    
11.                 return t2;
    
12.         }
    
13.         public void setT2(int t2) {
    
14.                 this.t2 = t2;
    
15.         }
    
16.         public Test2() {
    
17.                 System.out.println("另外包的Test2类被调用了");
    
18.         }
    
19. }
    
20. 
    

复制代码

输出结果：

*****************************
我只要调用Outer
Outer被调用了
*****************************
我要使用内部类
内部类被调用了
*****************************
我要使用内部类并调用其他包的类
内部类被调用了
另外包的Test2类被调用了
*****************************

知道为什么定义内部类么？就是为了方便引用外部类的成员呀