内部类的理解学习

怼烎@ 2023-09-28 15:38 8阅读 0赞

#### 文章目录 ####

*  一、基本介绍
 *  二、内部类的分类
 *  三、基本语法
 *  四、局部内部类的使用
 *  五、匿名内部类的使用（重点）
 *   *  1.基本语法
     *  2.案例引入
     *  3.两类补充
     *   *  1）基于类的匿名内部类
         *  2）基于抽象类的匿名内部类
     *  4.使用细节
     *  5.经典使用案例
 *  六、成员内部类的使用
 *  七、静态内部类的使用
 *  总结

[参考文章][Link 1]

## 一、基本介绍 ##

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

## 二、内部类的分类 ##

**定义在局部位置**（方法中/代码块）

1.  局部内部类
2.  **匿名内部类（重点）**

**定义在成员位置**

1.  成员内部类
2.  静态内部类

--------------------

*  局部内部类 （有类名，无访问修饰符修饰）
 *  匿名内部类 （没有类名，无访问修饰符修饰）
 *  成员内部类 （没有static修饰，可以有访问修饰符修饰）
 *  静态内部类 （有static修饰，可以有访问修饰符修饰）

## 三、基本语法 ##

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

## 四、局部内部类的使用 ##

class Outer02 {
        //外部类
        private int n1 = 100;
        private void m2() {
        
            System.out.println("Outer02 m2()");
        }//私有方法
        public void m1() {
        //方法
            //1.局部内部类是定义在外部类的局部位置,通常在方法
            //3.不能添加访问修饰符,但是可以使用final 修饰
            //4.作用域 : 仅仅在定义它的方法或代码块中
            final class Inner02 {
        //局部内部类(本质仍然是一个类)
                //2.可以直接访问外部类的所有成员，包含私有的
                private int n1 = 800;
                public void f1() {
        
            //5. 局部内部类可以直接访问外部类的成员，比如下面 外部类n1 和 m2()
            //7. 如果外部类和局部内部类的成员重名时，默认遵循就近原则如果想访问外部类的成员，
            // 如果想访问外部类的成员，使用 外部类名.this.成员 去访问
            //Outer02.this 本质就是外部类的对象, 即哪个对象调用了m1, Outer02.this就是哪个对象
                    //看两个hashcode一致
                    System.out.println("n1=" + n1 + " 外部类的n1=" + Outer02.this.n1);
                    System.out.println("Outer02.this hashcode=" + Outer02.this);
                    m2();
                }
            }
            //6. 外部类在方法中，可以创建Inner02对象，然后调用方法即可
            Inner02 inner02 = new Inner02();
            inner02.f1();
        }
     
    }
     
     
    Outer02 outer02 = new Outer02();
            outer02.m1();
            System.out.println("outer02的hashcode=" + outer02);

小结：局部内部类定义在方法中或代码块

作用域在方法体或代码块中

本质仍是一个类

## 五、匿名内部类的使用（重点） ##

> **匿名内部类主要针对只需要使用一次的类**

### 1.基本语法 ###

new 类或接口（参数列表）{
        
    
    类体}；

### 2.案例引入 ###

我们现在提一个需求，想使用IA接口，并创建对象，我们传统方法是写一个类，实现该接口，并创建对象

传统方法代码：

interface IA {
        //接口
        public void cry();
    }
    class Tiger implements IA {
        
     
        @Override
        public void cry() {
        
            System.out.println("老虎叫唤...");
        }
    }
    class Dog implements  IA{
        
        @Override
        public void cry() {
        
            System.out.println("小狗汪汪...");
        }
    }

但现在我们希望，Tiger/Dog类只使用一次，后面不再使用，因此我们可以使用匿名内部类来简化开发

匿名内部类使用一次就不能再使用
    IA tiger = new IA() {
        
                @Override
                public void cry() {
        
                    System.out.println("老虎叫唤...");
                }
            };
            System.out.println("tiger的运行类型=" + tiger.getClass());
            tiger.cry();
            tiger.cry();
            tiger.cry();

那我们这里需要弄清楚tiger的运行类型和编译类型是什么

毫无疑问编译类型看等号左边，所以**编译类型是IA，而运行类型是匿名内部类 Outer$01（系统分配）**，大家可以调一下上面代码，查看一下tiger的运行类型

