内部类

/**
 * 测试内部类基本定义方式
 * @author qjc
  */
public class Demo01 {
    
    //静态内部类
    private static class StaticNestedClass{}
    
    //普通内部类（成员内部类）
    private class FieldInnerClass{}
    
    void sayHello(){
        
        //方法内部类
        class LocalClass{}
        
        /**
         * 匿名内部类
         * 两个作用：
         *         1、定义匿名内部类实体
         *         2、创建了匿名内部类的一个实例
         * 
         */
        Runnable runnable = new Runnable(){
            @Override
            public void run() {
            }
        };
    }
}

/**
 * 静态内部类的使用
 * @author qjc
 */
public class Demo02 {
    public static void main(String[] args) {
        //通常不相关类创建静态内部类方法 
        Outer02.StaticInnerClass sic = new Outer02.StaticInnerClass();
        
        //不相关类中可以直接创建静态内部类（不推荐）
        //import cn.qjc.nested.Outer02.StaticInnerC
        StaticInnerClass sic2 = new StaticInnerClass();
    }
}

class Outer02{
    int c = 5;
    static int b = 10;
    
    void test2(){
        
//            System.out.println(a); //外部类不能调用内部类普通成员
        System.out.println(b);
        
        StaticInnerClass sic = new StaticInnerClass();
        sic.test();
    }
    
    //静态内部类
    static class StaticInnerClass{
        int a = 3;
        static int b = 5;
        void test(){
            System.out.println(a);
            
            //静态内部类中不能调用外部类的普通成员！
//            System.out.println(c);
        }
    }
}

/**
 * 普通内部类
 * @author qjc
 */
public class Demo03 {
    public static void main(String[] args) {
        /**
         * 不相关类创建成员内部类
         */
        Outer03 out = new Outer03();
        Outer03.InnerClass inner = out.new InnerClass();
        inner.test();
    }
}

class Outer03{
    private int a = 3;
    int b = 10;
    
    void test2(){
        //本类中直接创建成员内部类
        InnerClass inner = new InnerClass();
    }
    //成员内部类
    class InnerClass{
        /**
         * 成员内部类不能有静态成员，
         * 除非声明为final
         * 并且只能是编译器可以确认值的常量表达式
         */
        int c = 5;
//        static int d = 10;//cannot be declared static;
        final static int e = 5;
//        final static Date f = new Date();//cannot be resolved to a type
        
//        static void test2(){} //成员内部类不能有静态方法，
        
        void test(){
            System.out.println(a);
            
            System.out.println("内部类对象："+this);//成员内部类对象的创建，必须先有外部类对象
            System.out.println("外部类对象："+Outer03.this); //引用外部类的对象
        }
    }
}

/**
 * 方法内部类
 * @author qjc
 */
public class Demo04 {
    public void test(){
        int a = 3;
        final int a2 = 3;
        //方法内部类
        class inner{
            int b = 10;
//            static int c = 20; //方法内部类中只能定义非静态成员
            final static int c2 = 20; //除非是final的
            
            void test2(){
//                System.out.println(a); //方法内部类中不能饮用所在方法的普通局部变量
                System.out.println(b); //除非是final的
                /**
                 * 分析：
                 * 方法生命周期，和方法内部类生命周期不一致
                 * 方法执行完，内部类对象可能仍然存在
                 */
            }
        }
    }
}

/**
 * 匿名内部类定义三种方式
 * @author qjc
 */
public class Demo05 {
    public static void main(String[] args) {
        Outer05 out = new Outer05();
        out.test1();
    }
}

class Outer05{
    
    public void test1(){
        int a = 3;
        final int a2 =3; 
        //匿名内部类（接口式），由于本内部类定义在方法中，际方法内部类
        Runnable runnable = new Runnable(){
            @Override
            public void run() {
            }
        };
        
        //匿名内部类（继承式）
        Car car = new Car(){
            @Override
            public void run() {
                System.out.println("子类的车在跑");
//                System.out.println(a);
                System.out.println(a2);
            }
        };
        car.run();
        
        //匿名内部类（参数式）
        test2(new Car(){
            @Override
            public void run() {
                System.out.println("参数式匿名内部类");
            }
        });
    }
    
    public void test2(Car car){
        car.run();
    }
}

abstract class Car{
    public void run(){
    }
}