Ming-Log's Blog

记录生活中的点点滴滴

0%

Java(15)内部类

发表于 更新于 分类于
本文字数： 10k 阅读时长 ≈ 9 分钟

内部类

如果一个事物的内部包含另一个事物,那么这就是一个类内部包含另一个类.

例如:身体和心脏的关系.又如:汽车和发动机的关系.

分类:

  1. 成员内部类

  2. 局部内部类(包含匿名内部类)

成员内部类

1
2
3
4
5
6
7
// 成员内部类的定义格式:
修饰符 class 类名称{
    修饰符 class 内部类名称{
        // ...
    }
    // ...
}

注意：内用外,随意访问；外用内,需要内部类对象.

如何使用成员内部类?有两种方式:

  1. 间接方式：在外部类的方法当中,使用内部类:然后main只是调用外部类的方法
  2. 直接方式：
1
2
类名称 对象名 = new 类名称();
[外部类名称.内部内名称 对象名 = new 外部类名称().new 内部类名称();]

Body类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.tipdm.Demo05;

public class Body {  // 外部类

    public class Heart{  // 成员内部类
        public void beat(){
            // 内部类方法
            System.out.println("心脏跳动:砰砰砰!");
            System.out.println("我是:" + name);  // 正确写法
        }
    }

    private String name;

    public Body() {
    }

    public Body(String name) {
        this.name = name;
    }

    // 外部类方法
    public void methodBody(){
        System.out.println("外部类的方法");
        new Heart().beat();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

demo1类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package com.tipdm.Demo05;

/**
 * 如果一个事物的内部包含另一个事物,那么这就是一个类内部包含另一个类.
 * 例如:身体和心脏的关系.又如:汽车和发动机的关系.
 *
 * 分类:
 * 1. 成员内部类
 * 2. 局部内部类(包含匿名内部类)
 *
 * 成员内部类的定义格式:
 * 修饰符 class 类名称{
 *     修饰符 class 内部类名称{
 *         // ...
 *     }
 *     // ...
 * }
 *
 * 注意:内用外,随意访问:外用内,需要内部类对象.
 * =================================
 * 如何使用成员内部类?有两种方式:
 * 1. 间接方式:在外部类的方法当中,使用内部类:然后main只是调用外部类的方法
 * 2. 直接方式:公式:
 * 类名称 对象名 = new 类名称();
 * [外部类名称.内部内名称 对象名 = new 外部类名称().new 内部类名称();]
 */
public class demo1 {
    public static void main(String[] args) {
        Body body = new Body("赵丽颖");  // 外部类的对象
        // 通过外部类的对象,调用外部类的方法,里面间接在使用内部类Heart
        body.methodBody();
        System.out.println("========================");
        Body.Heart heart = new Body("冯绍峰").new Heart();  // 直接访问 
        heart.beat();
    }
}
1
2
3
4
5
6
7
8
外部类的方法
心脏跳动:砰砰砰!
我是:赵丽颖
========================
心脏跳动:砰砰砰!
我是:冯绍峰

进程已结束,退出代码0

如果成员变量出现重复，那么如何从内部类获取外部类的成员变量呢？

Outer类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.tipdm.Demo05;

/**
 * 如果出现了重名现象,那么格式是:外部类名称.this.外部类成员变量名
 */
public class Outer {
    int num = 10;  // 外部类的成员变量

    public class Inner{
        int num = 20;  // 内部类的成员变量
        public void methodInner(){
            int num = 30;  // 内部类方法的局部变量
            System.out.println(num);  // 局部变量,就近原则
            System.out.println(this.num);  // 内部类的成员变量
            System.out.println(Outer.this.num);  // 外部类的成员变量
        }
    }
}

demo2类：

1
2
3
4
5
6
7
8
9
package com.tipdm.Demo05;

public class demo2 {
    public static void main(String[] args) {
        // 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
        Outer.Inner inner = new Outer().new Inner();
        inner.methodInner();
    }
}
1
2
3
4
5
30
20
10

进程已结束,退出代码0

局部内部类

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。

“局部”：只有当前所属的方法才能使用它,出了这个方法外面就不能用了。

定义格式：

1
2
3
4
5
6
7
修饰符 class 外部类名称{
    修饰符 返回值类型 外部类方法名称(参数列表){
        class 局部内部类名称{
            // ...
        }
    }
}

Outer类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.tipdm.Demo06;

/**
 * 如果一个类是定义在一个方法内部的,那么这就是一个局部内部类.
 * "局部":只有当前所属的方法才能使用它,出了这个方法外面就不能用了.
 *
 * 定义格式:
 * 修饰符 class 外部类名称{
 *     修饰符 返回值类型 外部类方法名称(参数列表){
 *         class 局部内部类名称{
 *             // ...
 *         }
 *     }
 * }
 *
 * 小结一下类的权限修饰符:
 * public > protected > (default) > private
 * 定义一个类的时候,权限修饰符规则:
 * 1. 外部类:public / (default)
 * 2. 成员内部类: public / protected / (default) / private
 * 3. 局部内部类: 什么都不能写
 */
public class Outer {
    public void methodOuter(){
        class Inner {  // 局部内部类
            int num = 10;
            public void methodInner(){
                System.out.println(num);  // 10
            }
        }
        Inner inner1 = new Inner();
        inner1.methodInner();
    }
    //    Inner inner2 = new Inner();
}

在外部无法调用，局部内部类。

image-20230611161303364

demo1类：

1
2
3
4
5
6
7
8
package com.tipdm.Demo06;

public class demo1 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.methodOuter();
    }
}
1
2
3
10

