内部类大概有四种：

1.方法里面定义的局部内部类

2.成员变量级别的内部类

3.静态内部类

4.匿名内部类

应用:

1.方法内部的局部内部类


public void test(String str){ //已经不需要final修饰符了
        int i = 10; //Java 8更加智能：如果局部变量被匿名内部类访问，那么该局部变量相当于自动使用了final修饰。
        class testClass{
            //static int ss = 2; 非静态类不能有静态变量
            private int name = 10;
            void test(String s){
                System.out.println(name);
                System.out.println(s);
                System.out.println(i);
            }
        }

        new testClass().test(str);
    }
从上面的例程我们可以看出定义在方法内部的内部类的可见性更小，它只在方法内部
可见，在外部类(及外部类的其它方法中)中都不可见了。同时，它有一个特点，就是方法
内的内部类连本方法的成员变量都不可访问，它只能访问本方法的final型成员。同时另一个
需引起注意的是方法内部定义成员，只允许final修饰或不加修饰符，其它像static等均不可用。
用法还没找到经典的，猜测如下调用：
public interface FunClassInteface {
    String getRet();
    String getRetMsg();
}

public class FunClass {

    public FunClassInteface test2(){
        String str = "001";
        String str2 = "002";
        class FunCImpl implements FunClassInteface{
            @Override
            public String getRet() {
                return str;
            }
            @Override
            public String getRetMsg() {
                return str2;
            }
        }
        return new FunCImpl();
    }

    public static void main(String[] args) {
        FunClass funClass = new FunClass();
        funClass.test("123");

        FunClassInteface test2 = funClass.test2();
        System.out.println(test2.getRet());
        System.out.println(test2.getRetMsg());
    }
}

2.成员变量级别的内部类

java中的Iterate都是这种应用，写个Demo理解下：

//定义一个简单的迭代器接口
public interface MyIterate {
    Object next();
    boolean hasNext();
}


//简单的保存数据
public class MyList {

    int max = 0;

    private Object[] objects;

    public MyList(Object... objects) {
        this.objects = objects;
        max = objects.length;

    }

    public MyIterate getIterate(){
        return new MyIterateImpl();
    }

    //内部类实现迭代器
    private class MyIterateImpl implements MyIterate{
        private int i = 0;
        @Override
        public Object next() {
            return objects[i++];
        }

        @Override
        public boolean hasNext() {
            return i < max;
        }
    }
}


    //使用Demo
    public static void main(String[] args) {
        MyList myList = new MyList("你好","我好","大家好！");
        MyIterate myIterate = myList.getIterate();
        while(myIterate.hasNext()){
            System.out.println(myIterate.next());
        }
    }

3.静态内部类

感觉和正常的类差不多，除了不能有非静态变量 ，还没搞清楚



有可能为了更高的内部聚合，访问最严格性，HashEntry既然是一个工具类不需要访问

//ConcurrentHashMap的一些信息，使它的访问域最小就可以用上静态内部类
如果内部类不会引用到外部类东西的话，强烈建议使用静态内部类，因为这样更节省资源，
减少内部类其中的一个指向外部类的引用，详见 effective java

4.匿名内部类

众所周知，匿名内部类的作用一般在java8之前进行回调，比如说：

File file = new File("xxx");
        file.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return ".xml".equals(name);
            }
        });

3.