java内部类的理解
在java的code过程中，常会面对内部类的使用，在此根据自己理解，对内部类做一总结，方便学习。高手轻拍。
内部类顾名思义，就是定义在其它类内部的类，在这里内部类有两种区分：在其它类的内部；在其它类的方法的内部。
内部类使用主要基于以下三点：
1）通过内部类可以直接访问该类所定义的作用域中的数据，包括private数据。
2）通过添加private访问符或local inner class，将内部类对同一包中其它类隐藏起来。
3）定义回调函数。
一：inner class
格式
class A {
class B {
....
}
}
例子：
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;
import static java.lang.System.out;
public class InnerClassTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
TalkingClock clock = new TalkingClock(1000, true);
clock.start();
TalkingClock.TimerPrinter t = clock.new TimerPrinter();
JOptionPane.showMessageDialog(null, "Quit program?");
System.exit(0);
}
}
/**
* descr:inner class
* */
class TalkingClock {
public TalkingClock(int interval, boolean beep) {
this.interval = interval;
this.beep = beep;
}
/**
* descr:inner class. if the inner class with private,
* */
public void start() {
ActionListener listener = this.new TimerPrinter();
Timer t = new Timer(this.interval, listener);
t.start();
/*
TalkingClockII t = new TalkingClockII();
t.start(1000, true);
*/
}
/**
* descr:if inner class declared with private, the inner class is only used
* by outter class. any class couldn't used it,even if it is in the same
* package.
* */
class TimerPrinter implements ActionListener {
public TimerPrinter() {
}
public TimerPrinter(int interval, boolean beep) {
this.beep = beep;
}
public void actionPerformed(ActionEvent ev) {
Date now = new Date();
System.out.println("At the tone, the time is " + now);
if (TalkingClock.this.beep) {
Toolkit.getDefaultToolkit().beep();
}
}
private boolean beep;
}
private int interval;
private boolean beep;
}
可以看到TimerPrinter作为内部类。当access specifier为default时，TimerPrinter为包访问权限，为public时，为公共访问权限，但TimerPrinter要根据Outter类来决定是否可被外包函数访问。当为private时，只可被Outter访问。
二：local inner class
格式:
class A{
method(para1, para2,...) {
class B{
...
}
}
}
例子：
/**
* descr:local inner class.
* */
class TalkingClockII {
public TalkingClockII() {
}
public void start(int interval, final boolean beep) {
/**
* descr:local inner class are never declared with an access
* specifier(private, public or default).
* */
class TimerPrinterI implements ActionListener {
public void actionPerformed(ActionEvent ae) {
Date now = new Date();
out.println("At the tone, the time is " + now);
if (beep) {
Toolkit.getDefaultToolkit().beep();
}
}
}
//local innner class only konwed in start method.
//ActionListener listener = new TimerPrinterI();
//Timer t = new Timer(this.interval, listener);
Timer t = new Timer(interval, new TimerPrinterI());
t.start();
}
}
TimerPrinterI作为局部内部类，不能用private、public、protected等修饰符来生命，local inner class的作用域被限定到生命该局部类的块中，这样使得TimerPrinterI类完全对外界隐藏，只有包含它的start方法知道其存在，即使是Outter class TalkingClockI都不知道TimerPrinterI的存在。
三：匿名内部类
格式：
class A {
method1() {
class B = new B(para1, para2,...) {
...
};
}
method2() {
interface C = new C() {
....
};
}
}
例子：
class TalkingClockIII {
public void runImplements() {
IWrite w = new IWrite() {
public void write(boolean flag) {
if (flag) {
out.println("anonymous inner class.");
}
}
};
w.write(true);
}
public void runExtends(boolean flag) {
TestWrite t = new TestWrite(flag) {
public void test() {
out.println("flag is " + flag);
}
};
t.test();
}
}
匿名内部类中，如果匿名类继承的是interface，则不可带参数；如果继承的是class，则可带参数。