详解Java的内部类

一、基本介绍

        一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class)嵌套其他类的类称为外部类(outer class)。它是我们类的第五大成员，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。

二、内部类的分类 

2.1 定义在外部类局部位置上(比如方法内):

①局部内部类(有类名)

②匿名内部类(没有类名，重点)

2.2 定义在外部类的成员位置上:

①成员内部类(没用static修饰)

②静态内部类(使用static修饰)

三、内部类的使用细节

3.1 局部内部类

1.局部内部类是定义在外部类的局部位置，比如方法中或者代码块中，并且有类名。

class OuterClass {
    private int n1 = 10;

    public void m1() {
        class InnerClass {
                   //内部类
        }
    }
}

2.可以直接访问外部类的所有成员，包含外部类私有的成员

class OuterClass {
    private int n1 = 10;

    public void m1() {
        class InnerClass {
                   //内部类
            public void f1(){
                System.out.println("n1="+n1);
            }
        }
    }
}

3.不能添加访问修饰符,因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final 修饰（这样就不可被继承），因为局部变量也可以使用final

class OuterClass {
    private int n1 = 10;

    public void m1() {
        class InnerClass {
                   //内部类
            public void f1(){
                System.out.println("n1="+n1);
            }
        }
        
        class InnerClass1 extends InnerClass{
            //继承上面的内部类
        }
    }
}

4.作用域:仅仅在定义它的方法或代码块中

5.局部内部类可以访问外部类的成员

6.外部类访问局部内部类的成员，访问方式:  创建对象，再访问(注意:必须在作用域[所定义内部类的方法中]内)

7.如果外部类和局部内部类的成员重名，那么调用遵循就近原则（即先找局部内部类的成员），如果想访问外部类的成员变量，则需使用 

外部类名.this.成员

           //很好理解，我们可以解读为，外部类的对象的成员

 3.2 匿名内部类

匿名内部类是定义在外部类的局部位置，比如方法中或者代码块中，并且没有类名；

匿名内部类的使用是为了简化开发

①基于接口的匿名内部类

假如：我们有一个需求，“使用IA接口，并创建对象使用其方法”

按照传统方法：我们需要①编写实现类实现接口的方法②new实现类的实例

public class AnonymousInnerClass {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.eat();
    }
}

interface IA {
    void eat();
}

class Animal implements IA {
    @Override
    public void eat() {
        System.out.println("动物吃饭");
    }
}

现在，有了匿名内部类，我们就可以这样实现:

public class AnonymousInnerClass {
    public static void main(String[] args) {
        IA animal = new IA() {
            @Override
            public void eat() {
                System.out.println("动物吃饭");
            }
        };
        animal.eat();
    }
}

interface IA {
    void eat();
}

说是匿名，其实是有名字的，在底层，系统给它起了名字，底层实现类似（大概模拟）这样：

class XXXX implements IA {
    @Override
    public void eat() {
        System.out.println("动物吃饭");
    }
}

类名是由系统起的，我们可以通过.getClass( )方法获取其运行时类型，编译类型当然是IA这不用说。

注意：匿名内部类只能使用一次，也就是只能new一个实例对象，这不代表其引用就能用一次。匿名内部类需要把接口的抽象方法都实现。

②基于普通类的匿名内部类

public class AnonymousInnerClass {
    public static void main(String[] args) {
        Animal animal = new Animal("老虎") {
            @Override
            void eat() {
                System.out.println(this.name+"要吃肉");
            }
        };
        System.out.println(animal.getClass());
        animal.eat();
    }
}

class Animal {
     String name;
    void eat() {
        System.out.println(this.name + "要吃饭");
    }
    public Animal(String name) {
        this.name = name;
    }
}

底层实现（大概模拟）

class XXXX extends Animal{

@Override
void eat() {
    System.out.println(this.name+"要吃肉");
    }
}

我们可以通过.getClass( )方法获取其运行时类型

③基于抽象类的匿名内部类

public class AnonymousInnerClass {
    public static void main(String[] args) {
        Animal animal = new Animal("老虎") {
            @Override
            void eat() {
                System.out.println(this.name + "吃肉");
            }
        };
        System.out.println(animal.getClass());
        animal.eat();
    }
}

abstract class Animal {
    String name;

    abstract void eat();

    void shout() {
        System.out.println("动物大叫");
    }

    public Animal(String name) {
        this.name = name;
    }
}

必须把抽象类中的抽象方法都实现。

这里补充说明一下，父类的私有属性可以被子类继承，但是子类无法使用；父类的构造方法，子类无法继承，但是子类创建对象会先调用父类的构造方法（默认是无参构造方法），以上案例匿名内部类应该是调用了父类的有参构造方法。

3.3 成员内部类

成员内部类定义在外部类的成员位置，并且没有static修饰。

可以添加任意访问修饰符（public、protected、默认、private），因为它的地位是一个成员。

1.成员内部类可访问外部类所有成员，包括私有的

 使用内部类方法一

public class ChengYuan {
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.shiYong();
    }
}

class OuterClass {
    int n = 10;

    public void eat() {
        System.out.println("吃顿饭");
    }

    class innerClass {
        public void f1() {
            System.out.println(n);
            eat();
        }
    }

    public void shiYong() {
        innerClass innerClass = new innerClass();
        innerClass.f1();
    }
}

使用内部类方法二

        OuterClass.innerClass innerClass = outerClass.new innerClass();
        innerClass.f1();

使用内部类方法三

外部类写方法，返回内部类对象

    public InnerClass shiYong1(){
        return new InnerClass();
    }

3.4 静态内部类

静态内部类是定义在外部类的成员位置，并且有static修饰

可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员

可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员。

作用域:同其他的成员，为整个类体

静态内部类可通过类名直接访问

public class ChengYuan {
    public static void main(String[] args) {
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
        innerClass.f1();
    }
}

class OuterClass {
    static int n = 10;

    static class InnerClass {
        public void f1() {
            System.out.println(n);
        }
    }
}

如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.成员)去访问。