内部类

内部类介绍

• 内部类（Nested Class） 嵌套类
• 静态内部类
• 非静态内部类
• 普通内部类（也称为成员内部类）
• 在一个类（外部类）中直接定义的内部类
• 匿名内部类
• 方法内部类
• 在一个方法（外部类的方法）或代码块中定义的内部类
• 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号
• 内部类可以使用修饰符（public,protected,default,private）

内部类作用：

1、内部类可以方便使用外部类成员

2、内部类存是为了辅助外部类完成功能

例1：

/**
 * 测试内部类基本定义方式
 * @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() {
            }
        };
    }
}

编译后class文件：

 

1、静态内部类

• 静态内部类可以包含静态成员、非静态成员
• 静态内部类可以直接调用外部类的静态属性、静态方法。但不能调用外部类的普通属性、普通方法。
• 在不相关类中，可以直接创建静态内部类的对象（不需要通过所在外部类）
• 静态内部类实际上和外部类联系很少，也就是命名空间上的联系

例2：

/**
 * 静态内部类的使用
 * @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);
        }
    }
}

2、成员内部类（普通内部类）

• 成员内部类基本用法：
• 成员内部类就像一个成员变量一样存在于外部类中。
• 内部类可以访问外部类的所有成员（包含：private）
• 成员内部类的this指内部类对象本身，要拿到外部类对象可以使用：外部类.this
• 成员内部类的对象是一定要绑定到一个外部类的对象上的。因此。创建成员内部类对象时需要持有外部类对象的引用。因此，要先有外部类对象，后有成员内部类对象
• 成员内部类不能有静态成员
• 成员内部类对象的创建方式
• 外部类内部

　　　　　　Inner inner = new Inner()

• • 外部类外部

　　　　　　Inner inner = new Outer().new Inner()

例3：

/**
 * 普通内部类
 * @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); //引用外部类的对象
        }
    }
}

3、方法内部类

• 方法内部类的地位和方法内的局部变量的位置类似。
• 因此不能修饰局部变量的修饰符也不能修饰局部内部类，譬如public、private、pritected、static、transient等
• 方法内部类只能在声明的方法内是可见的
• 因此定义局部内部类之后，想用的话就要在此方法内直接实例化，记住这里顺序不能反了，一定要先声明后使用，否则编译器会说找不到
• 方法内部类不能访问定义它的方法内的局部变量，除非这个变量被定义为final
• 本质原因：局部变量和方法内部类生命周期不一致！
• 方法内部类只能包含非静态成员！

例4：

/**
 * 方法内部类
 * @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的
                /**
                 * 分析：
                 * 方法生命周期，和方法内部类生命周期不一致
                 * 方法执行完，内部类对象可能仍然存在
                 */
            }
        }
    }
}

4、匿名内部类

• 匿名内部类基本用法：
• 匿名内部类的实例化方式：new SomeInterfaceOrClass(){…}
• 意思是创造一个实现（继承）SomeInterfaceOrClass的类的对象
• 根据声明位置，判断匿名内部类是成员内部类还是方法内部类

注：一般是方法内部类，这是就具备了方法内部类的特性。

• 三种使用方法：
• 继承式
• 接口式
• 参数式

例5：

/**
 * 匿名内部类定义三种方式
 * @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(){
    }
}