概述
内部类是定义在另一个类中的类。使用原因如下:
内部类可以访问该类定义所在的作用域中的数据,包括私有数据
内部类可以对同一包中的其它类隐藏
当想要定义一个回调函数且不想编写大量代码时,使用匿名内部类比较便捷
使用内部类访问对象状态
内部类既可以访问自身的数据域,还可以访问创建它的外围类对象的数据域。例
public class TalkingClock
{
private int interval;
private boolean beep;
public TalkingClock(int interval,boolean beep){...}
public void start(){...}
public class TimerPrinter implments ActionListerner
{
public void actionPerformed(ActionEvent event)
{
System.out.println("At the tone , the time is"+ new Date());
if(beep) Toolkit.getDefaultToolkit().beep();
}
}
}
为了运行这个程序,内部类的对象总有一个隐式引用,它指向创建它的外部类对象。为了说明这个概念,我们将外围类对象的引用称为outer。则actionPerformed等价于
public void actionPerformed(ActionEvent event)
{
System.out.println("At the tone , the time is"+ new Date());
if(outer.beep) Toolkit.getDefaultToolkot().beep();
}
innerClass/InnerClassTest.java
package innerClass;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;
import javax.swing.JOptionPane;
import javax.swing.Timer;
public class InnerClassTest {
public static void main(String[] args)
{
TalkingClock clock=new TalkingClock(1000,true);
clock.start();
JOptionPane.showMessageDialog(null, "Quit program?");
System.exit(0);
}
}
class TalkingClock
{
private int interval;
private boolean beep;
public TalkingClock(int interval,boolean beep){
this.interval=interval;
this.beep=beep;
}
public void start(){
ActionListener listener=new TimePrinter();
Timer t=new Timer(interval,listener);
t.start();
}
public class TimePrinter implements ActionListener
{
public void actionPerformed(ActionEvent event)
{
System.out.println("At the tone , the time is"+ new Date());
if(beep) Toolkit.getDefaultToolkit().beep();
}
}
}
内部类的特殊语法规则
使用外部类引用的正规语法规则:
outerClass.this //外部类引用
在外围类之外的作用域,可以这样引用内部类:
OuterClass.InnerClass
注释
内部类声明的所有静态域都必须是final。原因很简单。我们希望一个静态域只有一个实例,不过对于每个外部对象,会分别有一个单独的内部类实例。如果这个域不是final,他就可能不是唯一的。
局部内部类
局部类不能用public或private访问说明符进行声明。它的作用域被限定在声明这个局部类的块中。
局部类有一个优势,即对外部世界可以完全隐藏起来。
由外部方法访问变量
与其他内部类相比,局部类还有另一个优势,它们不仅能够访问包含它们的外部类,还可以访问局部变量。不过,那些局部变量必须是事实上为final。说明,他们一旦赋值就绝不能改变。
匿名内部类
假如只创建这个类的一个对象,就不必命名了。这种类被称为匿名内部类。
通常的语法格式为:
new SuperType(Construction paratmeters)
{
inner class methods and data
}
例
public void start(int interval,boolean beep)
{
ActionListener listener=new ActionListener()
{
public void actionPerformed(ActionEvent event)
{
System.out.println("At the tone, the time is "+ new Date());
if(beep) Toolkit.getDafaultToolkit().beep();
}
};
Timer t=new Timer(interval,listener);
t.start();
}
由于构造器的名字必须与类名相同,而且匿名类没有类名,所以,匿名类不能有构造器。取而代之的是,将构造器参数传递给超类构造器。尤其是在内部类实现接口的时候,不能有任何构造参数。
如果构造参数的小括号后面跟一个大括号,正在定义的就是匿名内部类。
注释:双括号初始化假设你想构造一个数组列表,并将它传递到一个方法:
ArrayList<String> friends=new ArrayList<>();
friends.add("Harry");
friends.add("Tony");
invite(friends);
//如果不再需要这个数组列表,最好让它作为一个匿名列表。不过作为一个匿名列表,该如何添加元素呢?方法如下:
invite(ArrayList<String>(){{add("Harry"),add("Tony");}});
//注意这里的双括号。外层括号建立了一个ArrayList的匿名内部类。内层括号则是一个对象构造块。
静态内部类
使用内部类只是为了把一个类隐藏在另外一个类的内部,并不需要内部类引用外部类对象。为此,可以把内部类声明为static,以便取消产生的引用。
注释
与常规内部类不同,静态内部类可以有静态域和方法。
声明在接口中的内部类自动称为static和public 类。
package staticInnerClass;
public class StaticInnerClassTest {
public static void main(String[] args)
{
double[] d=new double[20];
for(int i=0;i<20;i++)
d[i]=Math.random()*100;
ArrayAlg.Pair p= ArrayAlg.minmax(d);
System.out.println("min="+p.getFirst());
System.out.println("max="+p.getSecond());
}
}
class ArrayAlg
{
public static class Pair
{
private double first;
private double second;
public Pair(double f,double s)
{
first=f;
second=s;
}
public double getFirst()
{
return first;
}
public double getSecond()
{
return second;
}
}
public static Pair minmax(double[] values)
{
double min=Double.POSITIVE_INFINITY;
double max=Double.NEGATIVE_INFINITY;
for(double v:values)
{
if(v<min) min=v;
if(v>max) max=v;
}
return new Pair(min,max);
}
}