进程已结束,退出代码0

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是[有效final的]。

备注：

  • 从Java 8 开始,只要局部变量事实不变,那么final关键字可以省略.

原因:

  1. new出来的对象在堆内存当中.

  2. 局部变量是跟着方法走的,在栈内存当中.

  3. 方法运行结束之后,立刻出栈,局部变量就会立刻消失.

  4. 但是new出来的对象会在堆当中持续存在,直到垃圾回收消失.

MyOuter类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.tipdm.Demo06;

/**
 * 局部内部类,如果希望访问所在方法的局部变量,那么这个局部变量必须是[有效final的]
 *
 * 备注:从Java 8 开始,只要局部变量事实不变,那么final关键字可以省略.
 *
 * 原因:
 * 1. new出来的对象在堆内存当中.
 * 2. 局部变量是跟着方法走的,在栈内存当中.
 * 3. 方法运行结束之后,立刻出栈,局部变量就会立刻消失.
 * 4. 但是new出来的对象会在堆当中持续存在,直到垃圾回收消失.
 *
 */
public class MyOuter {
    public void methodOuter(){
        final int num = 10;  // 所在方法的局部变量
        class MyInner{
            public void methodInner(){
                System.out.println(num);  // 修改了num后就会报错
            }
        }
    }
}

匿名内部类

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

匿名内部类的定义格式：

1
2
3
接口名称 对象名 = new 接口名称(){
    // 重写所有抽象方法
}

对格式进行解析”new 接口名称(){ … }” 进行解析:

  1. new代表创建对象的动作

  2. 接口名称就是匿名内部类需要实现哪个接口

  3. { … }这才是匿名内部类的内容.

另外还需要注意几点问题:

  1. 匿名内部类,在创建对象的时候,只能使用唯一一次.

    ​ 第二次想要重复使用,必须重复创建.或者单独定义接口实现类.

  2. 匿名对象,在调用方法的时候,只能调用一次

    ​ 如果希望同一个对象,调用多次方法,那么必须给对象起个名字

  3. 匿名内部类是省略了[实现类/子类名称].但是匿名对象是省略了[对象名称]

    ​ 强调:匿名内部类和匿名对象不是一回事!!!

MyInterface接口：

1
2
3
4
5
6
7
package com.tipdm.Demo07;

public interface MyInterface {
    void method();  // 抽象方法

    void method2();
}

MyInterfaceImpl接口实现类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.tipdm.Demo07;

public class MyInterfaceImpl implements MyInterface{

    @Override
    public void method() {
        System.out.println("覆盖重写了方法!11111111111");
    }

    @Override
    public void method2() {
        System.out.println("覆盖重写了方法!2222222222");
    }
}

DmoMain类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
package com.tipdm.Demo07;

/**
 * 如果接口的实现类(或者是父类的子类)只需要使用唯一的一次,
 * 那么这种情况下就可以省略掉该类的定义,而改为使用[匿名内部类].
 *
 * 匿名内部类的定义格式:
 * 接口名称 对象名 = new 接口名称(){
 *     // 重写所有抽象方法
 * }
 *
 * 对格式进行解析"new 接口名称(){ ... }" 进行解析:
 * 1. new代表创建对象的动作
 * 2. 接口名称就是匿名内部类需要实现哪个接口
 * 3. { ... }这才是匿名内部类的内容.
 *
 * 另外还需要注意几点问题:
 * 1. 匿名内部类,在创建对象的时候,只能使用唯一一次.
 *      第二次想要重复使用,必须重复创建.或者单独定义接口实现类.
 * 2. 匿名对象,在调用方法的时候,只能调用一次
 *      如果希望同一个对象,调用多次方法,那么必须给对象起个名字
 * 3. 匿名内部类是省略了[实现类/子类名称].但是匿名对象是省略了[对象名称]
 * 强调:匿名内部类和匿名对象不是一回事!!!
 */
