Java内部类知识初析

我们都知道Java是由类所组成，在Java类中可能还包含有其他的类，这就是Java中内部类。但是Java的内部类不仅仅只有一种，一共有四种类所组成的内部类：①成员内部类、②静态内部类、③局部内部类、④匿名内部类。每一种内部类的作用都不相同，我们在下面讲详细讲解关于每一种内部类的知识。

成员内部类

成员内部类指的是一个类作为类的成员而存在，其定义在类的内部。

对于成员内部类的实现与操作将以代码直接展示：

package com.tang.test;

//这个是外部类
public class Outer {
    private int number = 10;

    //这个是内部类
    public class Inner{
        int number1 = 20;
        public void test(){
            System.out.println("访问外部类的中的number："+number);
            System.out.println("访问内部类中的number1："+number1);
        }
    }

    //这个是测试类
    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inner = outer.new Inner();
        inner.test();
    }
}

注意点是创建内部类的方式：

Inner inner = outer.new Inner();

我们在创建内部类的时候是通过外部类的对象来创建的，此外就是我们在当外部类和内部类之间存在相同名字的成员变量和方法，内部类可以直接访问内部类的成员变量和方法，如果需要访问外部类的成员变量和方法，需要使用this关键字。详细代码如下：

package com.tang.test;

//这个是外部类
public class Outer {
    private int number = 10;

    //这个是内部类
    public class Inner{
        int number = 20;
        public void test(){
            System.out.println("访问外部类的中的number："+Outer.this.number);
            System.out.println("访问内部类中的number："+number);
        }
    }

    //这个是测试类
    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inner = outer.new Inner();
        inner.test();
    }
}

静态内部类

静态内部类指的是通过static修饰的内部类，静态内部类的特点是不能直接访问外部类的非静态成员，但是我们可以通过new 外部类来进行操作

package com.tang.test;

//这个是外部类
public class StaticOuter {
    private int number = 12;

    //这个是内部类
    public static class Inner{
        int number1 = 24;
        public void show(){
            System.out.println("这个是调用外部类的数据：" + new StaticOuter().number);
            System.out.println("这个是调用内部类的数据：" + number1);
        }
    }

    //这个是测试方式
    public static void main(String[] args) {
        StaticOuter staticOuter = new StaticOuter();
        Inner inner = new Inner();
        inner.show();
    }
}

注意此时我们外部类中变量并不是静态数据，所以我们必须要创建外部对象来进行调用。

如果此时咱们外部类的变量是静态变量，那么我们可以直接调用，详细代码如下：

package com.tang.test;

//这个是外部类
public class StaticOuter {
    private static int number = 12;

    //这个是内部类
    public static class Inner{
        int number1 = 24;
        public void show(){
            System.out.println("这个是调用外部类的数据：" + number);
            System.out.println("这个是调用内部类的数据：" + number1);
        }
    }

    //这个是测试方式
    public static void main(String[] args) {
        StaticOuter staticOuter = new StaticOuter();
        Inner inner = new Inner();
        inner.show();
    }
}

此时如果我们外部类变量和静态内部类的变量名不同时，我们可以如上直接调用，如果相同时，则和我们直接讲的成员内部类相同，通过外部类类名来进行调用，详细代码如下：

package com.tang.test;

//这个是外部类
public class StaticOuter {
    private static int number = 12;

    //这个是内部类
    public static class Inner{
        int number = 24;
        public void show(){
            System.out.println("这个是调用外部类的数据：" + StaticOuter.number);
            System.out.println("这个是调用内部类的数据：" + number);
        }
    }

    //这个是测试方式
    public static void main(String[] args) {
        StaticOuter staticOuter = new StaticOuter();
        Inner inner = new Inner();
        inner.show();
    }
}

关于静态内部类的主要点在于我们创建内部类的方式和成员内部类的方式不同，我们不再需要通过创建外部类对象来进行创建内部类。这点尤为重要，是成员内部类和静态内部类的重要区分点。

局部内部类

局部内部类又称为方法内部类，是处于方法中的类，这个类也是咱们内部类的重要组成部分，局部内部类在该方法中可用，详细情况我们通过一下代码展示

package com.tang.test;

public class MethOuter {
    private int number = 19;
    final private int number2 = 29;

    public void show(){
        class Inner{
            int number3 = 52;
            public void print(){
                System.out.println("访问外部类中的常量：" + number);
                System.out.println("访问外部类中变量：" + number2);
                System.out.println("访问内部类中变量：" + number3);
            }
        }
        Inner inner = new Inner();
        inner.print();
    }

    public static void main(String[] args) {
        MethOuter methOuter = new MethOuter();
        methOuter.show();
    }
}

局部内部类主要是在方法内部类，我们在方法中就把内部类进行创建，在测试类中我们可以直接创建外部类进行调用测试即可。

匿名内部类

匿名内部类是没有名字的内部类，只能使用一次，其主要作用是简化相关代码，如设置监听器等相关操作。匿名内部类必须继承抽象类或者接口，不能够凭空生成。

我们分两种方式来进行讲解匿名内部类的知识点

①：通过实现接口的匿名内部类，详细代码如下

package com.tang.test;

public class Anonymous {
    public static void main(String[] args) {
        new animal(){

            public void eat(){
                System.out.println("动物想吃东西了！");
            }
            @Override
            public void say() {
                System.out.println("动物叫一定表达什么");
            }
        }.eat();
    }
}

interface animal{
    public void say();
}

此时我们可以调用方法，如果我们想继续调用匿名内部类自身的方法我们可以在开始创建对象进行调用或者直接在最后调用.say()。

②：通过实现抽象类的匿名内部类，详细代码如下：

package com.tang.test;

public class Anonymous {
    public static void main(String[] args) {
        animal animal = new animal() {
            @Override
            public void say() {
                System.out.println("我想吃东西了");
            }
        };
        animal.say();
    }
}

abstract class animal{
    public abstract void say();
}

以上两种方式就是匿名内部类的表达方式，我们通过匿名内部类可以减少我们相应的代码，但是我们也必须对于匿名内部类有足够的了解。

我这篇博客主要是对于内部类的一个初步解释，还有很多详细的知识点并没有写出，如果哪里有不正确的，请大家指出以便改正。