备案控制台
开发者社区 开发与运维 文章 正文

【JavaSE】内部类

2023-11-21 26
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【JavaSE】内部类

内部类概念

可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件。

public class OutClass {//外部类
  class InnerClass{ //内部类
  }
}

上面的代码中，OutClass是外部类，InnerClass就是内部类。它与普通外部类最大的不同，在于其实例对象不能单独存在，必须依附于一个外部类的实例对象。

局部内部类

局部内部类是定义在外部类的局部位置，通常在方法里。它拥有外部类中所有元素的访问权限。不能添加访问修饰符，因为它就相当于是一个局部变量，但是可以使用final修饰。作用域仅仅只能在定义它的方法或代码块中。

class Outer{ //外部类
    private int a = 1;//私有属性
    private void fun2(){ //私有方法
        System.out.println("Outer fun2()");
    }
    public void fun1(){ 
        System.out.println("Outer fun1()");
        final class Inner{ //局部内部类
            private int a = 2;
            public void funInner(){
                System.out.println(a); // 1 外部变量名重名 就近原则
                //Outer.this本质上就是外部类的对象，即哪个对象调用了fun1，Outer.this就指向哪个对象
                System.out.println(Outer.this.a); // 2
                fun2();
            }
        }
        Inner inner = new Inner();
        inner.funInner();
    }
}
public class InnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.fun1();
    }
}

如果外部类和局部内部类成员重名时，默认遵循就近原则，如果想要访问外部类成员可以使用 外部类名.this.成员名。

匿名内部类（重点重点！！！ ）

匿名内部类就是指没有类名的内部类，必须在创建时使用 new 语句来声明。通常情况下，如果一个方法的参数是接口类型，且该接口只需要实现一次，那么我们就可以通过匿名内部类的形式来进行定义。

基于接口的匿名内部类实例：

class Outer1 {
    private int a = 10;
    public void method() {
        //基于接口的匿名内部类
        IA person = new IA() {
            @Override
            public void eat() {
                System.out.println("正在吃大餐");
            }
        };
        //查看person的运行类型
        System.out.println("person的运行类型：" + person.getClass()); // Outer1$1
        person.eat();
    }
}
//接口
interface IA {
    void eat();
}
class Person implements IA {
    @Override
    public void eat() {
        System.out.println("吃");
    }
}
public class AnonInter {
    public static void main(String[] args) {
        Outer1 outer1 = new Outer1();
        outer1.method();
    }
}
IA person = new IA() {
  @Override
  public void eat() {
    System.out.println("正在吃大餐");
  }
};
//上面这段代码其实就相当于
class Outer1$1 implements IA {
  @Override
  public void eat() {
    System.out.println("正在吃大餐");
  }
}

jdk底层在创建匿名内部类 Outer1$1 时，立即创建了 Outer1$1 实例，并且把地址返回给了person，匿名内部类只能使用一次就不能再使用了。

基于类的匿名内部类和抽象内部类实例：

class Outer2 {
    public void method() {
        //编译类型：Animal
        //运行类型：Outer2$1
        Animal animal = new Animal("小白"){ //基于类的匿名内部类
            @Override
            public void eat() {
                System.out.println("匿名内部类重写了eat()");;
            }
        };
        animal.eat();
        System.out.println(animal.getClass()); //animal的运行类型 Outer2$1
        //编译类型：Robot
        //运行类型：Outer2$2
        Robot robot = new Robot(){ //基于抽象类的匿名内部类
            @Override
            void run() {
                System.out.println("正在奔跑");
            }
        };
        robot.run();
        System.out.println(robot.getClass());// robot的运行类型 Outer2$2
    }
}
class Animal implements IC {
    String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(){
        System.out.println("Animal 在吃东西");
    }
    @Override
    public void run() {
        System.out.println("重写的run()");
    }
}
abstract class Robot { //抽象类
    abstract void run();
}
interface IC { //接口
    void run();
}
//测试
public class InterClass {
    public static void main(String[] args) {
        Outer2 outer2 = new Outer2();
        outer2.method();
    }
}

匿名内部类细节

匿名内部类既是一个类的定义，同时也是一个对象，从语法上看，它即有定义类的特征，也有创建对象的特征。

