内部类

1.内部类的定义：被定义在另一个类中的类。

2.使用内部类的原因：
(1)内部类可以访问它的外层作用域，即便是私有的数据也可以访问。
(2)内部类可以对同一个包中的其他类隐藏起来。
(3)如果想写一个回调函数，为了便捷可以使用匿名内部类。

3.使用内部类访问对象状态：

package com.wp;

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;

public class InnerClassTest {
    public static void main(String[] args) {
        //TalkingClock clock = 
    }
}

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) {
            Date now = new Date();
            System.out.println("At the tone, the time is " + now);
            if(beep) {
                Toolkit.getDefaultToolkit().beep();
            }
        }
    }
}

4.内部类的特殊语法规则：
(1)外部类引用：OuterClass.this
(2)编写内部对象的构造器：outerObject.new InnerClass(construction parameters)。例如：ActionListener listener = new TimePrinter();
(3)内部类引用：OuterClass.InnerClass。

5.局部内部类，不能用public或private声明。作用域在声明这个局部类的块中，对外部世界完全隐藏。

6.由外部方法访问final变量：
(1)局部类不仅可以访问包含它的外部类，还可以访问局部变量(局部变量必须声明为final)。
(2)final可以用于局部变量，实例变量和静态变量。是指在创建该变量之后，就只能赋一次值，不能再修改了。
(3)在定义final变量时，不用初始化。

package com.jsq;

import java.util.Date;

public class JsqTest {
    public static void main(String[] args) {
        final int[] counter = new int[1];
        Date[] dates = new Date[100];
        for(int i = 0; i < dates.length; i ++) 
            dates[i] = new Date(){
            public int compareTo(Date other) {
                counter[0] ++;
                return super.compareTo(other);
            }
        };
        System.out.println(dates);
        System.out.println(counter);
    }
}

7.匿名内部类：
(1)只创建这个类的一个对象的局部内部类就不用命名，就称为匿名内部类。
(2)用于构造对象的任何参数都要被放在超类名后面的括号()内，语法：

new SuperType(construction parameters) {
    innner class methods and data
}

(3)构造器名字必须要与类名相同，匿名内部类没有类名，所以匿名内部类也就没有构造器，取而代之的是，将构造器的参数传递给父类构造器。尤其是在内部类实现接口的时候，不能有任何的参数。

package com.anonymous;

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;

public class AnnoymousInnerClassTest {
    public static void main(String[] args) {

    }
}

class TalkingClock {
    public void start(int interval, final boolean beep) {
        ActionListener listener = new 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();
                }
            }
        };
        Timer t = new Timer(interval, listener);
        t.start();
    }
}

8.静态内部类：
(1)有些内部类只是为了把一个类隐藏在另一个类的内部，并不需要内部类引用外部类的对象。这时可以用静态内部类，也就是将内部类声明为static。
(2)只有内部类可以声明为static。静态内部类与普通内部类的区别就是对外部类不用访问，仅此而已。
(3)声明在接口中的内部类自动生成为public static。

package com.staticInner;

public class StaticInnerClassTest {
    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);
            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.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);
    }
}

9.代理：
(1)代理可以在运行时创建一个实现了一组给定接口的新类。
(2)代理只有在编译时无法确定需要实现哪个接口时才使用。
(3)代理类可以在运行时创建全新的类。这样的代理类能够实现全新的接口。它具有以下方法：
1)可以指定接口所需要的全部方法。
2)有Object类的全部方法，但是不能再运行时定义这些方法的新待代码，是要提供一个调用处理器，即就是 invocation handler。调用处理器是实现了InvocationHandle接口的类对象，而在这个接口中只有一个方法：Object invoke(Object proxy, Method method, Object[] args)。无论何时调用代理对象的方法，调用处理器的invoke方法都会被调用，并向其传递Method对象和原始参数，调用处理器必须给出处理调用的方式。
3)创建一个代理对象，要用Proxy类的newProxyInstance方法，该方法有三个参数：
a.一个类加载器(class loader)，用null表示默认的类加载器。
b.一个Class对象数组，每个元素都是需要实现的接口。
c.一个调用处理器。

package com.proxy;

import java.lang.reflect.*;
import java.util.*;

public class ProxyTest {
    public static void main(String[] args) {
        Object[] elements = new Object[1000];

        for(int i = 0;i < elements.length; i ++) {
            Integer value = i + 1;
            InvocationHandler handler = new TraceHandler(value);
            Object proxy = Proxy.newProxyInstance(null, new Class[] {Comparable.class}, handler);
            elements[i] = proxy;
        }

        Integer key = new Random().nextInt(elements.length) + 1;
        int result = Arrays.binarySearch(elements, key);

        if(result >= 0) {
            System.out.println(elements[result]);
        }
    }
}

class TraceHandler implements InvocationHandler{

    private Object target;

    public TraceHandler(Object t){
        target = t;
    }

    public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
        System.out.print(target);
        System.out.print("." + m.getName() + "+ ( +");

        if(args != null) {
            for(int i = 0; i < args.length; i ++) {
                System.out.print(args[i]);
                if(i < args.length - 1) {
                    System.out.print(",");
                }
            }
        }
        System.out.println(")");
        return m.invoke(target, args);
    }
}

(4)代理的特性：
1)代理是在程序运行过程中创建的。创建成功后，就与普通类一样了。
2)所有的代理类都扩展与Proxy类，一个代理类只有一个实例域（调用处理器），它被定义在Proxy的父类中，所需要的任何处理器都必须存储在调用处理器中。
3)对于特定的类加载器和预设的一组接口来说，只能有一个代理。
4)代理类一定是public和final。
5)如果代理类实现所有的接口，则代理类就不属于某个特定的类；否则，所有非公有的接口都必须属于同一个包，而代理类也属于这个包。
6)可以通过Proxy类中的isProxyClass方法检测一个特定的Class对象是否属于一个代理类。