java内部类详解

前言

内部类本人感觉不太常见，但是遇到时候就会产生很多疑问。但是遇到时候往往都是在比教奇怪的地方遇到。并且有些奇怪的特性。这里我大概总结下具体特点。

特点

这里我主要分成三个种类来说明：非匿名内部类，匿名内部类，静态内部类。

1、匿名内部类：

匿名内部类。匿名内部类在android开发中各种监听时间的处理都是通过匿名内部类实现的，他们节省代码，一定意义上是是代码更加简洁。例如：

Button button = new Button(this);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //监听处理动作
            }
        });

这里需要注意如果需要在匿名内部类中引用外部对象，需要必须是final，（这里解释下，匿名内部类大部分是作为函数参数或者返回值来使用的。他们在自己的作用域不是全局性质的。如果可以使用外部对象，就有可能拥有一个不存在的对象的句柄,这样做是危险的，如果是final的话，可以直接复制一份，避免这种问题），主要是用在return语句与函数参数中。

2、非匿名内部类：

非匿名内部类这里主要是用来解决较大的问题。主要是框架上的问题，和特殊结构问题。可以存在方法块中或者类域中。大部分来说在方法块中非常少见。例如：

public class getcode {
    public interface Code{
        public void code();
    }
    int person = 0；
    private class CodeJava implements Code{

        @Override
        public void code() {
            System.out.print("code java");
        }
    }

    private class CodeCpp implements Code{

        @Override
        public void code() {
            System.out.print("code c++"+">>>you have:"+ ++person+"to code");
        }
    }
    public Code getcoder(String code){
        if (code == "c++"){
            return new CodeCpp();
        }else if (code == "java"+">>>you have:"+ ++person+"to code"){
            return new CodeJava();
        }else return null;
    }
}

这里是一个简单的工厂方法。主要是对内部类的封装，这里说明下内部类可以拥有外部类的句柄。具体作用下一节讲解

3、静态内部类

1. 为创建一个 static内部类的对象，我们不需要一个外部类对象。
2. 不能从 static内部类的一个对象中访问一个外部类对象。
   这里有些需要注意。静态内部类需要实例化。并且可以实例化多个，这是个比较奇怪的地方。静态内部类是一个不依赖与外部类可以存在的类。我感觉他的雨普通类没有太大差别。你可以通过
   java
new Parent.Inner() //.Inner 是parent的内部类

   获取一个静态内部类。其实我感觉这和纯粹声明一个类没有太大区别（可以封装，不用创建很多文件目前我能想到的一点作用）

主要作用

这三种内部类都有它的作用在解决自己的问题方面有很多作用

1. 匿名内部类

节省代码。逻辑清晰

2. 非匿名内部类

这里我们当然立马看到的是对代码的封装与实现的隐藏。但是我在书上看到说是对于框架的构建很有帮助。我对于这部分理解不是很透彻。引用《thinking in java》

abstract class Event {
    private long evtTime;
    public Event(long eventTime) {
        evtTime = eventTime;
    }
    public boolean ready() {
        return System.currentTimeMillis() >= evtTime;
    }
    abstract public void action();
    abstract public String description();
} 

class EventSet {
    private Event[] events = new Event[100];
    private int index = 0;
    private int next = 0;
    public void add(Event e) {
        if(index >= events.length)
            return; // (In real life, throw exception)
        events[index++] = e;
    }
    public Event getNext() {
        boolean looped = false;
        int start = next;
        do {
            next = (next + 1) % events.length;
// See if it has looped to the beginning:
            if(start == next) looped = true;
// If it loops past start, the list
// is empty:

            if((next == (start + 1) % events.length)
                    && looped)
                return null;
        } while(events[next] == null);
        return events[next];
    }
    public void removeCurrent() {
        events[next] = null;
    }
}
public class Controller {
    private EventSet es = new EventSet();
    public void addEvent(Event c) { es.add(c); }
    public void run() {
        Event e;
        while((e = es.getNext()) != null) {
            if(e.ready()) {
                e.action();
                System.out.println(e.description());
                es.removeCurrent();
            }
        }
    }
}

(1) 在单独一个类里表达一个控制框架应用的全部实施细节，从而完整地封装与那个实施有关的所有东西。内部类用于表达多种不同类型的action()，它们用于解决实际的问题。除此以外，后续的例子使用了private内部类，所以实施细节会完全隐藏起来，可以安全地修改。
(2) 内部类使我们具体的实施变得更加巧妙，因为能方便地访问外部类的任何成员。若不具备这种能力，代码看起来就可能没那么使人舒服，最后不得不寻找其他方法解决。

感觉还是为了面向编程的的七大编程思想而服务的。主要是为了框架，具体编程的使用例如diolog的dialog的内部builder类。这种使用内部类实现了特殊的工厂模式，对于框架成很有帮助。

3. 静态内部类

这个感觉唯一的作用是封装。代码更加内敛。如
thread

public class Handler {
......
    private static final class BlockingRunnable implements Runnable {
     ......
    }
}

这里通过内部类是代码更加简单。逻辑更加清晰。

总结

这里每种定西我们都子啊思考他的作用。当他没有作用。就不应该存在。其实这里内部类主要还是对代码的封装和框架的帮助。
非匿名内部类主要是为了构成框架，便于代码封装
静态内部类主要是为了代码的封装。