内部类和顶级类及static修饰的内部类

一个".java"源文件中是否可以包括多个类？

 

是的。

  

一个".java"源文件中是否可以包括多个public修饰的类？

可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。我说的是不包括内部类，因为内部类可

 

以被public修饰，所以在不包括内部类的情况下一个类中只能有一个类被public修饰符修饰。

 

 

 这是内部类的情况：

Java代码  

1. public class Hello  
2. {  
3.     int a = 2;  
4.        public static void main(String[] args)  
5.         {  
6.             new Hello().new newHello().count();  
7.         }  
8.          
9.        public  class newHello  
10.        {  
11.            public void count()  
12.            {  
13.                new Hello().a = 1;  
14.                System.out.println("aaa");  
15.            }  
16.              
17.        }   
18. }         

 

 这也是内部类的情况：

 

Java代码  

1. public class Hello  
2. {  
3.     int a = 2;  
4.        public static void main(String[] args)  
5.         {  
6.             new Hello().new newHello().count();  
7.         }  
8.          
9.        protected class newHello  
10.        {  
11.            public void count()  
12.            {  
13.                new Hello().a = 1;  
14.                System.out.println("aaa");  
15.            }  
16.              
17.        }   
18. }         

 

 

这是静态内部类：

 

Java代码  

1. public class Hello  
2. {  
3.     static int a = 2;  
4.        public static void main(String[] args)  
5.         {  
6.             new newHello().count();  
7. //            new Hello().new newHello().count();  
8. //            System.out.println(new Hello().new newHello().b);  
9.             System.out.println(new newHello().b);  
10.         }  
11.          
12.        public static class newHello  
13.        {  
14.            int b = 3;  
15.            public void count()  
16.            {  
17.                  
18.                System.out.println(a);  
19.            }  
20.              
21.        }   
22. }         
23.   
24.     

 

 

这是外部类的情况:

 

 

Java代码  

1. public class Hello  
2. {  
3.     int a = 2;  
4.        public static void main(String[] args)  
5.         {  
6.             new Hello().new newHello().count();  
7.             System.out.println(new Hello().new newHello().b);  
8.         }  
9.          
10.        public  class newHello  
11.        {  
12.            int b = 3;  
13.            public void count()  
14.            {  
15.                  
16.                System.out.println(a);  
17.            }  
18.              
19.        }   
20. }         
21.   
22.  class Hello2  
23. {  
24.      public void  test()  
25.      {  
26.          System.out.println(new Hello().a);  
27.          System.out.println(new Hello().a);  
28.      }  
29. }         

 

  总结：

 

  与.java文件名相同的类是顶级类，顶级类里面的类是内部类，内部类可以被修饰符修饰。

 

 顶级类以外的类不可以被修饰符修饰。

 

 顶级类通过本身对象.内部类对象.属性或者方法调用内部类属性方法。

 

 内部类可以直接用顶级类里面的全局变量。

 

 静态内部类相当于一个单独的类。调用是通过对象调用的。

本文转自：http://woshixushigang.iteye.com/blog/1149013