Java基础之内部类

于 2021-04-15 22:16:10 发布
阅读量124 收藏
点赞数
分类专栏： Java基础 文章标签： java 反射 多态 interface 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_41633902/article/details/115741643
版权

文章目录

这里是一段防爬虫文本，请读者忽略。
本文原创首发于优快云，作者IDYS
博客首页：https://blog.youkuaiyun.com/weixin_41633902/
本文链接：https://blog.youkuaiyun.com/weixin_41633902/article/details/115741643
未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离剽窃！

内部类

内部类的概念与分类

  • 如果一个类包含另外一个事物，那么这就是一个类内部包含另外一个类

分类

  1. 成员内部类
  2. 局部内部类（包含匿名内部类）

成员内部类

成员内部类的定义

  • 成员内部类的定义格式：
修饰符 class 外部类名称{
     修饰符 class 类名称{
        // ...
    }   
}
  • 注意：内部类用外部类，随意访问；外部类用内部类，需要内部类对象

成员内部类的使用

  • 如果使用成员内部类？有两种方式：
  1. 间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法
  2. 直接方式，公式：
//通常方式
类名称 对象名 = new 类名称();

// 使用成员内部类的方式
外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();

内部类访问外部类的同名变量

  • 如果出现同名现象，那么格式是：
    • 外部类名称.this.外部类成员变量名

演示

  • 其他类
package com.idayuanshuai.www.Demo3;

public class Body {
    public class Heart{
        int num = 30;
        public void method(){
            int num = 40;
            System.out.println("heart beat beat beat");
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(Body.this.num);
        }
    }
    private int num = 20;
    public void methodBody(){
        new Heart().method();
    }
    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
}
  • 主类
package com.idayuanshuai.www.Demo3;

public class MyClassDemo {
    public static void main(String[] args) {
        Body by = new Body();
        by.setNum(12);
        by.methodBody();

        Body.Heart heart = new Body().new Heart();
        heart.method();
    }
}
  • 输出结果
heart beat beat beat
40
30
12
heart beat beat beat
40
30
20

局部内部类

局部内部类定义

  • 如果一个类是定义在一个方法内部的，那么这就是一个局部内部类
  • “局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能使用了
  • 格式定义：
修饰符 class 外部类名称{
    修饰符 返回值类型 外部类方法名称(参数列表){
    class 局部内部类名称{
        
    }
    }
}

  • 定义一个类的时候，权限修饰符规则：
  1. 外部类：public / (default)
  2. 成员内部类：public / protected / (default) / private
  3. 局部内部类：什么都不能写

局部内部类

  • 从java 8开始，只要局部变量事实不变，那么final关键字可以省略
  • 原因：
  1. new 出来的对象在堆内存当中
  2. 局部变量是跟着方法走的，在栈内存当中
  3. 方法运行结束之后，立刻出栈，局部变量就会立刻消失
  4. 但是new 出来的对象会在堆当中持续存在，直到垃圾回收消失

演示

  • 其他类
package com.idayuanshuai.www.Demo4;

public class Outer {
    public void methodOuter(){
        final int num = 10;
        class Inner{
            int num =20;
            public void methodInter(){
                int num =30;
                System.out.println("this is inter method");
                System.out.println(num);
                System.out.println(this.num);
            }
        }
        Inner inner = new Inner();
        inner.methodInter();
    }
}

package com.idayuanshuai.www.Demo4;

public class OuterDemo {
    public void methodDemo(){
        final int num = 2000;
        class interDemo{
            public void methodInter(){
                System.out.println(num);
            }
        }
        new interDemo().methodInter();
    }
}
  • 主类
package com.idayuanshuai.www.Demo4;

public class MyClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.methodOuter();
        new OuterDemo().methodDemo();
    }
}
  • 运行结果
this is inter method
30
20
2000

匿名内部类

  • 如果接口的实现类（或者是父类的子类）只需要使用唯一一次的

  • 那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】

  • 匿名内部类的定义格式：

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

匿名内部类的注意事项

  • 对格式new 接口名称(){ .... }进行解析：
  1. new 代表创建对象的动作
  2. 接口名称就是匿名内部类需要实现的那个接口
  3. { .... }这才是匿名内部类的内容

  • 另外需要注意的几点问题

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

  2. 如果希望多次创建对象，而且类的内容一样，那么就必须使用单独定义的实现类了。

  3. 匿名对象，在调用方法的时候，只能调用唯一一次

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

  5. 匿名内部类是省略了【实现类 / 子类】，但是匿名对象是省略了【对象名称】


