实时计算 java基础：类的结构之五：内部类

今天分享又来了呀。ღ( ´･ᴗ･` ) 一起学习进步ღゝ◡╹)ノ♡

摘要：

IMDG：

加油，好好学习，天天向上~ 

Q:

1 内部类概念

• 什么是内部类

  就是在一个类中定义一个类。生活举例：我们用的笔记本电脑，里面有Cpu。我们就可以把cpu这个东西看做是一个内部类。那么笔记本就可以看做是一个外部类了。

• 什么时候使用内部类

  在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。

class 汽车 { //外部类
    class 发动机 { //内部类
    }
}

• 内部类的分类

内部类分为成员内部类与局部内部类。

我们定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。

Q:

2 成员内部类

成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问

• 定义格式

class 外部类 {
    修饰符 class 内部类 {
        //其他代码
    }
}

• 访问方式

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

• 成员内部类代码演示

定义类

class Body {//外部类，身体
    private boolean life= true; //生命状态
    public class Heart { //内部类，心脏
        public void jump() {
            System.out.println("心脏噗通噗通的跳");
            System.out.println("生命状态" + life); //访问外部类成员变量
        }
    }
}

访问内部类

public static void main(String[] args) {
        //创建内部类对象
        Body.Heart bh = new Body().new Heart();
        //调用内部类中的方法
        bh.jump();
    }

完整的代码：

class Body {//外部类，身体
    private boolean life = true; //生命状态


    public class Heart { //内部类，心脏
        public void jump() {
            System.out.println("心脏噗通噗通的跳");
            System.out.println("生命状态" + life); //访问外部类成员变量
        }
    }


    public static void main(String[] args) {
        //创建内部类对象
        Body.Heart bh = new Body().new Heart();
        //调用内部类中的方法
        bh.jump();
    }


}


//运行后输出：
//心脏噗通噗通的跳
//生命状态true

Q:

3 局部内部类

局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问

• 定义格式

class 外部类 {
    修饰符 返回值类型 方法名(参数) {
        class 内部类 {
        //其他代码
        }
    }
}

• 访问方式

在外部类方法中，创建内部类对象，进行访问

• 局部内部类代码演示

  定义类

class Party {//外部类，聚会
    public void puffBall(){// 吹气球方法
        class Ball {// 内部类，气球
            public void puff(){
                System.out.println("气球膨胀了");
            }
        }
        //创建内部类对象，调用puff方法
        new Ball().puff();
    }
}

访问内部类

public static void main(String[] args) {
      //创建外部类对象
      Party p = new Party();
      //调用外部类中的puffBall方法
      p.puffBall();
}

Q:

4 内部类的实际使用——匿名内部类

‍

是局部内部类的一种特殊形式。

前提：存在一个类或者接口，这里的类可以是具体类，也可以是抽象类（居多）。

1 使用场景

假设你在编写GUI程序，突然发现你需要一个有实现Actionlistnerl的类的实例，你也发现你没有任何该实例，其实你根本没有写过这样的类（译注：听起来很白痴，实际上很常见），此时你有两种选择:(1)在程序中编写内部类，就像我们之前的GUI程序一样。或者(2)当场创建出匿名的内部类。就在现场开始写一个类出来。没错，就在需要传入一个实例的地方创建出这个类。这代表你把整个类当作参数传进去。

2 匿名内部类概念

内部类是为了应对更为复杂的类间关系。查看源代码中会涉及到，而在日常业务中很难遇到，这里不做赘述。

最常用到的内部类就是匿名内部类，它是局部内部类的一种。

定义的匿名内部类有两个含义：

• 临时定义某一指定类型的子类（常用）

• 定义后即刻创建刚刚定义的这个子类的对象（常用）

3  定义匿名内部类的作用与格式

作用：匿名内部类是创建某个类型子类对象的快捷方式。

我们的类一般是class关键字定义类，但是匿名内部类是使用new关键字开头！

格式：

new 类名或接口名(){
        进行方法重写
      };

• 范例

new Inter(){               //new关键字，说明整体应该是一个对象，但是对象没有名字，称 匿名对象
    public void show() {   **重写方法，说明继承了前面这个类，或者说实现了接口**
    }
}

本质：

是一个继承了该类或者实现了该接口的子类匿名对象。

代码案例：

Inter

package com.atguigu.itheima;

/**
 * @author zhouyanjun
 * @create 2021-07-07 7:59
 */
public interface Inter {
    void show();//给个抽象的方法
}

Outer

package com.atguigu.itheima;

/**
 前提:
        存在一个类或者接口
        这里的类可以是具体类也可以是抽象类
 格式:
        new类名或者接口名(){
            重写方法
        };
 本质是什么呢?
    是一个继承了该类或者实现了该接口的子类匿名对象
 */
public class Outer {
    public void method(){
    //匿名内部类是局部内部类的一种特殊形式，所以也要在方法里面来写
        /*
        new Inter(){
            @Override
            public void show() {
                System.out.println("我是匿名内部类");
            }
        }; //这个样子仅仅是个对象。
        */

        //本质是个对象，对象就可以调用方法
        new Inter(){
            @Override
            public void show() {
                System.out.println("我是匿名内部类");
            }
        }.show(); //这样，就是对象调用方法
    }
}

OuterDemo

package com.atguigu.itheima;

/**
测试类
 */
public class OuterDemo {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();//创建了Outer对象，调用了method()
    }
}
//控制台输出：
//我是匿名内部类

如果想要多次调用：

只要是对象，就有一个返回值类型。

            {
        @Override
        public void show() {
            System.out.println("我是匿名内部类");
        }
    }

new Inter，还重写了show()方法。所以，我把上述代码，整体看做Inter的实现类对象。那么就可以按照多态的形式赋值给Inter这个接口

package com.atguigu.itheima;

public class Outer {
    public void method(){
        //匿名内部类是局部内部类的一种特殊形式，所以也要在方法里面来写
        /*
        new Inter(){
            @Override
            public void show() {
                System.out.println("我是匿名内部类");
            }
        }; //这个样子仅仅是个对象。
        */

        //本质是个对象，对象就可以调用方法
        new Inter(){
            @Override
            public void show() {
                System.out.println("我是匿名内部类");
            }
        }.show(); //这样，就是对象调用方法

        **//这个对象是接口Inter的实现类对象。如果Inter是个类，那这个对象就是这个类的子类对象。**
        Inter i = new Inter(){
            @Override
            public void show() {
                System.out.println("我是匿名内部类");
            }
        };//new Inter，还重写了show(). 所以，我整体看做Inter的实现类对象。那么就可以按照多态的形式赋值给Inter这个接口
        i.show();//编译看左边，执行看右边
        i.show();//多次调用的话，对象.方法 多写几次就可以了
        //到测试类那里，执行下，就多打印多次 "我是匿名内部类"
    }
}

使用匿名对象的方式，将定义子类与创建子类对象两个步骤由一个格式一次完成。虽然是两个步骤，但是两个步骤是连在一起完成的。

- END -

本文为原创文章

❤：在这里跟我一起学习技术、职场、人生、原理、健身、摄影、生活等知识吧！

❤： 欢迎点个关注一起学习，进步充实人生。