//5. tiger的编译类型 ? IA
    //6. tiger的运行类型 ? 就是匿名内部类  Outer04$1
    
    //  我们看底层 会分配 类名 Outer04$1
    class Outer04$1 implements IA {
        
        @Override
        public void cry() {
        
            System.out.println("老虎叫唤...");
        }
    }
    
    //7. jdk底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1实例，并且把地址
    //   返回给 tiger

### 3.两类补充 ###

#### 1）基于类的匿名内部类 ####

> 匿名内部类的运行类型为编译类型的子类

class Father {
        //类
        public Father(String name) {
        //构造器
            System.out.println("接收到name=" + name);
        }
        public void test() {
        //方法
        }
    }
     
     
    //1. father编译类型 Father
            //2. father运行类型 Outer04$2
            //3. 底层会创建匿名内部类
            /*
                class Outer04$2 extends Father{
                    @Override
                    public void test() {
                        System.out.println("匿名内部类重写了test方法");
                    }
                }
             */
            //4. 同时也直接返回了 匿名内部类 Outer04$2的对象
            //5. 注意("jack") 参数列表会传递给 构造器
            Father father = new Father("jack"){
        
     
                @Override
                public void test() {
        
                    System.out.println("匿名内部类重写了test方法");
                }
            };
            System.out.println("father对象的运行类型=" + father.getClass());//Outer04$2
            father.test();

#### 2）基于抽象类的匿名内部类 ####

abstract class Animal {
         //抽象类
        abstract void eat();
    }
     
     
    //基于抽象类的匿名内部类
            Animal animal = new Animal(){
        
                @Override
                void eat() {
        
                    System.out.println("小狗吃骨头...");
                }
            };
            animal.eat();
        }
    }

### 4.使用细节 ###

class Outer05 {
        
        private int n1 = 99;
        public void f1() {
        
            //创建一个基于类的匿名内部类
            //不能添加访问修饰符,因为它的地位就是一个局部变量
            //作用域 : 仅仅在定义它的方法或代码块中
            Person p = new Person(){
        
                private int n1 = 88;
                @Override
                public void hi() {
        
                    //可以直接访问外部类的所有成员，包含私有的
                    //如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，
                    //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.this.成员）去访问
                    System.out.println("匿名内部类重写了 hi方法 n1=" + n1 +
                            " 外部内的n1=" + Outer05.this.n1 );
                    //Outer05.this 就是调用 f1的 对象
                    System.out.println("Outer05.this hashcode=" + Outer05.this);
                }
            };
            p.hi();//动态绑定, 运行类型是 Outer05$1
     
            //也可以直接调用, 匿名内部类本身也是返回对象
            // class 匿名内部类 extends Person {}就相当于下面一串代码
    //        new Person(){
        
    //            @Override
    //            public void hi() {
        
    //                System.out.println("匿名内部类重写了 hi方法,哈哈...");
    //            }
    //            @Override
    //            public void ok(String str) {
        
    //                super.ok(str);
    //            }
    //        }.ok("jack");
        }
    }
     
    class Person {
        //类
        public void hi() {
        
            System.out.println("Person hi()");
        }
        public void ok(String str) {
        
            System.out.println("Person ok() " + str);
        }
    }
     
     
     
            Outer05 outer05 = new Outer05();
            outer05.f1();
            //外部其他类---不能访问----->匿名内部类
            //即不能直接调用hi()方法
            System.out.println("main outer05 hashcode=" + outer05);

### 5.经典使用案例 ###

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

**直接将接口的实现类写为匿名内部类，通过实参的方式传递，优化了类的创建，简化了开发步骤**

public class InnerClassExercise01 {
        
        public static void main(String[] args) {
        
     
            //当做实参直接传递，简洁高效
            f1(new IL() {
        
                @Override
                public void show() {
        
                    System.out.println("这是一副名画~~...");
                }
            });
            //传统方法
            f1(new Picture());//相当于下面一串代码
    //        Picture picture = new Picture();
    //        f1(picture);
        }
     
        //静态方法,形参是接口类型
        public static void f1(IL il) {
        
            il.show();
        }
    }
    //接口
    interface IL {
        
        void show();
    }
    //类->实现IL => 编程领域 (硬编码)
    class Picture implements IL {
        
     
        @Override
        public void show() {
        
            System.out.println("这是一副名画XX...");
        }
    }

## 六、成员内部类的使用 ##

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

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

2.可以添加任意访问修饰符，因为它的地位就是一个成员

3.作用域和其它外部类的其它成员一样，为整个类体

class Outer08 {
         //外部类
        private int n1 = 10;
        public String name = "张三";
     