注意事项

  • 接口
package com.idayuanshuai.www.Demo5;

public interface MyInterface {
    public abstract void method();
}
  • 主类
package com.idayuanshuai.www.Demo5;

public class MyClass {
    public static void main(String[] args) {
        MyInterface inter = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现");
            }
        } ;
        inter.method();
        new MyInterface() {
            @Override
            public void method() {
                System.out.println("没有对象的匿名实现类");
            }
        }.method();
    }
}
  • 输出结果
匿名内部类实现
没有对象的匿名实现类

类作为成员变量类型

  • 直接上代码演示
  • 作为成员变量的类
package com.idayuanshuai.www.Demo6;

public class Weapon {
    private String code;

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

    public Weapon() {
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}
  • 英雄类
package com.idayuanshuai.www.Demo6;

public class Hero {
    private String name;
    private int age;
    private Weapon weapon;

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

    public Hero() {
    }
    public void attack(){
        System.out.println("我叫"+this.name+"我的年龄为"+this.age+"我用的武器是" +
                weapon.getCode());
    }
    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;
    }
}
  • 主类
package com.idayuanshuai.www.Demo6;

public class HeroClass {
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setAge(20);
        hero.setName("idys");
        Weapon weapon = new Weapon();
        weapon.setCode("code"); //先对weapon变量进行设置
        hero.setWeapon(weapon); //这个地方一定要传入weapon变量
        hero.attack();
    }
}
  • 输出结果
我叫idys我的年龄为20我用的武器是code

接口作为成员变量类型

  • 直接上演示
  • 接口
package com.idayuanshuai.www.Demo7;

public interface Skill {
    public abstract void use();
}
  • 接口实现类
package com.idayuanshuai.www.Demo7;

public class SkillImpl implements Skill{
    @Override
    public void use() {
        System.out.println("技能1-1-1-1-1-1-1-1");
    }
}
  • 英雄类
package com.idayuanshuai.www.Demo7;

public class Hero {
    private String name;
    private Skill skill;

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

    public Hero() {
    }
    public void attack(){
        System.out.println("我叫"+this.name+"施放技能");
        skill.use();
        System.out.println("技能施放完成");
    }
    public String getName() {
        return name;
    }

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

    public Skill getSkill() {
        return skill;
    }

    public void setSkill(Skill skill) {
        this.skill = skill;
    }
}
  • 主类
package com.idayuanshuai.www.Demo7;

public class HeroClass {
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("idys");
        SkillImpl skill = new SkillImpl();
        hero.setSkill(skill);
        hero.attack();
        Skill skill1 = new Skill() {
            @Override
            public void use() {
                System.out.println("技能施放2-2-2-2-2-2");
            }
        };
        hero.setSkill(skill1);
        hero.attack();
        hero.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("技能施放3-3-3-3-3");
            }
        });
        hero.attack();
    }
}
  • 输出结果
我叫idys施放技能
技能1-1-1-1-1-1-1-1
技能施放完成
我叫idys施放技能
技能施放2-2-2-2-2-2
技能施放完成
我叫idys施放技能
技能施放3-3-3-3-3
技能施放完成

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

  • 主类
package com.idayuanshuai.www.Demo7;

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

public class DemoInterface {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        List<String> myResult = addName(list);
        for (int i = 0; i < myResult.size(); i++) {
            System.out.println(myResult.get(i));
        }
    }
    public static List<String> addName(List<String> list){
        list.add("idys1");
        list.add("idys2");
        list.add("idys3");
        list.add("idys4");
        return list;
    }
}
  • 输出结果
idys1
idys2
idys3
idys4

写在最后的话：

  • 无论每个知识点的难易程度如何，我都会尽力将它描绘得足够细致
  • 欢迎关注我的优快云博客，IDYS’BLOG
  • 持续更新内容：
    linux基础 | 数据通信（路由交换，WLAN） | Python全栈 | 云计算
  • 如果你有什么疑问，或者是难题。欢迎评论或者私信我。你若留言，我必回复！
  • 虽然我现在还很渺小，但我会做好每一篇内容。谢谢关注！

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值