Java内部类详解(含：成员内部类、局部内部类、匿名内部类、静态内部类)

内部类是什么？

字面意思，在类的内部编写的类就叫内部类！即一个类的内部又完整的嵌套了另一个类结构，被嵌套的类称为内部类(inner class),嵌套其他类的类称为外部类(outer class)。

内部类是类的第五大成员→【提示:类的五大成员是哪些?[属性、方法、构造器、代码块、内部类]】

内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。

官方给的内部类优点如下：
1.每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整；
2.方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏；
3.方便编写事件驱动程序；
4.方便编写线程代码。

注意：内部类是学习的难点,同时也是重点,后面看底层源码时，有大量的内部类。

一、成员内部类：（在类的内部方法的外部编写的类就是成员内部类）

成员内部类特点：

1.成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）；

2.同名的属性名/方法名访问外部类时 → 外部类.this.成员名

Outer.this.name

成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。所以在外部类访问内部类的时候必须先实例化外部类对象

		Outer outer= new outer();
		Inner inner = outer.new Inner();
        //或者如下一句代码：
        Outer.Inner inner = new Outer().new Inner();

注意：

1.成员内部类可以使用四种权限修饰符进行修饰(四种权限修饰符：public（公有的） >protected（受保护的） > (default)（缺省/默认的） > private(私有的))；
2.成员内部类中不能书写静态变量和方法。

详见案例演示：

public class Outer {
    String name = "外部类的类名";
    static String type = "外部类的type属性";
    private int item = 1;

    public static void show() {
        System.out.println("掉用外部类中的show方法");
    }
    public void print() {
        System.out.println("调用外部类中的打印方法");
    }

    //成员内部类 可以使用权限修饰符进行修饰
    public class Inner{
        //static double weight = 1.8;  //成员内部类中不能使用static修饰变量和方法
        String name = "内部类的类名";

        public void innerShow(){
            //成员内部类可以直接访问外部类的属性和方法
            show();
            print();
            System.out.println(type);
            System.out.println(item);
            System.out.println("我是：" + name);
            //进行特指访问时 使用类名.this.变量名进行访问
            System.out.println("我是：" + Outer.this.name);

        }
    }

    public static void main(String[] args) {
        //成员内部类对象的创建步骤
        //1.第一步需要实例化外部类对象
        //2.第二步正常实例化内部类对象 但是new关键字要改成 外部类对象名.new
           /*Outer outer = new Outer();
            Inner inner = outer.new Inner();*/
        //或者这样创建
        Outer.Inner inner = new Outer().new Inner();
        inner.innerShow();
    }
}

二、局部内部类 (编写在方法的内部的类称之为局部内部类，也可以称为方法内部类)

局部内部类的特点

1.局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内；
2.局部内部类不可使用权限修饰符 静态(static)修饰符进行修饰 同局部变量相同；
3.局部内部类可以直接访问方法中的属性；
4.局部内部类 可以直接访问方法外部类中属性和方法；
5.局部内部类 创建对象 要在方法内部 局部内部类的外部声明。

详见案例演示：

public class Partial {
    String name = "外部类的类名";
    String type = "外部类的type属性";
    private int item = 1;

    public static void show() {
        System.out.println("掉用外部类中的show方法");
    }
    public void print() {
        System.out.println("调用外部类中的打印方法");
    }

    public void demo(){
        String name = "外部类方法deme()内部的方法名";
        String type = "外部类方法deme()内部的type属性";
        /*编写在方法的内部的类称之为局部内部类
        局部内部类不可使用权限修饰符 静态修饰符进行修饰 同局部变量相同
        局部内部类与局部变量使用范围一样 在此方法内部
        局部内部类可以直接访问方法中的属性 重名时使用参数传递完成访问*/
        class Inner{
            //局部内部类 可以访问方法外部类中属性和方法
            String name = "局部类的类名";
            public void showInner(String name){
                show();
                print();
                System.out.println("我是："+ type);
                System.out.println("我是："+ Partial.this.type);
                System.out.println(item);
                System.out.println("我是：" + this.name);
                System.out.println("我是：" + name);
                System.out.println("我是：" + Partial.this.name);
            }
        }
        //局部内部类 创建对象 要在方法内部 局部内部类的外部声明
        Inner inner = new Inner();
        inner.showInner(name);
    }

    public static void main(String[] args) {
        Partial partial = new Partial();
        partial.demo();
    }
}

三、匿名内部类(注意：匿名内部类只是没有类名，其他的都是具备的)

匿名内部类特点

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

详见案例演示：

 // 实现关系下的匿名内部类：
interface Dao {
	void show();
}

public class AnonymousDemo {
    //编写回调方法 ：callInner
    public void callInner(){
        // 接口关系下的匿名内部类
        new Dao(){
            //实现子类 但是没有名字 所以叫匿名内部类
            @Override
            public void show() {
                System.out.println("接口方法...");
            }
        }.show();
    }
}
// 测试：
public class Demo {
    public static void main(String[] args) {
        AnonymousDemo anonymousDemo = new AnonymousDemo();
        anonymousDemo.callInner();
    }
}

匿名内部类可用于给方法传递实参，演示如下：

interface Dao {
	void show();
}

public class AnonymousDemo {
    //编写回调方法:callInner 参数类型为接口Dao
    private static void callInner(Dao d) {
        d.show();
    }

    public static void main(String[] args) {
        callInner(new Dao() {//接口回调

            //实现子类 但是没有名字 所以叫匿名内部类
            @Override
            public void show() {
                System.out.println("匿名内部类用于给方法传递实参");
            }
        });
    }
    
}

或许有些难以理解，其实过程并不复杂。
说明：首先有一个接口，然后在使用的类中编写了一个方法（参数类型是接口对象），并使用接口中未实现的方法。
我们调用此方法直接构造一个接口对象传入，此时会自动生成一个此接口的子类（匿名内部类）实现接口中的方法。本质传入的类便是此时的匿名内部类。

四、静态内部类(在类中编写的以static修饰的类称为静态内部类)

静态内部类特点

1.静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static;
2.静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法;
3.静态内部类中即能声明静态成员也可以声明非静态成员。

详见案例演示：

public class Static {
    static String name = "外部类的类名";
    //静态内部类中不能访问外部类非静态成员
    String type = "外部类的type属性";

    public static class Inner{
        //四种权限修饰符可以修饰静态内部类
        public String name = "静态内部类的类名";
        static double weight = 1.8;
        String type = "静态内部类的type属性";
        public void show(){
            System.out.println("我是：" + weight);
            System.out.println("我是：" + type);
            System.out.println("我是：" + name);
            //System.out.println("我是：" + Static.type);//静态内部类中不能访问外部类非静态成员
            System.out.println("我是：" + Static.name);
        }
    }

    public static void main(String[] args) {
        //静态内部类可以直接实例化 不需要依附于外部类
        Inner inner = new Inner();
        inner.show();
    }
}

有问题大家一起提出，我们共同学习、共同成长！！！
欢迎评论区留言***