public class AnonClassDatil {
    public static void main(String[] args) {
        Outer3 outer3 = new Outer3();
        outer3.fun();
    }
}
class Outer3 {
    public void fun(){
        Car car = new Car(){ // 运行类型 Outer3$1
            @Override
            public void speed() {
                System.out.println("重写了speed()");;
            }
        };
        car.speed(); //动态绑定
        //也可以直接调用
        new Car(){
            @Override
            public void speed() {
                System.out.println("直接调用speed()");
            }
        }.speed();
    }
}
class Car {
    public void speed() {
        System.out.println("Car speed()");
    }
}

请看下面的代码

public class InnerExcise {
    public static void main(String[] args) {
        fun(new IQ() { //当做实参直接传递 简洁高效
            @Override
            public void show() {
                System.out.println("正在学习Java内部类");
            }
        });
    }
    public static void fun(IQ iq) { //静态方法 形参是接口类型
        iq.show();
    }
}
interface IQ {
    void show();
}

练习：

有一个铃声接口Bell，里面有一个ring方法，有一个手机类 CellPhone，具有闹钟的功能alarmClock，参数是Bell类型，测试手机类的闹钟功能，通过匿名内部类作为参数，打印 “起床了要迟到了”，再传入另一个匿名内部类，打印 “已经迟到了”。

public class InnerExcise1 {
    public static void main(String[] args) {
        CallPhone callPhone = new CallPhone();
        callPhone.alarmClock(new Bell() { //传递的是实现了Bell接口的匿名内部类
            @Override
            public void ring() {
                System.out.println("起床了要迟到了");
            }
        });
        callPhone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("已经迟到了");
            }
        });
    }
}
interface Bell {
    void ring();
}
class CallPhone {
    public void alarmClock(Bell bell) {
        bell.ring(); // 动态绑定
    }
}

成员内部类

成员内部类是定义在外部类的成员位置，并且没有static修饰，可以访问外部类的所以成员，包括私有成员。可以添加任意访问修饰符，因为它本质上就是一个成员。简而言之，成员内部类就是指没有被static修饰的内部类，也可以称为非静态内部类。

public class InnerExcise2 {
    public static void main(String[] args) {
        Outer5 outer5 = new Outer5();
        outer5.fun();
    }
}
class Outer5 {
    private int a = 10;
    private class Inner { // 可以添加任意访问修饰符
        public void say() {
            System.out.println(a); //可以访问外部类的所有成员，包括私有成员
        }
    }
    public void fun() {
        Inner inner = new Inner();
        inner.say();
    }
}
public class InnerExcise2 {
    public static void main(String[] args) {
        Outer5 outer5 = new Outer5();
        outer5.fun();
        //外部其他类 使用成员内部类的几种方式
        // 第一种 outer5.new Inner() 相当于是把new Inner()当成一个成员
        Outer5.Inner outer51 = outer5.new Inner(); 
        outer51.say();
        Outer5.Inner outer52 = outer5.shawOuter5();
        outer52.say();
    }
}
class Outer5 {
    private int a = 10;
    public class Inner { // 可以添加任意访问修饰符
        public void say() {
            System.out.println(a); //可以访问外部类的所有成员，包括私有成员
        }
    }
    //第二种 定义一个方法 返回一个Inner对象
    public Inner shawOuter5() {
        return new Inner();
    }
    public void fun() {
        Inner inner = new Inner();
        inner.say();
    }
}

如果有重名的成员，会遵守就近原则，如果要访问外部类成员，访问方法和上面的一样，外部类名.this.成员名。

静态内部类

静态内部类和成员内部类的定义类似，但要使用static修饰，所以称为静态内部类。静态内部类不再依附于Outer的实例，而是一个完全独立的类，因此无法引用Outer.this的方式调用。但它可以访问Outer类的private静态字段和静态方法，如果我们把静态内部类移到Outer类之外，就失去了访问private的权限。

