[java基础] 内部类@ 一篇带你玩透(超详解)

前言

大家好本人双非科班大一菜鸟，自学java中，文章如果有误的地方，欢迎各位大佬交流指正探讨，一起共同进步
一个人单打独斗不如和一群人风雨前行

★,♫◦★,♫◦★,♫◦★,♫◦★,♫◦★我是分割线♫◦★,♫◦★,♫◦★,♫◦★,♫◦★,♫◦★,♫◦★

一.内部类概述

1. 定义:一个类中定义一个类就是内部类
2.定义格式:
public class 类名{
修饰符 class 类名{ }
}
3.内部类分类:
成员内部类和局部内部类
而这两个分为可以细分为:
(1)成员内部类（静态内部类，成员内部类）
(2)局部内部类（方法内部类，匿名内部类）
4. 那成员内部类和局部内部类的区别呢？
(1)如果定义在方法里面，则该类为方法内部类或者局部内部类
(2)如果定义在方法外面，则该类为成员内部类，加上static则该类为静态内部类
5.内部类访问特点:
(1)内部类可以直接访问外部类的成员，包括私有
(2)外部类想访问内部的成员，必须创建对象

6.代码案例:

public class Outer {
    //内部类可以直接访问外部类的成员，包括私有
    //外部类想访问内部的成员，必须创建对象
    private int num = 10;
    public class Inner{
        public void show(){
            System.out.println(num);
        }
    }
        public void method() {
            // show();不能直接访问,必须创建对象才能调用
            Inner i = new Inner();
            i.show();
        }
    }

★,♫◦★,♫◦★,♫◦★,♫◦★,♫◦★我是分割线♫◦★,♫◦★,♫◦★,♫◦★,♫◦★,♫◦★,♫◦★

---

二.成员内部类

✅那在成员内部类，外界如何创建对象使用呢？
那我们就看下面的例子:

public class Outer {
    private int num = 10;
    /*public class inner{
        public void show() {
            System.out.println(num);
        }
    }*/
    private class inner{
        public void show() {
            System.out.println(num);
        }
    }
    public void method(){//间接的访问inner内部类
        inner i = new inner();
        i.show();
    }
}
public class Test01 {
    public static void main(String[] args) {
        //创建内部类对象，并调用方法
       /* Outer.inner oi = new Outer().new inner();公共类public内部类可以访问
       格式:外部类.内部类 对象 = new 外部类().new 内部类();
        oi.show();*/
        Outer o = new Outer();
        o.method();

    }
}

✅则外界创建对象使用的格式:
外部类.内部类 对象 = new 外部类().new 内部类()
★,♫◦★,♫◦★,♫◦★,♫◦★,♫◦★我是分割线♫◦★,♫◦★,♫◦★,♫◦★,♫◦★,♫◦★,♫◦★

---

三.静态内部类

1.定义:有static关键字修饰的内部类为静态内部类
2.静态内部类访问外部类的静态成员变量或方法必须是静态
3.注意事项:
(1)静态内部类只能使用外部类静态的属性和方法, 对象的内容不可以访问
(2)外部类可以直接使用静态成员内部类
(3)外部类的外部也能访问静态成员内部类
4.访问格式:
外部类名.内部类名 对象名 = new 外部类名.内部类名();
让我们看一下下面的例子:

public class Outer {
    //静态内部类访问外部类的静态成员变量或方法，必须是静态
    private static  int age =10;
    public  static void show() {
        System.out.println("外部类");
    }
    public static class inner{//静态内部类
      public void method(){
          //静态内部类访问外部类的静态成员变量或方法，必须是静态
          show();
          System.out.println("静态内部类中method方法");
          System.out.println(age);
      }
    }
public class Test02 {
    public static void main(String[] args) {
        //如果外部访问 静态内部类 new 外部类.内部类()
        Outer.inner oi = new Outer.inner();
        oi.method();
    }
  }   
}

★,♫◦★,♫◦★,♫◦★,♫◦★,♫◦★我是分割线♫◦★,♫◦★,♫◦★,♫◦★,♫◦★,♫◦★,♫◦★

---

四.局部内部类

1.局部内部类是定义在方法中的类
2.外界是不能直接访问,需要在方法内部创建对象并使用
3.该类可以直接访问外部类成员，也可以访问方法内的局部变量
4.只有调用局部内部类所在的方法,才会创建局部内部类对象
让我们看一下例子:

public class Outer {
    private int num = 50;
    //在方法体里面定义的类 为局部内部类(或方法内部类)
    public void method(){
        class Inner{//局部内部类(或方法内部类)
            public void show(){
                System.out.println("我是局部内部类show方法");
                System.out.println(num);
                show2();
            }
        }
        Inner i = new Inner();
        i.show();
    }

    /*public void show2(){
        Inner i = new Inner();
        i.show();局部内部类只能在方法里面访问，不能在外界(外部方法)访问
    }*/
    public void show2(){
        System.out.println("我是外部类show2方法");
    }
}
public class Test {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

★,♫◦★,♫◦★,♫◦★,♫◦★,♫◦★我是分割线♫◦★,♫◦★,♫◦★,♫◦★,♫◦★,♫◦★,♫◦★

---

五.匿名内部类(常用)

1.没有名字的类为匿名内部类
2.匿名内部类存在是有前提的:
(1)继承自一个类
(2)实现某个接口
3.定义格式:
new 父类名(){
需要重写的方法;
};
new 接口名(){
重写接口中抽象方法
};
4.其本质:
是一个继承了该类(子类)或者实现了该接口(实现类)匿名对象
5.(1)如果匿名内部类创建的对象,没有使用变量接收, 只能使用一次
(2)如果想多次使用匿名内部类对象,使用父类或者接口类型变量存储匿名内部类对象

✅6.让我们看例子:

public abstract class Animal {
    public abstract void eat();
}
public class Test {
    public static void main(String[] args) {
        Animal cat = new Animal() {
            @Override
            public void eat() {
                System.out.println("猫类，爱吃鱼");
            }
        };
        cat.eat();
        Animal dog = new Animal() {
            @Override
            public void eat() {
                System.out.println("狗类，爱吃骨头");
            }
        };
        dog.eat();
    }
}

✅7.再看接口实现类的例子:
method接口类

public interface Method {
    void method();
}

show接口类

public interface Show {
    void show();
}

再看测试类

public class Test {
    public static void main(String[] args) {
        //匿名内部类
     Method m =  new Method() {
            //重写了接口中 方法
            @Override
            public void method() {
                System.out.println("匿名内部类。。method方法");
            }
        };
     m.method();//使用匿名内部类不需要去创建实现类和子类
        //底层实际是创建 我们子类
      Show s =  new Show() {
            @Override
            public void show() {
                System.out.println("匿名内部类。。show方法");
            }
        };
        s.show();
    }
}

匿名内部类底层是如何实现的呢？
通过反编译技术
(1) java源代码翻译成class文件
(2)class文件反编译成 Java源代码
在java编译阶段 new 对象名{}
而低层创建了一个没有名称的类或接口,类的名称为null
而接口和抽象类是不能实例化的 匿名内部类底层 new接口 底层帮我们创建了一个实现类
名称为null 在编译阶段实现

好了，内部类，今天就到这