        private void hi() {
        
            System.out.println("hi()方法...");
        }
     
     //1.注意: 成员内部类，是定义在外部内的成员位置上
     //2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
        public class Inner08 {
        //成员内部类
            private double sal = 99.8;
            private int n1 = 66;
            public void say() {
        
                //可以直接访问外部类的所有成员，包含私有的
                //如果成员内部类的成员和外部类的成员重名，会遵守就近原则.
                //，可以通过  外部类名.this.属性 来访问外部类的成员
                System.out.println("n1 = " + n1 + " name = " + name + " 外部类的n1=" + Outer08.this.n1);
                hi();
            }
        }
        //方法，返回一个Inner08实例
        public Inner08 getInner08Instance(){
        
            return new Inner08();
        }
     
     
        //写方法
        public void t1() {
        
            //使用成员内部类
            //创建成员内部类的对象，然后使用相关的方法
            Inner08 inner08 = new Inner08();
            inner08.say();
            System.out.println(inner08.sal);
        }
    }
     
     
     
    Outer08 outer08 = new Outer08();
            outer08.t1();
     
            //外部其他类，使用成员内部类的三种方式
            //老韩解读
            // 第一种方式
            // outer08.new Inner08(); 相当于把 new Inner08()当做是outer08成员
            // 这就是一个语法，不要特别的纠结.
            Outer08.Inner08 inner08 = outer08.new Inner08();
            inner08.say();
            // 第二方式 在外部类中，编写一个方法，可以返回 Inner08对象
            Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
            inner08Instance.say();

## 七、静态内部类的使用 ##

使用方法与成员内部类基本相同，只不过增添一个static的前提

class Outer10 {
         //外部类
        private int n1 = 10;
        private static String name = "张三";
        private static void cry() {
        }
      //Inner10就是静态内部类
      //1. 放在外部类的成员位置
      //2. 使用static 修饰
      //3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
      //4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
      //5. 作用域 ：同其他的成员，为整个类体
        static class Inner10 {
        
            private static String name = "韩顺平教育";
            public void say() {
        
                //如果外部类和静态内部类的成员重名时，静态内部类访问的时，
                //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）
                System.out.println(name + " 外部类name= " + Outer10.name);
                cry();
            }
        }
     
        public void m1() {
         //外部类---访问------>静态内部类 访问方式：创建对象，再访问
            Inner10 inner10 = new Inner10();
            inner10.say();
        }
     
        public Inner10 getInner10() {
        
            return new Inner10();
        }
     
        public static Inner10 getInner10_() {
        
            return new Inner10();
        }
    }
     
     
     
     
    Outer10 outer10 = new Outer10();
            outer10.m1();
     
            //外部其他类 使用静态内部类
            //方式1
            //因为静态内部类，是可以通过类名直接访问(前提是满足访问权限)
            Outer10.Inner10 inner10 = new Outer10.Inner10();
            inner10.say();
            //方式2
            //编写一个方法，可以返回静态内部类的对象实例.
            Outer10.Inner10 inner101 = outer10.getInner10();
            System.out.println("============");
            inner101.say();
     
            Outer10.Inner10 inner10_ = Outer10.getInner10_();
            System.out.println("************");
            inner10_.say();

## 总结 ##

在以前的学习中，没有怎么注意过java的内部类，本次在复习基础知识的过程中，对这些以前没怎么注意过的知识进行了一个学习。

1.  内部类有四种
    
     *  局部内部类
     *  匿名内部类
     *  成员内部类
     *  静态内部类
2.  重点是掌握匿名内部类的使用
3.  局部内部类，匿名内部类是放在方法或代码块内的位置，作用域为方法或代码块内
4.  成员内部类，静态内部类是放在外部类的成员位置，本质就是一个成员

内部类的实现方式自我认为挺简单，难的是如何去理解它。它简化了我们开发过程中单独再创建一个类的繁琐操作，其中最重要的是匿名内部类，**其主要针对只需要使用一次的类**，提高了我们的开发效率。

[Link 1]: https://blog.csdn.net/wztmds/article/details/124258203?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165803241016781685337421%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=165803241016781685337421&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~baidu_landing_v2~default-1-124258203-null-null.142%5Ev32%5Enew_blog_fixed_pos,185%5Ev2%5Econtrol&utm_term=%E9%9F%A9%E9%A1%BA%E5%B9%B3%E5%8C%BF%E5%90%8D%E5%86%85%E9%83%A8%E7%B1%BB&spm=1018.2226.3001.4187