public class DmoMain {
    public static void main(String[] args) {
        MyInterface obj = new MyInterfaceImpl();
        obj.method();

        // 使用匿名内部类,但不是匿名对象,对象名称就叫objA
//        MyInterface some = new MyInterface();  // 错误写法
        MyInterface objA = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法!111111111111AAAAAAAAAAA");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法!22222222222AAAAAAAAAAAAAA");
            }
        };
        objA.method();
        objA.method2();

        System.out.println("======================");
        // 使用了匿名内部类,而且省略了对象名称,也是匿名对象
        new MyInterface() {
            @Override
            public void method() {
                System.out.println("又实现了匿名内部方法11111111bbbbbbbbbbb");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法!22222222222BBBBBBBBBBBB");
            }
        }.method();
        // 因为匿名对象无法调用第二次方法,所以需要再创建一个匿名内部类的匿名对象
        new MyInterface() {
            @Override
            public void method() {
                System.out.println("又实现了匿名内部方法11111111bbbbbbbbbbb");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法!22222222222BBBBBBBBBBBB");
            }
        }.method2();
    }
}
1
2
3
4
5
6
7
8
覆盖重写了方法!11111111111
匿名内部类实现了方法!111111111111AAAAAAAAAAA
匿名内部类实现了方法!22222222222AAAAAAAAAAAAAA
======================
又实现了匿名内部方法11111111bbbbbbbbbbb
匿名内部类实现了方法!22222222222BBBBBBBBBBBB

进程已结束,退出代码

类作为成员变量类型

Weapon武器类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.tipdm.Demo08;

public class Weapon {
    private String code;  // 武器代号

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public Weapon(String code) {
        this.code = code;
    }

    public Weapon() {
    }
}

Hero英雄类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package com.tipdm.Demo08;

public class Hero {
    private String name;  // 英雄名字
    private int age;
    private Weapon  weapon;  // 武器

    public Hero() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Weapon getWeapon() {
        return weapon;
    }

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }

    public Hero(String name, int age, Weapon weapon) {
        this.name = name;
        this.age = age;
        this.weapon = weapon;
    }

    public void attack(){
        System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "攻击敌方!");
    }
}

demo类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.tipdm.Demo08;

public class demo {
    public static void main(String[] args) {
        // 创建一个英雄角色
        Hero hero = new Hero();
        // 为英雄起一个名字,并且设置年龄
        hero.setName("盖伦");
        hero.setAge(20);

        // 创建一个武器对象
        Weapon weapon = new Weapon("多兰剑");
        // 为英雄配备武器
        hero.setWeapon(weapon);

        hero.attack();  // 年龄为20的盖伦用多兰剑攻击敌方!
    }
}
1
2
3
年龄为20的盖伦用多兰剑攻击敌方!

进程已结束,退出代码0

接口作为成员变量类型

Skill接口：

1
2
3
4
5
package com.tipdm.Demo09;

public interface Skill {
    void use();  // 释放技能
}

SkillImpl实现类：

1
2
3
4
5
6
7
8
9
package com.tipdm.Demo09;

public class SkillImpl implements Skill{

    @Override
    public void use() {
        System.out.println("Biubiubiu~~~~");
    }
}

Hero类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.tipdm.Demo09;

public class Hero {
    private String name;  // 英雄的名称
    private Skill skill;  // 英雄的极能

    public void attack(){
        System.out.println("我叫" + name + "开始释放极能!");
        skill.use();
        System.out.println("释放极能结束");
    }
    public String getName() {
        return name;
    }

    public Skill getSkill() {
        return skill;
    }

    public void setSkill(Skill skill) {
        this.skill = skill;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Hero(String name, Skill skill) {
        this.name = name;
        this.skill = skill;
    }

    public Hero() {
    }
}

DemoGame类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.tipdm.Demo09;

public class DemoGame {
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("艾希");  // 设置英雄名称

        // 设置英雄极能
//        hero.setSkill(new SkillImpl());  // 使用单独定义的实现类

        // 还可以改成使用匿名内部类
        Skill skill = new Skill() {
            @Override
            public void use() {
                System.out.println("piapiapia!!!!!");
            }
        };
        hero.setSkill(skill);

        // 进一步简化,同时使用匿名对象和匿名内部类
        hero.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("xuxuxuxu~~~");
            }
        });
        hero.attack();
    }
}
1
2
3
4
5
我叫艾希开始释放极能!
xuxuxuxu~~~
释放极能结束

进程已结束,退出代码0

接口作为方法的参数和返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.tipdm.Demo10;

import java.util.ArrayList;
import java.util.List;

/**
 * java.util.List正是ArrayList所实现的接口.
 */
public class demo {
    public static void main(String[] args) {
        // 左边是接口名称,右边是实现类名称,这就是多态的写法
        List<String> list = new ArrayList<>();

        List<String> result = addNames(list);
        for (int i = 0; i < result.size(); i++) {
            System.out.println(result.get(i));
        }
    }

    public static List<String> addNames(List<String> list){
        list.add("迪丽热巴");
        list.add("古力娜扎");
        list.add("马尔扎哈");
        list.add("沙场娜拉");
        return list;
    }
}
1
2
3
4
5
6
迪丽热巴
古力娜扎
马尔扎哈
沙场娜拉

进程已结束,退出代码0
-------------本文结束感谢您的阅读-------------