Java：内部类的四种形式

内部类

• 成员内部类
• 局部内部类
• 静态内部类
• 匿名内部类

内部类可看做外部类的成员。外部类只能由public修饰或者默认包内访问
而内部类却可以用四种访问控制符以及static修饰

---

成员内部类

解释：除静态常量外没有静态内容且声明在类的成员区
外部类内容的访问权限：顾名思义 此时的内部类就相当于外部类的一个成员，因此可以访问外部类的所有内容
成员限制：除静态常量外，无静态内容

public class OuterClass {

    private int out;
    public static  final  int CONST = 5;

    private static  int getCONST(){
        return CONST;
    }
//成员内部类
    class InnerClass{

        private int out;//内部类变量与外部类变量重名
        private static final int test = 5;

        public int getOut(){
            System.out.println(OuterClass.this.out);//内部用out访问到的是内部变量，
            return out;//用  外部类名.this.变量名   访问外部变量
        }

        public int innerGetCONST(){
            return getCONST();
        }
    }
    InnerClass ic = new InnerClass();//外部类内制造成员内部类对象
    InnerClass p = this.new InnerClass();//实际通过this创建
}
//成员内部类是依附外部类而存在的，制造成员内部类的对象，必须存在一个外部类的对象
OutClass oc = new OutClass();
OutClass.InnerClass oi = oc.new InnerClass();
//方法二
OutClass.InnerClass oi = new OutClass().new InnerClass();

---

局部内部类

解释：作用域类似局部变量，只在当前代码块中有效的，只有在作用域内才能被实例化的内部类
外部类内容的访问权限：
如果在静态方法中：
可以访问外部类中所有静态成员，包含私有
如果在实例方法中：
可以访问外部类中所有的成员，包含私有
成员限制：局部内部类中不可定义静态变量

public class Outer {

    private int out;

    public void print(){
    //局部内部类
        class Inner{

            private int in;

            private final int tset=3;

            private int getIn(){
                return in;
            }
        }
        System.out.println(new Inner().getIn());//可以在外部类中直接制造局部内部类的对象
    }
}

---

静态内部类

解释：由static修饰的静态内部类类似静态变量/方法
可含有static修饰的方法
外部类内容访问权限：只可访问外部类的静态成员

实际上由static修饰后，此内部类已经与外部类的对象无关了，它是直接属于外部类的，可以认为是嵌套类，类名为 外部类名.内部类名 ，实际上就是一种外部类 这个特点在制造对象的方式中可见一斑

public class Out {
    private int out = 10;
//静态内部类
    static class In{
        private int inner = 5;
        private static int in = 6;

        public void setIn(int num){
            in = num;
        }
        public static int getIn(){
            return in;
        }
        public static  int getInner(){
            return new In().inner;
        }
    }

    In in = new In();//外部类内可直接使用
}//静态内部类的对象制造方式
//外部类名.内部类名 变量名 = new 外部类名.内部类名();

---

匿名内部类

解释：顾名思义，没有名字的内部类。。
没有class,interface,implements,extends关键字
没有构造器
一般隐式的继承某一个父类或者实现某一个接口，只使用一次

public class OutClass {

    private int out=1;

    public int getOut(OutClass oc){
        return  oc.out;
    }


    public static void main(String[] args) {
        System.out.println(new OutClass(){//由此开始  继承了OutClass类
            @Override//临时重写了getOut方法
            public int getOut(OutClass oc){
                return 10;
            }
        }/*匿名内部类自此结束*/.getOut(new OutClass())//调用这个该匿名内部类的getOut方法);
    }
}
//输出为10

2018/7/21