一
    
    
    
、在一个Java文件中定义多个类（外部类）

1.问题描述及解答

1     


     


     


  、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

答案：可以有多个类
    
    
    
，但只能有一个public的类     


     


     


  ，并且public的类名必须与文件名相一致    
    
    
  。一个文件中可以只有非public类 




 




 




 
，如果只有一个非public类

   

   

   

，此类可以跟文件名不同 


     


     


     
。

2 




 




 




 
、为什么一个java源文件中只能有一个public类？

在java编程思想（第四版）一书中有这样3段话（6.4 类的访问权限）：

每个编译单元（文件）都只能有一个public类     

     

     

 ，这表示  




  




  




  ，每个编译单元都有单一的公共接口


  


  


  


，用public类来表现

 




 




 




。该接口可以按要求包含众多的支持包访问权限的类   

   

   

 。如果在某个编译单元内有一个以上的public类     
     
     
，编译器就会给出错误信息  

     

     

     。 public类的名称必须完全与含有该编译单元的文件名相同   




   




   




   ，包含大小写


  




  




  




。如果不匹配



 



 



 


，同样将得到编译错误  


  


  


。 虽然不是很常用               ，但编译单元内完全不带public类也是可能的   
     
     
     。在这种情况下    




    




    




   ，可以随意对文件命名



   




   




   



。

3

   

   

   

、当java源文件不存在public类时

















，会出现什么情况？

　　此时程序编译通过               ，在相应路径下产生了三个.class文件 



 



 



。直接点击运行     



     



     



   ，程序是不能运行的
















，我们需要鼠标右键点击程序----->Run As----->Java Aplication----->选数据来源

2.总结

一个编译单元（java文件）可以存在多个类
    
    
    
，在编译时产生多个不同的.class文件     


     


     


  ，.class文件便是程序运行的数据来源                  。java将public类作为每个编译单元的数据接口 




 




 




 
，只能有一个

   

   

   

，不然不能处理存在多个类的java文件




    




    




    


。当一个编译单元（java文件）有多个非public类时     

     

     

 ，运行时需要对数据来源进行选择














。

二     

     

     

 、在一个Java文件定义多个类（内部类）

在 Java 中  




  




  




  ，可以将一个类定义在另一个类里面或者一个方法里面


  


  


  


，这样的类称为内部类                  。广泛意义上的内部类一般来说包括这四种：成员内部类  




  




  




  、局部内部类


  


  


  


、匿名内部类和静态内部类



     



     



     

。其中成员内部类和匿名内部类比较常见















。

下面我将对成员内部类和匿名内部类进行专讲     
     
     
，其他内部类可参考链接：菜鸟教程-Java内部类详解    
    
    
  。

1.成员内部类和匿名内部类

1.1 成员内部类

先说结论：

成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员） 


     


     


     
。 虽然成员内部类可以无条件地访问外部类的成员   




   




   




   ，而外部类想访问成员内部类的成员却不是这么随心所欲了

 




 




 




。在外部类中如果要访问成员内部类的成员



 



 



 


，必须先创建一个成员内部类的对象               ，再通过指向这个对象的引用来访问   

   

   

 。

成员内部类是最普通的内部类    




    




    




   ，它的定义为位于另一个类的内部

















