6.4 内部类

 内部类：定义在一个类中的类。

为什么要用内部类：

1）内部类可以访问其外围类的实例域，包括私有数据。

2）内部类可以对同包中的其他类隐藏。

3）定义一个回调函数，使用匿名内部类要便捷。

6.4.1 使用内部类访问对象的状态

实例：一个TimePrinter常规类，他需要通过TalkingClock类的共有方法访问beep标志。

注释：TimePrinter类被声明为私有的，这样只有TalkingClock的方法才能生成TimePrinter对象。内部类可以是私有类，常规类只能是包可见性或公有可见性。

例6-4源代码：

package com.corejava.innerclass;

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;
/**
 *
 * @author vincent
 *
 */
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 {

        @Override
        public void actionPerformed(ActionEvent e) {
            // TODO Auto-generated method stub
            Date now = new Date();
            System.out.println("At the tone, the time is " + now);
            if(beep)
                Toolkit.getDefaultToolkit().beep();
        }

    }
}

6.4.4局部内部类

使用背景：创建一个类的对象只需使用一次时，推荐使用局部内部类。例如上述代码中TimerPrinter这个类只在start方法中创建了对象并只使用了一次，这时可将TimerPrinter创建为局部内部类：

public void start() {
    class TimerPrinter implements ActionListener {
        public void actionPerformed(ActionEvent event) {
            Date now = new Date();
            System.out.println("At the tone, the time is " + now);
            if(beep)
                Toolkit.getDefaultToolkit().beep();
        }
    }

    ActionListener listener = new TimerPrinter();
    Timer t = new Timer(interval, listener);
    t.start();
}

注意：局部内部类不能用public或private声明，它的作用域被限定在声明这个局部类的块中；

局部类的好处是对外完全隐藏，即使TalkingClock类中的其他代码也不能访问它，除了start方法外，没有任何方法知道TimerPrinter类的存在。

局部类还有一个优点：除了能访问包含它的外部类，还能访问局部变量，不过这些局部变量必须被声明为final。

6.4.5由外部方法访问final变量

典型示例：将TalkingClock构造器的参数interval和beep移至start方法中。

public void start(int interval, final boolean beep) {
    class TimerPrinter implements ActionListener {
        public void actionPerformed(ActionEvent event) {
            Date now = new Date();
            System.out.println("At the tone, the time is " + now);
            if(beep)
                Toolkit.getDefaultToolkit().beep();
        }
    }

    ActionListener listener = new TimerPrinter();
    Timer t = new Timer(interval, listener);
    t.start();
}

6.4.6匿名内部类

1、将局部内部类深入，若只创建这个类的一个对象，就不用命名了。这种类就是匿名内部类。

小程序：

public void start(int interval, final boolean beep) {

ActiongListener listener = new ActionListener() {

public void actionPerformed(ActionEvent event) {

Date now = new Date();

System.out.println("At the tone, time is " + now);

if(beep)

Toolkit.getDefultToolkit().beep();

}

};

Timer t = new Timer(interval, listener);

t.start();

}

代码解析：创建了一个实现ActiongListener接口的类的新对象，这个新对象需要实现actionPerformed所定义的方法。

2、构造器的名字必须和类名相同，但是匿名类没有类名，所以匿名类没有构造器。取而代之的是将构造器的参数传递给超类（父类）构造器。尤其是内部类实现接口是不能有任何构造参数，而且还要提供一组括号，例如：

new InterfaceType() {

    methods and data;

}

3、构造一个类的新对象共和构造一个匿名类的区别：

Person queen = new Person("Mary");    //a Person object

Person count = new Person() {....};   //an object of an inner class extending Person

如果构造参数的闭源括号跟一个开花括号，表示正在定义的就是匿名内部类 

例6-5源代码：将这个程序与之前的6-4相比较会发现匿名类的解决方案比较简单、实际和易于理解

package com.core.anonymousinnerclass;

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;

/**
 *
 * @author vincent
 *
 */
public class AnonymousInnerClass {

    public static void main(String[] args) {
        TalkingClock clock = new TalkingClock();
        clock.start(1000, true);

        //keep progra running until user selects "OK"
        JOptionPane.showMessageDialog(null, "Quit program?");
        System.exit(0);
    }
}

class TalkingClock {
    public void start(int interval, final boolean beep) {
        ActionListener listener = new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                // TODO Auto-generated method stub
                Date now = new Date();
                System.out.println("At the tone, time is: " + now);
                if(beep)
                    Toolkit.getDefaultToolkit().beep();
            }

        };
        Timer t = new Timer(interval, listener);
        t.start();
    }
}

6.4.7静态内部类

使用背景：只需要将一个类隐藏在另一个类的内部，并不需要内部类引用外围类对象时。

只有内部类可以声明为static，静态类除了不能生产外围类对象的引用外，与其他内部类一样。

例6-6

package com.core.staticinnerclass;

/**
 *
 * @author vincent
 *
 */
public class StaticInnerClass {

    public static void main(String[] args) {
        double[] d = new double[20];
        for (int i = 0; i < d.length; i++)
            d[i] = 100 * Math.random();

        ArrayAlg.Pair p = ArrayAlg.minmax(d);   //不需要用new生成对象，静态方法可以直接引用

        System.out.println("min = " + p.getFirst());
        System.out.println("max = " + p.getSecond());
    }

}

    class ArrayAlg {

        //A pair of floating-point numbers
        public static class Pair {

            private double first;
            private double second;

            //Constructs a pair from two floating-point numbers
            public Pair(double f, double s) {
                first = f;
                second = s;
            }

            //Returns the first numbers of the pair
            public double getFirst() {
                return first;
            }

            //Return the second numbers of the pair
            public double getSecond() {
                return second;
            }
        }

        //minmax方法返回 Pair这个静态内部类
        public static Pair minmax(double[] values) {

            double min = Double.MAX_VALUE;
            double max = Double.MIN_VALUE;

            for (double v : values) {
                if (min > v)
                    min = v;
                if (max < v)
                    max = v;
            }
            return new Pair(min, max);
        }

    }