JavaSE语法（11）—— 详细解读Java中的内部类

最新推荐文章于 2024-11-08 23:31:31 发布

会飞的阿喵

最新推荐文章于 2024-11-08 23:31:31 发布

阅读量238

点赞数

分类专栏： JavaSE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/che__dan/article/details/128363751

版权

JavaSE 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的内部类概念，包括实例内部类、静态内部类、局部内部类和匿名内部类的定义、实例化方式以及如何访问外部类的成员。实例内部类可以直接访问外部类的所有成员，静态内部类只能访问外部类的静态成员。局部内部类和匿名内部类有特定的使用场景和限制。

摘要由CSDN通过智能技术生成

1.前言

👉博主的JavaSE专栏

本篇来详细介绍Java语法中的内部类知识，内部类在数据结构中应用广泛，不废话了，开干👇。

2.内部类的概念

当一个事物的内部还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类，就比如链表的结点在类中的实现。

在 Java 中，可以将一个类定义在另一个类或者一个方法的内部。

public class A {
    
    class B{
        //........
    }
}

其中A为外部类，B为内部类，只要是一个类中有另一个类，则这个类叫内部类。

3.内部类的分类

内部类有如下几种：

成员内部类：
1. 实例内部类：未被static修饰的成员内部类
2. 静态内部类：被static修饰的成员内部类
局部内部类
匿名内部类

3.1 实例内部类

未被static修饰的成员内部类叫实例内部类，其形式：

public class OutClass {
	
	//......

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

实例内部类 实例化 的方式：

public class Main {
    public static void main(String[] args) {

        //第一种方式：先将外部类对象先创建出来，然后再创建实例内部类对象
        OutClass outClass = new OutClass();
        OutClass.InnerClass innerClass = outClass.new InnerClass();

        //第二种方式：直接创建，其实还是要先将外部类对象先创建出来
        OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
    }
}

实例内部类访问外部类的成员

1. 在实例内部类中可以直接访问外部类中的任意访问限定符修饰的成员。

public class OutClass {

    //不同修饰符的变量
    private int a = 10;
    protected int b= 10;
    public int c = 10;
    int d = 10;

    private void OutMethodA(){
        System.out.println("我是OutMethodA!!!");
    }

    private static void OutMethodB(){
        System.out.println("我是OutMethodB!!!");
    }

    //实例内部类
    class InnerClass{
    
        //在实例内部类中可以直接访问外部类中的任意访问限定符修饰的成员
        public void InnerMethod(){
            a = 20;
            b = 20;
            c = 20;
            d = 20;
            System.out.println("a = " + a + "  b = " + b +"  c = " + c + "  d = " + d);

            OutMethodA();
            OutMethodB();
        }
    }
    
}

public class Main {
    public static void main(String[] args) {

        OutClass.InnerClass innerClass = new OutClass().new InnerClass();
        innerClass.InnerMethod();

    }
}

结果：

a = 20  b = 20  c = 20  d = 20
我是OutMethodA!!!
我是OutMethodB!!!

2.如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的。

public class OutClass {

    int d = 10;
    private void A(){
        System.out.println("我是OutClass的A!!!");
    }

    //实例内部类
    class InnerClass{

        int d = 200000;
        private void A(){
            System.out.println("我是InnerClass的A!!!");
        }

        public void InnerMethod(){

            System.out.println("d = "+d);
            A();
        }
    }

}

public class Main {
    public static void main(String[] args) {

        //第二种方式：直接创建
        OutClass.InnerClass innerClass = new OutClass().new InnerClass();
        innerClass.InnerMethod();


    }
}

结果：

d = 200000
我是InnerClass的A!!!

3.如果要访问外部类同名成员时候用：外部类名称.this.同名成员名字

public class OutClass {

    int d = 10;

    //实例内部类
    class InnerClass{

        int d = 200000;

        public void A() {
            System.out.println("d = " + OutClass.this.d);
        }
    }
}
------------------------------------------------------------------
public class Main {
    public static void main(String[] args) {

        //第二种方式：直接创建
        OutClass.InnerClass innerClass = new OutClass().new InnerClass();
        innerClass.A();
    }
}

结果：

d = 10

3.2 静态内部类

被static修饰的内部成员类称为静态内部类，形式如下👇。

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

静态内部类的实例化方式：

        //静态内部类的实例化方式
        OutClass.InnerClass innerClass = new OutClass.InnerClass();

这里创建静态内部类对象时，不需要先创建外部类对象。

静态内部类访问外部类的成员：

1.只能访问外部类的静态成员

public class OutClass {
    public int a = 1;
    public static int b =2;

    //静态内部类
    static class InnerClass{

        public void A(){

            System.out.println(a);
            
            System.out.println(b);
        }
    }
}
---------------------------------------------------------

public class Main {
    public static void main(String[] args) {
        //静态内部类的实例化方式
        OutClass.InnerClass innerClass = new OutClass.InnerClass();
        innerClass.A();
    }
}

结果：
在这里插入图片描述

2.由于只能引用外部的静态成员，当外部与内部的静态成员同名时，访问外部类同名成员时候用：外部类名称.同名成员名字

public class OutClass {

    public static int b =2;

    //静态内部类
    static class InnerClass{
        public static int b =100;
        public void A(){
            //访问的是外部的a
            System.out.println(OutClass.b);
            //访问的是内部的a
            System.out.println(b);
        }
    }
}

结果：

2
100

3.3 局部内部类

是定义在{}中的类为局部内部类，这种用法几乎用不到，简单了解一下就行了。

public class OutClass {
    
    //可以定义在构造方法中
    OutClass(){
        class InnerClass{
            
        }
    }
    
    //可以定义在静态方法中
    public static void A(){
        class InnerClass{
            
        }
    }
    
    //可以定义在普通方法中
    public void B(){
        class InnerClass{

        }
    }

    //可以定义在代码块中
    {
        class InnerClass{

        }
    }
}

局部内部类不能被public、private等访问修饰符修饰：

在这里插入图片描述

只能在该{}中使用，其他位置都不能用：

public class OutClass {

    //定义在静态方法中
    public void A(){
        class InnerClass{
            public int a = 10000;
        }
        //只能在该方法体内部使用，其他位置都不能用
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.a);
    }

}
--------------------------------------------------------------------
public class Main {
    public static void main(String[] args) {
        OutClass outClass = new OutClass();
        outClass.A();
    }
}

结果：
10000

3.4 匿名内部类

匿名类是不能有名字的类，它们不能被引用，只能在创建时用 new 语句来声明它们。那么它是怎么用的呢？

假如有一个抽象类，里面有一个抽象方法，我们知道要用一个类来继承这个抽象类并重写方法才能使用。如下：

abstract class Test{

    public abstract void method1();
}


class Tool extends Test{

    //重写
    public void method1() {
        System.out.println("我是重写之后的method1()方法！！！");
    }
}


public class OutClass {
    public static void main(String[] args) {

        Test test = new Tool();
        test.method1();
    }
}

结果：
在这里插入图片描述

那如果有的时候我想只用一次 method1()方法，这时我还用一个“工具”类来继承的话就显得太麻烦了。那么匿名内部类就能解决这个问题：

abstract class Test{

    public abstract void method1();
}


public class OutClass {
    public static void main(String[] args) {

        Test test = new Test() {
            //必须重写所有的抽象方法。
            public void method1() {
                System.out.println("我是重写之后的method1()方法！！！");
            }
        };

        //调用method1()
        test.method1();
    }
}