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

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

内部类主要分类：

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("系统以安全退出 ！");    
//    }
    
//}