第十八节（内部类（实例，静态，局部，匿名））

在一个类的内部定义的类，称为内部类

内部类主要分类：

1. 实例内部类

2. 局部内部类

3. 静态内部类

实例内部类 ：

1.  创建实例内部类，外部类的实例必须已经创建

2. 实例内部类会持有外部类的引用

3. 实例内部不能定义 static 成员，只能定义实例成员

静态内部类

匿名内部类

/*
    内部类： 实例内部类（成员内部类）

        1. 成员内部类可以等同看做成员变量

        2. 成员内部类中不能有静态声明

        3. 成员内部类可以访问外部类所有的数据

*/
public class OuterClass{

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

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

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

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

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

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

        public void m4(){
            // 静态的
            System.out.println(s1);
            m1();

            // 成员的
            System.out.println(s2);
            m2();
        }

    }    

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

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

        InnerClass inner = oc.new InnerClass();

        inner.m4();

    }

}

/*
    关于静态内部类

        1. 静态内部类可以等同看做静态变量

        2. 内部类的重要的作用： 可以访问外部类中的私有的属性

        3. 静态内部类可以直接访问外部类的静态数据，无法直接访问成员变量

*/

public class OuterClass{

    // 静态的成员变量
    private static String s1 = "Ming";

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

    // 静态方法
    private static void m1(){
        System.out.println("我是一个静态方法 !");
    } 

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

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

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

            // 无法直接访问成员变量
            // 成员的
            //System.out.println(s2);
            //m2();    

        }

        // 成员方法
        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();

    }

}

/*
    内部类： 局部内部类

    等同于局部变量;

    重点：局部内部类在访问局部变量的时候，局部变量必须使用final修饰

*/
public class OuterClass{

    // 方法
    public void m1(){

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

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

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

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

        }

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

    }

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

        OuterClass oc = new OuterClass();
        oc.m1();

    }

}

/*
    匿名内部类：是指 类没有名字

*/

public class Test{

    // 静态方法
    public static void arry(UserService u){
        u.logout();
    }

    public static void main(String[] args){

        // 调用arry方法
        // new UserServiceImpl(){} 这个就是匿名内部类
        //arry(new UserServiceImpl());

        arry(new UserService(){
            public void logout(){
                System.out.println("我要退出系统！");
            }
        });

    }

}

// 定义接口
interface UserService{
    // 退出系统
    void logout();
}

//class UserServiceImpl implements UserService{

//    void logout(){
//        System.out.println("系统以安全退出 ！");
//    }

//}