【零基础学Java】第十五篇 Java基础中的重难点—内部类

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

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

---

前言

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

---

内部类

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();
    }
}