1-15内部类

内部类的分类

内部类，顾名思义就是在一个类的内部声明一个类。内部类主要分为：

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

内部类的特点：

内部类可以直接访问外部类的成员，包括private修饰的变量和方法

在编写swing程序时内部类出现的频率比较高，不过目前大部分软件公司基本都不会使用swing，所以本节内容简单了解即可。

静态内部类

1.静态内部类可以等同看做静态变量
2.静态内部类可以直接访问外部类的静态数据

public class OuterClass{

    //静态变量
    private static String s1 = "A";

    //成员变量
    private String s2 = "B";

    //静态方法
    private static void m1(){
        System.out.println("静态方法m1");
    }

    //成员方法
    private void m2(){
        System.out.println("m2方法");
    }

    //静态内部类
    //可以用访问控制权限的修饰符修饰。
    //public,protected,private,缺省
    static class InnerClass{

        //静态方法
        public static void m3(){
            System.out.println(s1);
            m1();
        }

        //成员方法
        public void m4(){
            System.out.println(s1);
            m1();
        }
    }


    public static void main(String[] args){

        //执行m3
        OuterClass.InnerClass.m3();

        //执行m4
        InnerClass inner = new OuterClass.InnerClass();
        inner.m4();

    }

}

成员内部类

1.成员内部类可以等同看做成员变量
2.成员内部类中不能有静态声明
3.成员内部类可以访问外部类所有的数据

public class OuterClass{

    //静态变量
    private static String s1 = "A";

    //成员变量
    private String s2 = "B";

    //静态方法
    private static void m1(){
        System.out.println("静态方法m1");
    }

    //成员方法
    private void m2(){
        System.out.println("m2方法");
    }

    //成员内部类
    //可以用访问控制权限的修饰符修饰。
    //public,protected,private,缺省
    class InnerClass{

        //静态方法
        //public static void m3(){}

        //成员方法
        public void m4(){
            System.out.println(s1);
            m1();

            System.out.println(s2);
            m2();
        }
    }

    public static void main(String[] args){

        //创建外部类对象
        OuterClass oc = new OuterClass();

        InnerClass inner = oc.new InnerClass();

        inner.m4();

    }

}

匿名内部类

一个没有名字的类就叫做匿名内部类

public class Test{

    //静态方法
    public static void m1(Animal a){
        a.eat();
    }

    //入口
    public static void main(String[] args){


        //使用匿名内部类的方式执行m1方法
        //整个这个"new Animal(){}"就是个匿名内部类
        m1(new Animal(){
            public void eat(){
                System.out.println("吃猫粮");
            }
        });

        //匿名内部类的优点：少定义一个类.
        //缺点：无法重复使用!
    }

}


//接口
interface Animal{


    void eat();

}

局部内部类

局部内部类在访问局部变量的时候，局部变量必须使用final修饰，在JDK8之后，这个限制被取消了

public class OuterClass{

    //方法
    public void m1(){

        //局部变量
        final int i = 10;

        //局部内部类
        //局部内部类不能用访问控制权限修饰符修饰。
        class InnerClass{

            //内部类不能有静态声明
            //public static void m1(){}

            //成员方法
            public void m2(){
                System.out.println(i); // 10
            }

        }

        //调用m2
        InnerClass inner = new InnerClass();
        inner.m2();

    }


    public static void main(String[] args){
        OuterClass oc = new OuterClass();
        oc.m1();

    }

}