【内部类】

1.什么是内部类

在Java中，可以将一个类定义在一个类中或者在一个方法中，前者称为内部类，后者称为外部类。
内部类也是封装的一种体现。

class Outclass{//外部类

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

注意：
1.定义在class类名{}外面的，即使在一个文件中，也不是内部类

class Animal{
    
}
class Dog
{
    
}

这只是两个毫无相关的两个类，并不是内部类。

2.内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件。

2.内部类分类

2.1静态内部类

静态内部类就是在一个类中，定义一个由static修饰的类

注意：
1.当我们在内部类中定义了一个方法输出这些变量的时候，外部类的非静态成员变量需要先实例化这个类，在通过这个类对象引用，获得结果。

2.当我们在外部类定义了一个方法，想要输出这些结果，需要先实例化内部类，在通过内部类对象的引用来获取这个变量值。

class Outclass{//外部类

    public int data1=1;
    private int data2=2;

    public static int data5=5;
    //静态内部类
    static class InnerClass
    {
        public int data3=1;
        private int data4=2;
        public static int data6=5;
        public void func()
        {
            Outclass outclass=new Outclass();
            System.out.println("==============");
            System.out.println(outclass.data1);
            System.out.println(outclass.data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);

        }
    }

    public void fun()
    {
        System.out.println("==============");
        InnerClass innerClass=new InnerClass();
        System.out.println(data1);
        System.out.println(data2);
        System.out.println(innerClass.data3);
        System.out.println(innerClass.data4);
        System.out.println(data5);
        System.out.println(innerClass.data6);
    }
}
public class Test {
    public static void main(String[] args) {
        Outclass.InnerClass innerClass=new Outclass.InnerClass();
        innerClass.func();
        Outclass outclass=new Outclass();
        outclass.fun();
    }
}

2.非静态内部类

非静态内部类就是在一个类的内部，定义一个普通类，不需要static修饰的。

注意：
1.当我们在非静态内部类中，定义了一个方法，想要输出这些变量的话，我们不需要任何的添加，直接就可以输出，但是当我们在内部类中，把外部类的变量值修改了，那么我们输出的就是我们修改过得，内部类的值。
如果我们想要得到，外部类的值，那我们就需要先实例化外部类，通过外部类对象的（Outclass2.this.data1）
这个方法了。

2.当我们在外部类定义了一个方法，想要输出这些结果，需要先实例化内部类，在通过内部类对象的引用来获取这个变量值。

class Outclass2{//外部类

    public int data1=1;
    private int data2=2;

    public static int data5=5;
    //非静态内部类
    class InnerClass2
    {
        public int data1=11111;
        public int data3=1;
        private int data4=2;
        public static final  int data6=5;
        public void func()
        {
            Outclass outclass=new Outclass();
            System.out.println("==============");
            System.out.println(data1);
            System.out.println(Outclass2.this.data1);
            System.out.println(data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);

        }
    }

    public void fun()
    {
        System.out.println("==============");
        InnerClass2 innerClass2=new InnerClass2();
        System.out.println(data1);
        System.out.println(data2);
        System.out.println(innerClass2.data3);
        System.out.println(innerClass2.data4);
        System.out.println(data5);
        System.out.println(innerClass2.data6);
    }
}
public class Test2 {
    public static void main(String[] args) {
        Outclass2 outclass2=new Outclass2();
        Outclass2.InnerClass2 innerClass2=outclass2.new InnerClass2();
        innerClass2.func();
        outclass2.fun();
    }
}

1. 外部类中的任何成员都可以在实例内部类方法中直接访问
2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名
   称.this.同名成员 来访问
4. 实例内部类对象必须在先有外部类对象前提下才能创建
5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用
6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

2.3 局部内部类（几乎不用，大家了解）

就是在一个类中，定义一个方法，然后在这个方法中，定义一个普通类。

class Outclass3{

    public int a=10;
    public void func()
    {
        //局部内部类
        class Innerclass
        {
            public void test()
            {
                System.out.println("hello!");
            }
        }
        Innerclass innerclass=new Innerclass();
        innerclass.test();
    }
}
public class Test3 {
    public static void main(String[] args) {
        Outclass3 outclass3=new Outclass3();
        outclass3.func();
    }
}

注意：
局部内部类的使用，只能在这个方法中使用，就是说只能在这个方法中进行实例化，然后调用内部类中的属性。

1.局部内部类只能在所定义的方法体内部使用
2. 不能被public、static等修饰符修饰
3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class
4. 几乎不会使用

3.匿名内部类

匿名内部类

匿名内部类，就是没有名字的一种嵌套类。它是Java对类的定义方式之一。

为什么要使用匿名内部类？

在实际开发中，我们常常遇到这样的情况：一个接口的方法的某个实现方式在程序中只会执行一次，但为了使用它，我们需要创建它的实现类/子类去实现/重写。此时可以使用匿名内部类的方式，可以无需创建新的类，减少代码冗余。

interface IA
{
    void func();
}
public class Test4 {
    public static void main(String[] args) {
        //匿名内部类
        new IA(){

            @Override
            public void func() {
                System.out.println("hello!!!");
            }
        }.func();
    }
}

我们为了实现某一个方法，就需要先实现一个接口，但是如果我们想使用这个方法的话就需要去实例化一个对象，太麻烦，所以我们就通过new 接口（）{ }；这样的格式，去定义一个匿名内部类，最后调用这个方法就可以了。
这个就是匿名内部类的格式了。