一、内部类的概念

内部类的是定义在另一个类中的类

一般分为：

本地内部类
实例内部类
静态内部类
匿名内部类

二、内部类的分类

1.本地内部类

定义在方法当中的类。

public class TestDemo {
    public void func(){
        class  Test{
            public int a;
        }
        //缺点：只能在当前方法中使用——本地内部类，定义在方法内部的类
    }

本地内部类，我们用得比较少，我们写本地内部类的时候一定要谨慎。

同时，本地内部类有一个很大的缺点：只能在当前方法中使用。

2.实例内部类

实例内部类是指没有用 static 修饰的内部类，有的地方也称为非静态内部类。

简单示例如下：

public class OuterClass {
    class InnerClass {
        // 实例内部类
    }
}

上面的InnerClass就是实力内部类了。

实例内部类的注意事项有以下几点，我们通过实例来一一了解：

在实例内部类中不能定义一个静态的成员变量，如果非要定义，只能定义一个静态常量，也就是用final修饰。

class OuterClass{//定义了一个普通类
    //实例内部类，可以把他当作外部类的一个普通实例的成员
    class InnerClass{
        public int data4=4;
        private int data5 = 5;
        //public static int data6 = 6; //err,不能定义静态成员变量，因为如果一个东西是静态的，它是属于类的，不属于对象的
        //加final就可以，因为加了final，它就变成了一个静态常量
        public static final int data6 = 6;
        }
     }

我们如何实例化实例内部类的对象？

外部类名.内部类名变量 = 外部类对象的引用.new 内部类（）；

class OuterClass{//定义了一个普通类
    //实例内部类，可以把他当作外部类的一个普通实例的成员
    class InnerClass{
        public int data4=4;
        private int data5 = 5;
        //public static int data6 = 6; //err,不能定义静态成员变量，因为如果一个东西是静态的，它是属于类的，不属于对象的
        //加final就可以，因为加了final，它就变成了一个静态常量
        public static final int data6 = 6;
        }
     }

public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        //OuterClass.InnerClass innerClass = new OuterClass.InnerClass();//ERR ，直接new是不能编译通过
        //需要外部类对象的引用才能实例化一个内部类对象
        OuterClass.InnerClass innerClass =  outerClass.new InnerClass();
    }

实例内部类当中，如果包含了和外部类同名的成员变量，我们如何在实例内部类中访问？

我们可以通过外部类的this来访问。注意：我们实例内部类当中包含了两个this，一个是外部类的this，一个是内部类的this。

//实例内部类
class OuterClass{//定义了一个普通类
    public int data1= 1;

    //实例内部类，可以把他当作外部类的一个普通实例的成员
    class InnerClass{
        public int data1=999;
        public InnerClass(){
            System.out.println("不带参数的内部类构造方法");
        }
        public void test(){
            System.out.println(OuterClass.this.data1);//1
            System.out.println(this.data1);//999
        }

    }
}


public class TestDemo {
    public static void main(String[] args) {
    //创建内部类对象分两步，1：
        OuterClass outerClass = new OuterClass();
//2.实例化一个内部类对象
        OuterClass.InnerClass innerClass =  outerClass.new InnerClass();
        innerClass.test();
    }
}

在这里插入图片描述

3.静态内部类

实例内部类是指用 static 修饰的内部类

public class OuterClass {
    static class InnerClass {
        // 静态内部类
    }
}

静态内部类的一些问题：

如何访问外部类的普通成员变量？

静态内部类不能访问外部类的实例成员，只能访问外部类的类成员。

 class OuterClass2{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
    //静态内部类
    static class InnerClass{
        public int data4 = 4;
        private int data5 = 5;
        public static int data6 = 6;

        //写一个构造方法
        public OuterClass2 out;
        public InnerClass(OuterClass2 out){
            this.out = out;
        }

        public void test(){
            //System.out.println(data1); //err
            System.out.println(out.data1);
            //System.out.println(data2);//err
            //System.out.println(new OuterClass2().data2); //由于是私有的，访问不了，要访问，只能提供get()和set()方法了
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
            System.out.println("InnerClass::test()");
        }
    }

如何实例化静态成员变量？

外部类名.内部类名变量 =new 外部类对象的引用.内部类（变量）；

public static void main(String[] args) {
//这里有两步 
//1.实例化外部类类对象
        OuterClass2 outerClass2 = new OuterClass2();
//2.通过外部类对象的引用实例化一个内部类对象
        OuterClass2.InnerClass innerClass = new OuterClass2.InnerClass(outerClass2);
        innerClass.test();
    }

打印结果：

在这里插入图片描述

3.匿名内部类

名内部类就是一个没有显式的名字的内部类。
匿名内部类没有类名，因此就不可能有构造函数，不能创建对象。

语法一：

new 实现接口（）
{
    //匿名内部类类体部分
}

语法二：

new 父类构造器（实参列表）
{
  //匿名内部类类体部分
}

实例：

class Test{
    public void test(){
        System.out.println("test()haha!");
    }
}

public class TestDemo2 {
    public static void main(String[] args) {
        new Test(){
            @Override
            public void test(){
                System.out.println("我是重写的test方法");
            }
        }.test();//调用test()方法
    }