内部类

Posted 2020-08-23

1、什么是内部类？

　　内部类是指在一个外部类的内部再定义一个类。内部类作为外部类的一个成员，并且依附于外部类而存在的。内部类主要有以下几类：成员内部类、静态内部类、局部内部类、匿名内部类

2、内部类的共性

　　(1)、内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。

　　(2)、内部类不能用普通的方式访问。

　　(3)、内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量 。

　　(4)、外部类不能直接访问内部类的的成员，但可以通过内部类对象来访问

 　　内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的 。

　　因为当某个外围类的对象创建内部类的对象时，此内部类会捕获一个隐式引用，它引用了实例化该内部对象的外围类对象。通过这个指针，可以访问外围类对象的全部状态。

　　通过反编译内部类的字节码， 分析之后主要是通过以下几步做到的： 
　　1 、编译器自动为内部类添加一个成员变量， 这个成员变量的类型和外部类的类型相同， 这个成员变量就是指向外部类对象的引用； 
　　2 、编译器自动为内部类的构造方法添加一个参数， 参数的类型是外部类的类型， 在构造方法内部使用这个参数为1中添加的成员变量赋值； 
　　3 、在调用内部类的构造函数初始化内部类对象时， 会默认传入外部类的引用。

3、成员内部类

　　在一个类中直接定义的内部类， 成员内部类与普通的成员没什么区别，可以与普通成员一样进行修饰和限制。

　　成员内部类不能含有static的变量和方法。

　　外部类可以创建内部类的对象，内部类可以引用外部类的私有域。

　　只有有了外部类的对象，才能创建内部类的对象。

package com.yq.test.inner;

/**
 * Created by yq on 2016/12/7.
 */
public class Animal {
    public int age = 1;
    private int level = 1;
    private static String name = "动物";

    class DogInner {
        int level = 2;

        //static int name = "dog";
        // 内部类中不允许定义静态变量
        void print() {
            System.out.println(level);
            // 在内部类中访问内部类自己的变量直接用变量名
            System.out.println(this.level);
            // 在内部类中访问内部类自己的变量也可以用this.变量名
            System.out.println(Animal.this.level);
            // 在内部类中访问外部类中与内部类同名的实例变量用外部类名.this.变量名
            System.out.println(age);
            // 如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量
            System.out.println(name);
        }
    }

    public static void main(String[] args) {
        Animal animal = new Animal();
        Animal.DogInner ad = animal.new DogInner();
        ad.print();
    }
}
//output
2
2
1
1
动物

4、静态内部类

　　如果不需要内部类对象与其外围类对象之间有联系，可以将内部类声明为static。这通常称为嵌套类（nested class）。

　　要创建嵌套类的对象，并不需要其外围类的对象。

　　静态内部类只能访问其外围类的静态成员，除此之外与非静态内部类没有任何区别。

package com.yq.test.inner;

/**
 * Created by yq on 2016/12/7.
 */
public class Animal {
    public int age = 1;
    private int level = 1;
    private static String name = "动物";

    static class DogInner {
        int level = 2;
        static int age = 2;

        void print() {
            System.out.println(level);
            System.out.println(age);
            System.out.println(name);
        }
    }

    public static void main(String[] args) {
        Animal.DogInner ad = new Animal.DogInner();
        ad.print();
    }
}
//output
2
2
动物

5、局部内部类

　　在方法中定义的内部类称为局部内部类。

　　局部内部类不能有访问说明符，因为它不是外围类的一部分，但是它可以访问当前代码块内的常量，和此外围类所有的成员。

　　方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。

　　方法内部类对象只能使用final修饰的局部变量。(为了保持局部变量与局部内部类中备份域保持一致) 

package com.yq.test.inner;

/**
 * Created by yq on 2016/12/7.
 */
public class Animal {
    private int level = 1;
    private static String name = "动物";

    void inner(final int i) {
        final int age = 2;
        class DogInner {
            int level = 2;

            void print() {
                System.out.println(level);
                System.out.println(age);
                System.out.println(name);
                System.out.println(i);
            }
        }
        DogInner di = new DogInner();
        di.print();
    }

    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.inner(3);
    }
}
//output
2
2
动物
3

 6、匿名内部类

　　简单地说：匿名内部类就是没有名字的内部类。如果满足下面的一些条件，使用匿名内部类是比较合适的：

• 只用到类的一个实例。
• 类在定义后马上用到。
• 类非常小（SUN推荐是在4行代码以下）
• 给类命名并不会导致你的代码更容易被理解。

在使用匿名内部类时，要记住以下几个原则：

• 　　匿名内部类不能有构造方法。

• 　　匿名内部类不能定义任何静态成员、方法和类。

• 　　匿名内部类不能是public,protected,private,static。

• 　　只能创建匿名内部类的一个实例。

•      一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

• 　　因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

7、为什么需要内部类？

　　其主要原因有以下几点：

• 内部类方法可以访问该类定义所在的作用域的数据，包括私有的数据

• 内部类可以对同一个包中的其他类隐藏起来,一般的非内部类，是不允许有 private 与protected权限的，但内部类可以

• 可是实现多重继承

• 当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷

　　使用内部类最吸引人的原因是：

　　每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。大家都知道Java只能继承一个类，它的多重继承在我们没有学习内部类之前是用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了。它可以使我们的类继承多个具体类或抽象类。