四种内部类

分类

（1）定义在外部类的局部位置上（例如：方法中或代码块中）：局部内部类、匿名内部类

【本质：局部变量】

（1.1）作用域：定义它的方法或者代码块中

（1.2）外部类和局部内部类成员变量重名时，采用就近原则，如果要想访问外部类的同名成员，可以是使用 外部类名.this.成员名 来访问（这里的this指的是调用定义该内部类的方法的外部类对象）

（1.3）可以直接外部类的所有成员，包括私有

（2）定义在外部类的成员位置上：成员内部类、静态内部类

【本质：类的成员】

（2.1）可以添加任意访问修饰符，因为他也是一个成员

（2.2）作用域：同其他类成员，为整个类体

类的五大成员：属性、方法、构造器、代码块、内部类

类的种类：外部类、内部类、外部其它类

一、局部内部类：有类名

（1）即使是内部类的内部类，也可以访问到外部类的外部类（也就是只要是内部类就可以访问它所有外部类的所有成员）

（2）由于本身是局部变量，因此不能添加访问修饰符，但是可以用final修饰

（3）外部类在方法中可以创建内部类对象，然后调用内部类的方法

（4）外部其他类不能访问局部内部类

二、匿名内部类：

（1）注意点：1.本质是类 2.是一个内部类 3.无名 4.同时也是这个类的一个对象

（2）适用场景：某个类只需要用一次，无需定义该类，直接创建匿名内部类，又是对象，简化开发

（3）形式：

外部类  变量名 = new 要实现的类名/接口名（参数）{重写方法。。。}；

//编译类型：外部类      运行类型：匿名内部类类型

（4）在jdk底层是创建匿名内部类后立即创建实例，并返回一个地址，其实编译器在创建时会给其分配一个类名（外部类名$1,2,3...），形如：

class Outer$1 extends/implements Outer{类体}

注：1.这里的“参数” 传给要实现的类的构造器，因为本质上是继承/实现，在创建对象时首先要调用外部类的构造器。

（5）调用匿名内部类的方法的两种形式：

class Outer1{
    private int n = 0;
    public void fun1(){
        //1.调用匿名内部类的第一种方法
        Person person = new Person("jack"){
            @Override
            public void hi() {
                System.out.println("perSon类的第一个匿名内部类的hi方法");
            }
        };
        person.hi();
        //2.调用匿名内部类的第二种方法
        new Person("lili"){
            @Override
            public void hi() {
                System.out.println("person类的第二个匿名内部类的hi方法");
            }
        }.hi();
    }
}

class Person{
    public Person(String name){
        System.out.println(name);
    }
    public void hi(){
        System.out.println("person类的hi方法");
    }
}

（6）匿名内部类只使用一次就没有了

（7）不能添加访问修饰符，也不能加final

实践：

package innerclass;


public class AnonymousExercise {
    public static void main(String[] args) {
        CellPhone phone = new CellPhone();
        phone.alarm(new Bell() {
            @Override
            public void ring() {
                System.out.println("a起床了");
            }
        });

        phone.alarm(new Bell() {
            @Override
            public void ring() {
                System.out.println("b起床了");
            }
        });
    }
}

class CellPhone{
    public void alarm(Bell bell){
        bell.ring();
    }
}

interface Bell{
    void ring();
}

三、成员内部类：

（1）可直接访问外部类所有成员

（2）外部类——>访问成员内部类：在方法中创建内部类对象，就可以访问内部类的所有成员

（3）外部其他类——>访问成员内部类：1.使用外部类对象.new  成员内部类（） 2.在外部类中编写一个方法返回成员内部类对象

package innerclass;

public class MemberInnerClass {
    public static void main(String[] args) {
        Outer01 outer01 = new Outer01();
        //通过调用外部类的方法创建内部类对象，并调用其方法
        outer01.diaoyong();

        //其他外部类创建成员内部类
        //1.通过外部类的对象new
        Outer01.Member member = new Outer01().new Member();
        member.hi();
        //2.通过外部类方法返回内部类对象
        Outer01.Member member1 = outer01.getMember();
        member1.hi();
    }
}

class Outer01{
    public int n1 = 0;
    class Member{
        private int nn = 0;
        public void hi(){
            System.out.println("成员内部类的hi方法");
        }
    }

    //外部类访问成员内部类
    public void diaoyong(){
        Member member = new Member();
        member.hi();
        member.nn = 5;//私有方法也可以直接访问
    }

    public Member getMember(){
        return new Member();
    }
}

（4）重名问题同上

四、静态内部类（有static修饰）

（1）可以直接访问外部类的所有静态成员，不能直接访问非静态成员

（2）外部类访问内部类：先创建对象再访问！！！（这里static修饰的类不是说它自己是静态类，而是说它是外部类的静态成员。）

（3）外部其它类访问静态内部类：1. new  外部类名.静态内部类（）【满足静态内部类访问条件的前提下】2.外部类 编写方法，返回实例

（4）重名问题：就近原则，访问外部类同名时，使用外部类名.成员名（成员为静态）

package innerclass;

public class StaticInnerClass {
    public static void main(String[] args) {
        OuterStatic.StaticClass staticClass = new OuterStatic.StaticClass();//在满足访问权限的前提下
        staticClass.fun();
        OuterStatic outerStatic = new OuterStatic();
        outerStatic.getInner().fun();
    }
}

class OuterStatic{
    private int n1 = 0;
    private static String NAME = "jack";
    static class StaticClass{
        private int n1 = 3;
        public void fun(){
            
        }
    }

    public void out(){
        StaticClass staticClass = new StaticClass();
        staticClass.fun();
    }

    public StaticClass getInner(){//也可以定义成静态的方法直接用外部类类名访问
        return new StaticClass();
    }
}