public class StaticInnerClass {
    public static void main(String[] args) {
        Outer6 outer6 = new Outer6();
        outer6.fun1();
        //外部其他类访问静态内部类
        //静态内部类可以直接通过类名访问
        Outer6.Fun fun1 = new Outer6.Fun();
        fun1.show();
        //通过定义一个方法返回静态内部类
        Outer6.Fun fun2 = outer6.getFun();
        fun2.show();
    }
}
class Outer6 {
    private static int a = 99;
    private static String str = "java";
    static class Fun {
        public static int a = 999;
        public void show() {
            System.out.println(str);
            System.out.println(a); //同名成员遵循就近原则
            System.out.println(Outer6.a); //通过 外部类名.成员名访问
        }
    }
    public void fun1() {
        Fun fun = new Fun();
        fun.show();
    }
    public Fun getFun() {
        return new Fun();
    }
}

静态内部类中只能访问静态外部类的静态属性和方法

文章标签：
Java
努力的小徐
目录
相关文章
努力的小徐
|
5月前
|
Java
【JavaSE】详解final关键字
【JavaSE】详解final关键字
努力的小徐
24 0
小胡_不糊涂
|
8月前
|
Java 编译器
【JAVASE】继承 中
【JAVASE】继承
小胡_不糊涂
30 0
请回答1024
|
3天前
javaSE&多态
javaSE&多态
请回答1024
9 1
小胡_不糊涂
|
8月前
|
安全 Java
【JAVASE】多态 下
【JAVASE】多态
小胡_不糊涂
29 0
爱吃大白菜.
|
10月前
|
Java 程序员 编译器
【JavaSE】一起学继承
【JavaSE】一起学继承
爱吃大白菜.
59 0
小胡_不糊涂
|
8月前
|
Java
【JAVASE】继承 下
【JAVASE】继承
小胡_不糊涂
24 0
小胡_不糊涂
|
8月前
|
Java 程序员
【JAVASE】继承 上
【JAVASE】继承
小胡_不糊涂
24 0
小胡_不糊涂
|
8月前
|
Java 编译器
【JAVASE】多态 上
【JAVASE】多态
小胡_不糊涂
32 0
Y君的进化史
|
9月前
|
Java
JavaSE/内部类
JavaSE/内部类
Y君的进化史
33 0
Designer小郑
|
10月前
|
Java 定位技术 Android开发
Java的内部类和匿名类 ， 您了解过吗？
Java的内部类和匿名类 ， 您了解过吗？
Designer小郑
56 0

热门文章

最新文章

  • 1
    TCP三次握手与四次分手
  • 2
    袋鼠云数据中台专栏（五）：数栈，企业级一站式数据中台PaaS
  • 3
    利用Serverless Kubernetes和Kaniko快速自动化构建容器镜像
  • 4
    CentOS7(6.5)升级docker到较新版
  • 5
    如何判断自己IP是内网IP还是外网IP
  • 6
    模型社区实战训练营首开,开源让代码更有趣!
  • 7
    深入分析bgp选路规则(上)
  • 8
    2-Sat+输出可行解(个人模版)
  • 9
    一次ORA-00130: invalid listener address错误
  • 10
    PathFinding.js – 综合性的 JavaScript 路径查找库
  • 1
    AI大咖说-如何评价论文的创新性
    15
  • 2
    实时计算 Flink版产品使用合集之在Flink Stream API中，可以在任务启动时初始化一些静态的参数并将其存储在内存中吗
    15
  • 3
    实时计算 Flink版产品使用合集之支持在同步全量数据时使用checkpoint吗
    13
  • 4
    51.从键盘上输入任意两个数和一个运算符（+、-、*、/），根据输入的运算符对两个数计算，并输出结果
    12
  • 5
    50.编写程序，逆转字符串
    13
  • 6
    49.输入一字符串，检查是否回文 （回文是指正反序相同，如，LeveL）
    9
  • 7
    48.输入任意正整数，编程判断该数是否为回文数(回文数是指从左到右读与从右到左读一样，如12321）
    8
  • 8
    47.从键盘上输入一个3*3的矩阵，并求其主对角线元素的和
    10
  • 9
    46.编写程序在屏幕上显示如下图形
    7
  • 10
    45.将3×3二维数组转置，并输出
    11

    • 相关电子书

    更多
  • Java基础入门(四)-泛型、反射、注解
  • 低代码开发师（初级）实战教程
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考