java内部类

R.divan

已于 2024-01-05 21:27:01 修改

阅读量1.4k

点赞数 32

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

于 2023-12-23 19:23:21 首次发布

本文链接：https://blog.csdn.net/yxlhhhh_/article/details/135171316

版权

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

作为一个前端开发人员，为了准备软考所以我最近在学习java语言。我是跟着B站韩顺平老师学习的java。在学习到内部类的时候，总觉得它非常抽象，如果没有看源码的需要的话，实际上是很难记住它的。用进废退，非常简单的道理。

然而，作为一个有追求的人，怎么能不把它记录下来呢？

基本介绍

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类成为内部类（inner class），嵌套其他类的类成为外部类（outer class）。是java类的第五大成员（属性、方法、构造器、代码块、内部类），内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。

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

基本语法

class Outer{  //外部类
    class Inner{   //内部类    
    }    
}

class Oter{  //外部其他类
}

主要分类

1.局部内部类的使用

定义：局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。

1.可以直接访问外部类的所有成员，包含私有的

2.不能添加访问修饰符（public、protected、默认、private），因为它的地位就是一个局部变量。局部变量不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final

3.作用域：仅仅在定义他的方法或代码块汇中。

4.局部内部类访问外部类的成员，可以直接访问。

5.与第四条相反，在外部类访问局部内部类的成员需要先常见对象才能访问。（需要注意的是它必须要在作用域内）

6.外部其他类不能访问局部内部类（因为局部内部类地位是一个局部变量）

7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问。可以看匿名内部类需要注意的地方第七条。

System.out.println("外部类的n2=" + 外部类名.this.n2);

三点强调

（1）局部内部类定义在方法中/代码块

（2）作用域在方法体或者代码块中

（3）本质仍然是一个类

代码献上~~~

class Outer{
    private int n1 = 10;
    private static String name = "张三";
    public void say(){
        int n3 = 30;
        class LocalInner01{//这个就是定义在方法内的局部内部类 相当于一个局部变量
            int n2 = 40;
            public void show(){
                System.out.println(n2);
            }
        }
//        如果要使用内部类的方法，必须要先创建对象
        LocalInner01 localInner01 = new LocalInner01();
        localInner01.show();
    }
}

2.匿名内部类的使用（重要！！！！！）

经常在源码中出现，而且具有很高的实用价值

定义：匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名

特点：

（1）本质是类

（2）内部类

（3）该类没有名字

（4）同时还是一个对象

基本语法

class Outer04{
    private int n1 = 10;
    public void method(){
        new A(){                //这个就是匿名内部类 它不需要变量来接受
            @Override
            public void cry() {
                System.out.println("hello~");
            }
        }.cry();                //并且可以直接调用！！！
    }
}

interface A{
    public void cry();
}

我们来看一下韩老师对它的解读

1.需求：想用IA接口，并创建对象

2.传统方式，是写一个类，实现该接口，并创建对象

3.但是这边的需求是Tiger/Dog类只是使用一次，后面在不使用

4.可以使用匿名内部类

5.tiger的编译类型？是IA

6.tiger的运行类型？就是匿名内部类 Outer04$1

以前我们会这么写

但是会了匿名内部类后我们会这么写

代码是不是直观简洁了很多！！！

匿名内部类的需要注意的地方

1.匿名内部类的语法比较奇特，因为匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特点，也有创建对象的特征，对前面代码分析可以看出这个特点，因此可以调用匿名内部类方法。

2.可以直接访问外部类的所有成员，包含私有的

3.不能添加修饰访问符，因为它的地位和局部内部类一样，就是一个局部变量

4.作用域：仅仅在定义它的方法或代码块中。

5.匿名内部类可以直接访问外部类成员

6.外部其他类不能直接访问匿名内部类（因为匿名内部类地位是一个局部变量）

7.如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问。这个和局部内部类是一样的。

最佳实践：

当做实参直接传递，简洁高效

public class CSDN {
    public static void main(String[] args) {
        show(new AA() {
            @Override
            public void cry() {
                System.out.println("AA cry");
            }
        });
    }
    public static void show(AA a){
        a.cry();
    }
}
interface AA{
    public void cry();
}

来道练习题

3.成员内部类

定义：成员内部类是定义在外部类的成员位置，并且没有static修饰。

1.可以直接访问外部类的所有成员，包含私有的

例如：

2.可以添加任意访问修饰符（public、protected、默认、private）,因为它的地位就是一个成员。

3.作用域和外部类的其他成员一样，为整个整体比如前面案例，在外部类的成员方法中创建成员内部类对象，再调用方法。

4.成员内部类访问外部类（比如：属性）【访问方式：直接访问】

5.外部类--访问---->内部类(说明）访问方式：创建对象，再访问

6.外部其他类---访问--->成员内部类

外部其他类访问成员内部类的方法

public class TestInner3{
    public static void main(String[] args){
//        其他类访问内部类，方式1
        Outer01 outer01 = new Outer01();
        Outer01.Innter01 innter01 = outer01.new Innter01();
//        方式2，相当于方法1的快捷写法
        Outer01.Innter01 innter011 = new Outer01().new Innter01();
//        方式3：使用一个方法来获取，更加简介
        Outer01.Innter01 innter01Instance = new Outer01().getInnter01Instance();

    }
}
class Outer01{
    private int n1 = 10;
    public String name = "张三";
    class Innter01{
        public void say(){
            System.out.println("Outer01 的 n1 = " + n1 + "Outer01 的 name = " + name);
        }
    }
    public Innter01 getInnter01Instance(){
        return new Innter01();
    }

}

7.如果外部类和成员内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问。和匿名内部类的第七点一样。

4.静态内部类的使用

定义：静态内部类是定义在外部类的成员位置，并且static修饰

1.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员

2.可以直接添加任意访问修饰符（public、protected、默认、private）,因为它的地位就是一个成员。

3.作用域:同其他的成员，为整个类体

class Outer02{
    private int n1 = 10 ;
    private static String name = "张三";
    static class Inner02{
        public void say(){
            System.out.println(name);
//            不能直接访问外部类的非静态成员
//            System.out.println(n1);
        }
    }
    public void show(){
        new Inner02().say();
    }
}

4.静态内部类--访问-->外部类（比如静态属性）【访问方式：直接访问所有静态成员】

5.外部类--访问--->静态内部类，访问方式：创建对象，再访问

下面代码是外部类访问静态内部类成员

class A03{
    private int n1 = 10;
    private static  String name= "tom";
    static class B02{
        public void say(){
            System.out.println(name);
        }
    }
//    外部类方法访问静态内部类，需要创建对象
    public void test(){
        B02 b02 = new B02();
        bo2.say();
    }
}