深挖java内部类

前言

一个Java类包括什么构造器、块、变量、方法、内部类。我们很多时候忘记了内部类。

为什么需要内部类

将只在一个地方使用的类进行逻辑分组，增加了封装性，可读性，可维护性。

1. 每个内部类都能独立的继承一个(接口的)实现,外部类是否继承这个接口都不影响内部类。

内部类可以有多个实例，每个实例独有自己的状态信息，与外部类对象的信息相互独立。例如迭代器

2. 如果拥有的是抽象类或具体的类，而不是接口，那就只能使用内部类才能实现多重继承，有几个类就要多少个内部类。

内部类分类

public class OuterClass {
    private  int count = 0;

    /**
     *成员内部类
     */
    class MemberInnerClass implements Counter {
        static int b;
        MemberInnerClass() {
            // Local inner class can have a constructor
            System.out.println("MemberInnerClass()");
        }

        @Override
        public int next() {
            return ++b;
        }

        public static void hah() {
            System.out.println("我是静态方法");
        }
    }

    /**
     * 局部内部类
     * @param name
     * @return
     */
    Counter getCounter(String name) {
        // A local inner class:
         class LocalInnerClass implements Counter {
             LocalInnerClass() {
                // Local inner class can have a constructor
                System.out.println("LocalInnerClass()");
            }
            @Override
            public int next() {
                System.out.print(name); // Access local final
                return count++;
            }
        }
        return new LocalInnerClass();
    }

    /**
     * 静态内部类
     */
    static class StaticInnerClass implements Counter {
        int owncount;
        StaticInnerClass() {
            // Local inner class can have a constructor
            System.out.println("StaticInnerClass()");
        }
        public void ph(OuterClass out){
            owncount = out.count;
            next();
        }
        @Override
        public int next() {
            return owncount++;
        }
    }
    /**
     * 匿名内部类
     * @param
     */
    Counter getCounter2(String name) {
        return new Counter() {
            // Anonymous inner class cannot have a named
            // constructor, only an instance initializer:
            {
                System.out.println("AnonymousInnerClass()");
            }
            @Override
            public int next() {
                System.out.print(name); // Access local final
                return count++;
            }
        };
    }

    public  void instance(String[] args) {
        //成员内部类
        MemberInnerClass mc = new MemberInnerClass();
        OuterClass.MemberInnerClass mc1 = new OuterClass.MemberInnerClass();
        MemberInnerClass mc2 = this.new MemberInnerClass();
        //局部内部类
        LocalInnerClass lc = new LocalInnerClass();
        OuterClass.LocalInnerClass lc1 = new OuterClass.LocalInnerClass();
        //静态内部类
        StaticInnerClass cl = new StaticInnerClass();
        OuterClass.StaticInnerClass cl1 = new OuterClass.StaticInnerClass();
    }
}

创建内部类对象

参考