，形如下面的形式： class Circle { double radius = 0; public Circle(double radius) { this.radius = radius; } class Draw { //内部类 public void drawSahpe() { System.out.println("drawshape"); } } }

这样看起来               ，类Draw像是类Circle的一个成员     



     



     



   ，Circle称为外部类  

     

     

     。成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）


  




  




  




。

class Circle { private double radius = 0; public static int count =1; public Circle(double radius) { this.radius = radius; } class Draw { //内部类 public void drawSahpe() { System.out.println(radius); //外部类的private成员 System.out.println(count); //外部类的静态成员 } } }

不过要注意的是
















，当成员内部类拥有和外部类同名的成员变量或者方法时
    
    
    
，会发生隐藏现象     


     


     


  ，即默认情况下访问的是成员内部类的成员  


  


  


。如果要访问外部类的同名成员 




 




 




 
，需要以下面的形式进行访问：

外部类.this.成员变量 外部类.this.成员方法

虽然成员内部类可以无条件地访问外部类的成员

   

   

   

，而外部类想访问成员内部类的成员却不是这么随心所欲了   
     
     
     。在外部类中如果要访问成员内部类的成员     

     

     

 ，必须先创建一个成员内部类的对象  




  




  




  ，再通过指向这个对象的引用来访问：

class Circle { private double radius = 0; public Circle(double radius) { this.radius = radius; getDrawInstance().drawSahpe(); //必须先创建成员内部类的对象


  


  


  


，再进行访问 } private Draw getDrawInstance() { return new Draw(); } class Draw { //内部类 public void drawSahpe() { System.out.println(radius); //外部类的private成员 } } }

成员内部类是依附外部类而存在的     
     
     
，也就是说   




   




   




   ，如果要创建成员内部类的对象



 



 



 


，前提是必须存在一个外部类的对象



   




   




   



。创建成员内部类对象的一般方式如下：

public class Test { public static void main(String[] args) { //第一种方式： Outter outter = new Outter(); Outter.Inner inner = outter.new Inner(); //必须通过Outter对象来创建 //第二种方式： Outter.Inner inner1 = outter.getInnerInstance(); } } class Outter { private Inner inner = null; public Outter() { } public Inner getInnerInstance() { if(inner == null) inner = new Inner(); return inner; } class Inner { public Inner() { } } }

内部类可以拥有 private 访问权限     
     
     
、protected 访问权限   




   




   




   、public 访问权限及包访问权限 



 



 



。比如上面的例子               ，如果成员内部类 Inner 用 private 修饰    




    




    




   ，则只能在外部类的内部访问

















，如果用 public 修饰               ，则任何地方都能访问；如果用 protected 修饰     



     



     



   ，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限
















，则只能在同一个包下访问                  。这一点和外部类有一点不一样
    
    
    
，外部类只能被 public 和包访问两种权限修饰




    




    




    


。我个人是这么理解的     


     


     


  ，由于成员内部类看起来像是外部类的一个成员 




 




 




 
，所以可以像类的成员一样拥有多种权限修饰














。

1.2 匿名内部类

匿名内部类应该是平时我们编写代码时用得最多的

   

   

   

，在编写事件监听的代码时使用匿名内部类不但方便     

     

     

 ，而且使代码更加容易维护                  。下面这段代码是一段 Android 事件监听代码：

scan_bt.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub } }); history_bt.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub } });

这段代码为两个按钮设置监听器  




  




  




  ，这里面就使用了匿名内部类



     



     



     

。这段代码中的：

new OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub } }

就是匿名内部类的使用















。代码中需要给按钮设置监听器对象


  


  


  


，使用匿名内部类能够在实现父类或者接口中的方法情况下同时产生一个相应的对象     
     
     
，但是前提是这个父类或者接口必须先存在才能这样使用    
    
    
  。当然像下面这种写法也是可以的   




   




   




   ，跟上面使用匿名内部类达到效果相同 


     


     


     
。

private void setListener() { scan_bt.setOnClickListener(new Listener1()); history_bt.setOnClickListener(new Listener2()); } class Listener1 implements View.OnClickListener{ @Override public void onClick(View v) { // TODO Auto-generated method stub } } class Listener2 implements View.OnClickListener{ @Override public void onClick(View v) { // TODO Auto-generated method stub } }

这种写法虽然能达到一样的效果



 



 



 


，但是既冗长又难以维护               ，所以一般使用匿名内部类的方法来编写事件监听代码

 




 




 




。同样的    




    




    




   ，匿名内部类也是不能有访问修饰符和 static 修饰符的   

   

   

 。

匿名内部类是唯一一种没有构造器的类  

     

     

     。正因为其没有构造器

















，所以匿名内部类的使用范围非常有限               ，大部分匿名内部类用于接口回调


  




  




  




。匿名内部类在编译的时候由系统自动起名为 Outter$1.class  


  


  


。一般来说     



     



     



   ，匿名内部类用于继承其他类或是实现接口
















，并不需要增加额外的方法
    
    
    
，只是对继承方法的实现或是重写   
     
     
     。

2.深入理解内部类

1



 



 



 


、为什么成员内部类可以无条件访问外部类的成员？

3.内部类的使用场景和好处

为什么在 Java 中需要内部类？总结一下主要有以下四点：

每个内部类都能独立的继承一个接口的实现     


     


     


  ，所以无论外部类是否已经继承了某个(接口的)实现 




 




 




 
，对于内部类都没有影响



   




   




   



。内部类使得多继承的解决方案变得完整 



 



 



。 方便将存在一定逻辑关系的类组织在一起

   

   

   

，又可以对外界隐藏                  。 方便编写事件驱动程序




    




    




    


。 方便编写线程代码














。

个人觉得第一点是最重要的原因之一     

     

     

 ，内部类的存在使得Java的多继承机制变得更加完善                  。