内部类

package minner_class;
/*
 * 关于静态内部类
 *         1、静态内部类可以等同看作静态变量
 * 
 *         内部类重要的作用：可以访问外部类中私有的数据
 * 
 *         2、静态内部类可以直接访问外部类的静态数据，无法直接访问成员
 */
public class OuterClass {

    //静态变量
    private static String s1 = "A";
    
    //成员方法
    private String s2 = "B";
    
    //静态方法
    private static void m1(){
        System.out.println("static's m1 method execute!");
    }
    
    //成员方法
    private void m2(){
        System.out.println("m2 method execute!");
    }
    
    //静态内部类
    //可以用访问控制权限的修饰符修饰
    static class InnerClass{
        
        //静态方法
        public static void m3(){
            System.out.println(s1);
            m1();
            
            //System.out.println(s2);
            //m2();
        }
        
        //成员方法
        public void m4(){        
            System.out.println(s1);
            //System.out.println(s2);
            m1();
            //m2();
        }
    }
    
    //入口
    public static void main(String[] args){
        
        //执行m3
        OuterClass.InnerClass.m3();
        
        //执行m4
        InnerClass inner = new OuterClass.InnerClass();
        inner.m4();
    }
}

package minner_class;

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

public class InnerClass {

    //静态变量
    private static String s1 = "A";
    
    //成员方法
    private String s2 = "B";
    
    //静态方法
    private static void m1(){
        System.out.println("static's m1 method execute!");
    }
    
    //成员方法
    private void m2(){
        System.out.println("m2 method execute!");
    }
    
    //成员内部类
    //可以用访问控制权限的修饰符修饰
    class InnerClass2{
        
        //静态方法
        //public static void m3(){}
        
        //成员方法
        public void m4(){
            
            System.out.println(s1);
            System.out.println(s2);
            m1();
            m2();
        }
    }
    
    //入口
    public static void main(String[] args){
        
        //创建外部类对象
        InnerClass ic = new InnerClass();
        
        InnerClass2 inner = ic.new InnerClass2();
        
        inner.m4();
    }
}

package minner_class;

/*
 * 局部内部类等同于局部变量
 * 
 * 重点：局部内部类在访问局部变量的时候，局部变量必须使用final修饰。
 */
public class JubuClass {

    public void m1(){
        //局部变量
        //可以，但不能被访问
        //int i = 10;
        final int i = 10;
        
        //局部内部类
        //局部内部类、局部内部类不能用访问控制权限修饰符修饰，
        //因为已经是局部变量了，只在局部有效果，不必要加修饰符
        class InnerClass{
            
            //内部类不能有静态声明
            //public static void m1(){}
            
            //成员方法
            public void m2(){
                System.out.println(i);
            }
        }
        
        //假如没有final，此处修改i的值
        //程序至上而下的运行，会产生冲突
        
        //调用m2
        InnerClass inner = new InnerClass();
        inner.m2();
    }

    
    //入口
    public static void main(String[] args){
        //想要调用m2方法，只能在上面的类创建对象，
        //因为局部内部类出了大括号就不认识了
        JubuClass jubu = new JubuClass();
        jubu.m1();
    }
}

package minner_class;

/*
 * 匿名内部类：指的是类没有名字
 */
public class NimingClass {

    //静态方法
    public static void t(CustomerService cs){
        cs.logout();
    }
    
    //入口
    public static void main(String[] args) {

        //调用t方法，方法一
        //父类型的引用指向子类型的方法
        //t(new CustomerServiceImpl());
        
        //使用匿名内部类的方式执行t方法
        //整个这个"t(new CustomerService(){}"就是匿名内部类
        t(new CustomerService(){
            public void logout(){
                System.out.println("系统已安全退出");
            }
        });
        
        //匿名内部类的优点：少定义一个类
        //缺点：无法重复使用！
    }

}

//接口
interface CustomerService{
    
    //退出系统
    void logout();
}

//方法一
//编写一个类实现CustomerService接口
/*
class CustomerServiceImpl implements CustomerService{
    
    public void logout(){
        System.out.println("系统已安全退出");
    }
}
*/