📄个人简介
🔔作者简介：大家好，我是小学生！！🙈大二学生一枚，目前正在自学Java，如果大家觉得我写的还不错的话，希望大家给我点赞👍+收藏⭐+评论📢，有什么写的不对的地方还请大家多多指教🙏，共同进步。
📝个人主页：小学生！！
📖系列专栏
🌕阶段一：Java基础编程
💦目前已原创15篇

🌕阶段二：数据结构与算法
🌕阶段三：操作系统
🌕阶段四：计算机网络

文章目录

• 前言
• 内部类
• • 1.基本介绍
  • 2.基本语法
  • 3.内部类的分类
  • • 1.局部内部类的使用
    • 2.匿名内部类的使用(重点)
    • 3.成员内部类的使用
    • 4.静态内部类的使用

前言

🔥本文主要介绍了内部类的基本语法以及四种内部类：局部内部类，匿名内部类(重点)，成员内部类，静态内部类的使用和注意事项。内部类很很很重要！！！！！！

内部类

1.基本介绍

一个类的内部又嵌套了另一个类，被嵌套的类叫做内部类。被嵌套的其他类叫做外部类。

内部类可以直接访问私有属性。

2.基本语法

class Outer{//外部类       class Inner{//内部类   }}class Other{//外部其他类}

3.内部类的分类

1.定义在外部类的局部位置上(比如方法)：

①局部内部类(有类名)

②匿名内部类(无类名，重要)

2.定义在外部类的成员位置上：

①成员内部类(没有static修饰)

②静态内部类(有static修饰)

1.局部内部类的使用

1.局部内部类，必须定义在局部位置(方法/代码块)，有类名。

2.不能添加访问修饰符，地位相当于局部变量，但可以用final修饰。

3.外部类访问局部内部类，创建内部类对象，必须在作用域内。

4.外部类同样能访问内部类的所有成员。

5.局部内部类可直接访问外部类的所有成员包括私有的

6.作用域在方法或代码块中，所以外部其他类不能访问局部内部类。

7.当内部类的成员与外部类重名时，遵循就近原则，若想直接访问外部类采用外部类名.this.成员名。

class Outer {//外部类    private int a = 100;    { //1.局部内部类，必须定义在局部位置(方法/代码块)，有类名 class Inner02 { }    }    public void m1() { //2.不能添加访问修饰符，地位相当于局部变量 final class Inner01 {//但可以用final修饰     private int a = 10;     public void display() {  //可直接访问外部类的所有成员包括私有的  System.out.println(a);     } } //3.外部类访问局部内部类，创建内部类对象 Inner01 inner01 = new Inner01(); //4.外部类同样能访问内部类的所有成员 //5.当内部类的成员与外部类重名时，遵循就近原则 //若想直接访问外部类采用外部类名.this.成员名 System.out.println("内部类 a = " + inner01.a +"\n"+ "外部类 a = " + Outer.this.a); inner01.display();    }}

2.匿名内部类的使用(重点)

1.基本语法

new 类或接口名(参数列表){类体};

2.匿名内部类既是一个类的定义，同时还是一个对象

3.匿名内部类使用一次就不能再用。

4.匿名内部类，必须定义在局部位置(方法/代码块)，不表现出类名，但底层会分配类名。

5.不能添加访问修饰符，地位相当于局部变量。

6.作用域在方法或代码块中，所以外部其他类不能访问匿名内部类。

7.当内部类的成员与外部类重名时，遵循就近原则，若想直接访问外部类采用外部类名.this.成员名。

8.匿名内部类可直接访问外部类的所有成员包括私有的。

9.匿名内部类还可当做实参直接传递。

public class InnerClass02 {    public static void main(String[] args) { Outer02 outer02 = new Outer02();//9.匿名内部类还可当做实参直接传递。 outer02.m2(new A() {     @Override     public void cry() {  System.out.println("小猫在哭。。。");     } });    }}interface A {    void cry();}class Outer02 {    //1.基本语法    //new 类或接口名(参数列表){类体};    private int a = 100;    public void m2(A a) { a.cry(); //基于接口 A Dog = new A() {     //2.匿名内部类既是一个类的定义，同时还是一个对象     //Dog的编译类型为A，运行类型为匿名内部类 Outer02$1     //JDk底层在创建匿名内部类 Outer02$1，立即就会创建Outer02$1的实力，并且将地址返回给Dog     //3.匿名内部类使用一次就不能再用。     /*     底层会分配类名 Outer02$1     class Outer02$1 implements A{ @Override public void cry() {   System.out.println("小狗在哭。。。"); }     }      */     @Override     public void cry() {  System.out.println("小狗在哭。。。");     } }; Dog.cry();  //基于类 new Person("Bob") {     /*    底层会分配类名 Outer02$2    class Outer02$2 extends Person{public void show() {  //8.直接访问外部类所有成员  System.out.println("外部类 a = " + a);     }    }     */     public void show() {  //8.可直接访问外部类所有成员  System.out.println("外部类 a = " + a);     } }.display();    }}class Dog {}class Person {    private String name;    public Person(String name) { this.name = name;    }    void display() { System.out.println("Bob在工作。。。");    }}

3.成员内部类的使用

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

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

3.可以添加任意访问修饰符(public，protected，默认的，private)，地位是一个成员。

4.作用域是整个类体。

5.成员内部类可直接访问外部类的成员，外部类访问要先创建对象再访问。

6.外部其他类访问成员内部类。方法1，方法2。

7.当内部类的成员与外部类重名时，遵循就近原则，若想直接访问外部类采用外部类名.this.成员名。

public class InnerClass03 {    public static void main(String[] args) { //方法1 Outer03 outer03 = new Outer03(); Outer03.Inner03 inner03 = outer03.new Inner03(); inner03.display(); //方法2 inner03 = outer03.getInstance(); inner03.display();    }}class Outer03 {    private int a = 100;    public class Inner03 { private int a = 10; void display() {     //7.当内部类的成员与外部类重名时，遵循就近原则，若想直接访问外部类采用外部类名.this.成员名。     System.out.println("内部类" + a + "+" + "外部类" + Outer03.this.a); }    }  void show() { Inner03 inner03 = new Inner03(); System.out.println(inner03.c);    }    public Inner03 getInstance() { return new Inner03();    }}

4.静态内部类的使用

1.静态内部类是定义在外部类的成员位置，并没有static修饰。

2.可以直接访问外部类的静态成员，包括私有的。

3.可以添加任意访问修饰符(public，protected，默认的，private)，地位是一个成员。

4.作用域是整个类体。

5.静态内部类可直接访问外部类的成员，外部类访问要先创建对象再访问，静态成员还可直接采用静态内部类名.成员名。

6.外部其他类访问静态内部类。方法1，方法2。

7.当静态内部类的成员与外部类重名时，遵循就近原则，若想直接访问外部类采用外部类名.成员名。

public class InnerClass03 {    public static void main(String[] args) { Outer03.Inner03.display(); //方法1 Outer03.Inner03 inner03 = new Outer03.Inner03(); System.out.println(inner03.c); //方法2 Outer03.Inner03 instance = Outer03.getInstance(); System.out.println(instance.c);    }}class Outer03 {    static private int a = 100;    static class Inner03 { static private int a = 10; int c = 23; static void display() {     //7.当静态内部类的成员与外部类重名时，遵循就近原则，若想直接访问外部类采用外部类名.成员名。     System.out.println("内部类" + a + "+" + "外部类" + Outer03.a); }    }    void show() { //5.静态内部类可直接访问外部类的成员，外部类访问要先创建对象再访问 Inner03 inner03 = new Inner03(); System.out.println(inner03.c);  //静态成员还可直接采用静态内部类名.成员名。 Inner03.display(); System.out.println(Inner03.a);    }    public static Inner03 getInstance() { return new Inner03();    }}

小故事网