java之内部类

概述

内部类是定义在另一个类中的类。使用原因如下：
内部类可以访问该类定义所在的作用域中的数据，包括私有数据
内部类可以对同一包中的其它类隐藏
当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷

使用内部类访问对象状态

内部类既可以访问自身的数据域，还可以访问创建它的外围类对象的数据域。例

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);
	 }
	 
 }