高级特性（局部内部类及应用）

一、局部内部类特点：

    1.定义在代码块、方法体内的类叫局部内部类。

    2.局部内部类访问外部类的属性和方法使用"外部类名.this.属性名"和"外部类名.this.方法名(参数)"的形式。

    3.对外部世界完全隐藏，只能在其作用域内（方法内）生成对象。

二、局部内部类有以下限制：

    1.局部内部类不能加访问修饰符，因为它们不是类成员。

    2.成员内部类不能与外部类重名。

    3.局部内部类访问作用域内的局部变量，该局部变量需要使用final修饰。

public class LocalInnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.showOuter();
    }
}

class Outer{
    
    private String name = "test";
    
    private int num1 = 10;
    
    private static int num2 = 20;
    
    public void showOuter() {
        
        final int num4 = 50;
        
        class Inner {
            
            private int num3 = 30;
            
            private int num1 = 20;
            
            public void showInner() {
                System.out.println(num1);
                System.out.println(Outer.this.num1);
                System.out.println(Outer.num2);
                // 局部内部类只能访问声明其方法中的常量
                System.out.println(num4);
            }
        }
        
        Inner inner = new Inner();
        inner.showInner();
    }
    
}

     局部内部类的生命周期很短，其它外部的类是没办法构建局部内部类对象的，而局部内部类对象只能在其声明的方法里面进行构造，当方法运行完，这个局部类对象也就释放了。

    Java当中的四个内部类，其中成员内部类和匿名内部类用的相对比较多一点，静态内部类在源代码的设计中会经常看到，局部内部类用的很少。

---

案例讲解（使用内部类开发一个存放数据的容器）

1.案例介绍：开发一个容器用来存放键值对（键存放英文名字，值存放中文名字），对键值对使用内部类来进行封装。

2.案例设计：使用静态内部类封装键值对数据。容器默认容量是5，超过就扩容其2倍。通过调用entryArrays方法返回容器中的数据。

public class LocalInnerClass {
    public static void main(String[] args) {
        MyContainer myContainer = new MyContainer();
        myContainer.put("jack", "乘号");
        myContainer.put("jay", "周婕纶");
        myContainer.put("rose", "玫瑰");
        
        Entry[] entryArrays = myContainer.entryArrays();
        for (Entry entry : entryArrays) {
            System.out.println(entry.getKey() + "----" + entry.getValue());
        }
    }
}

class MyContainer{
    // 存放Entry对象的数组，默认大小为5
    private Entry[] entrys = new Entry[5];
    // 数组下标
    private int count = 0;
    
    /**
     * 对外提供一个接口，向容器中存放封装好的数据（Entry对象）
     * @param key
     * @param value
     */
    public void put(String key, String value){
        Entry entry = new Entry();
        entry.setKey(key);
        entry.setValue(value);
        // 存放Entry对象到数组中
        entrys[count++] = entry;
        // 数组扩容
        if (count >= entrys.length) {
            // 扩容后新数组的大小
            int newCapacity = entrys.length * 2;
            entrys = Arrays.copyOf(entrys, newCapacity);
        }
    }
    
    /**
     * 返回容器中的数据。
     * @return
     */
    public Entry[] entryArrays() {
        return Arrays.copyOfRange(entrys, 0, count);
    }
    
    /**
     * 内部类在程序设计的领域可以用作对数据的封装。
     */
    public static class Entry {
        
        private String key = "";
        
        private String value = "";

        public String getKey() {
            return key;
        }

        public void setKey(String key) {
            this.key = key;
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }       
    }
}