韩顺平java教程个人笔记 内部类（局部内部类、匿名内部类、成员内部类、静态内部类）

最新推荐文章于 2024-10-01 22:30:45 发布
最新推荐文章于 2024-10-01 22:30:45 发布
阅读量916 收藏 25
点赞数 24
分类专栏： 韩顺平Java笔记 文章标签： java 笔记 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52804277/article/details/134961351
版权

内部类

一个类的内部又完整的嵌套了另一个类结构，被嵌套的类称为内部类，嵌套其他类的类称为外部类。内部类是类的第五大成员。

基本语法

class Outer{//外部类

​ class Inner {//内部类

​ }

}

没有嵌套和被嵌套关系的类称为 外部其他类。

内部类的分类

  • 定义在外部类的局部位置上（比如某个方法中）
    • 局部内部类（有类名）
    • 匿名内部类（没有类名）
  • 定义在外部类的成员位置上
    • 成员内部类（没有static修饰的类）
    • 静态内部类（有static修饰的类）

局部内部类

局部内部类定义在外部类的局部位置上，通常在方法中，且有类名

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

  2. 不能添加访问修饰符，因为它的地位就是一个局部变量。

局部变量不能使用修饰符，但是可以使用final修饰

  1. 作用域：仅仅在定义它的方法或代码块中

  2. 局部内部类 访问 外部类的成员：直接访问

  3. 外部类 访问 局部内部类的成员：创建对象再访问(必须在作用域内)

  4. 外部其他类 不能访问 局部内部类（因为局部内部类地位和局部变量一样）

  5. 如果外部类 和局部内部类的成员重名时，遵循就近原则。

    • 如果想访问外部类的成员，可以使用 外部类名.this.成员 去访问
//localInnerClass.java

package com.learnJava.innerClass;

public class localInnerClass {
    public static void main(String[] args) {
        //创建外部类的对象并调用 m1方法
        Outer outer = new Outer();
        outer.m1();
        /** 调用m1后的运行过程
         *  创建 Inner 类 -> 发现内部需要创建 Inner对象 -> 创建对象
         *  -> 调用 f1()-> 调用 m2()
         */

        //用Hashcode 检验 outer 和 Outer.this是否为同一个对象
        System.out.println("outer对象 的Hashcode:" + outer);


    }

}

class Outer {
    private int n1 = 100;//私有属性
    private void m2(){
        System.out.println("Outer 的 m2()方法");
    };//私有方法
    public void m1(){//局部内部类通常定义在方法中

        final class Inner{//2. 不能添加修饰符但可以用final修饰
            private int n1 = 800;//内部类中定义一个和外部类属性同名的属性n1
            public void f1(){//1.  可以直接访问外部类的包括私有在内的所有成员
                System.out.println("n1=" + n1);//4. 访问外部类方式：直接访问。但是第7点内部类定义了一个重名的属性，此处遵循就近原则变为访问内部类的n1
                System.out.println("外部类的n1:" + Outer.this.n1);//外部类的n1改成用 外部类名.this.n1 来访问
                /** 解释为什么用Outer.this：
                 *  1. 存在访问冲突时，需要准确找到属性
                 *  2. Outer.this 本质上是Outer类的对象，即哪个对象调用了 m1, 哪个对象就是 Outer.this
                 *  3. 主函数创建了 Outer对象 outer, 并调用了m1, 所以outer就是这里的 Outer.this
                 */
                m2();
                System.out.println("Outer.this 的Hashcode:" + Outer.this);
            }
        }

        /** 如果用final修饰了class Inner,那么就不能在方法中再继承Inner类了
         *  class Inner02 extends Inner { }
         */

        //5. 外部类访问内部类方式：在作用域中，通过创建内部类对象来访问成员
        //创建在方法外则编译器找不到内部类在哪
        Inner inner = new Inner();
        inner.f1();
    }
    {//3. 作用域为定义它的方法或代码块中
        class Inner03 {}
    }

}

输出结果


n1=800
外部类的n1：100
Outer 的 m2()方法
Outer.this 的Hashcode:com.learnJava.innerClass.Outer@6d03e736
outer对象 的Hashcode:com.learnJava.innerClass.Outer@6d03e736

匿名内部类

匿名内部类定义在外部类的局部位置中

  • 是一个类
  • 是一个内部类
  • 没有名字
  • 是一个对象

基本语法

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

​ 类体

};

基本使用

下面给出了基于接口和类的使用方式。基于抽象类时记得实现内部的抽象方法。

//AnonymousInnerClass.java


package com.learnJava.innerClass;


public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.method();

    }
}
class Outer02 {
    private int n1 = 10;
    public void method(){//方法
        /** 一、基于接口的匿名内部类
         * 需求：使用IA接口创建对象
         * 1. 传统方式：写一个类实现该接口并创建对象
         * 2. 匿名方式: 如果一个类只使用一次，则可以选择用匿名方式
         */

        IA tiger1 = new Tiger();//传统方式：创建类再创建对象
        tiger1.cry();

        //匿名方式：不能直接创建接口对象，但是可以后面跟着实现该接口，而不用单独创建一个类
        IA tiger2 = new IA(){//编译类型：IA, 运行类型：匿名内部类
            @Override
            public void cry() {
                System.out.println("匿名-老虎叫");
            }
        };//记得加分号
        tiger2.cry();
        System.out.println("tiger2的运行类型：" + tiger2.getClass());//用来查看匿名内部类返回的类型
        /**
         * 匿名内部类底层实现方式也相当于创建了一个类来实现接口，创建完后把地址返回给tiger2
         * 但是对于开发者而言效率更高了
         * class Outer02$1 implements IA(){
         *     @Override
         *     public void cry() {
         *         System.out.println("匿名-老虎叫");
         *     }
         * }
         *
         */

        /*
            二、基于类的匿名内部类
         */
        Father father = new Father("jack"){//此处 father的编译类型是 Father, 但运行类型不是 Father,而是 匿名内部类

            @Override
            public void test() {
                System.out.println("匿名内部类重写了Father类中的test()");
            }
        };
        System.out.println("father 的运行类型" + father.getClass());

        /*  
         *   类的匿名内部类底层实现：
         * class Outer02$2 extends Father(){
         *      @Override
         *      public void test() {
         *         System.out.println("匿名内部类重写了Father类中的test()");
         *      }
         * }
         */
    }
}

interface IA{//接口
    public void cry();

}

class Tiger implements IA{//传统方式
    @Override
    public void cry() {
        System.out.println("对象-老虎叫");
    }
}
class Father{//类
    public Father(String name) {//构造器

    }
    public void test(){//方法

    }
}

输出结果

对象-老虎叫
匿名-老虎叫
tiger2的运行类型：class com.learnJava.innerClass.Outer02$1
father 的运行类型class com.learnJava.innerClass.Outer02$2

注意事项

和局部内部类相似处：

  1. 不能添加访问修饰符，因为它地位等同于局部变量
  2. 作用域：仅仅在定义它的方法或代码块中
  3. 匿名内部类 直接访问 包括私有在内 的外部类成员
  4. 外部其他类 不能访问 匿名内部类
  5. 如果外部类 和局部内部类的成员重名时，遵循就近原则。
    • 如果想访问外部类的成员，可以使用 外部类名.this.成员 去访问

特点：

​ 匿名内部类既是一个类的定义，同时本身也是一个对象。

//AnonymousInnerClassDetail.java

public class AnonymousInnerClassDetail {
    public static void main(String[] args) {
        OuterDetail outerDetail = new OuterDetail();
        outerDetail.f1();
    }
}
class Person{
    public void hi(){
        System.out.println("Person 的 hi()");
    };
}

class OuterDetail{
    private int n1 = 99;
    public void f1(){
        Person p = new Person(){
            @Override
            public void hi(){
                System.out.println("匿名内部类 的 hi()");
            }
        };
        System.out.println(p.getClass());
        p.hi();//动态绑定，运行类型为OuterDetail$1

        //也可以这样直接调用方法
        new Person(){
            @Override
            public void hi(){
                System.out.println("匿名内部类 的 hi()");
            }
        }.hi();
    }
}

实践

  1. 匿名内部类可以当做实参直接传递。创建的对象只使用一次时，会更方便。（表现在代码上即：函数的括号中直接new对象出来）

  2. 起床案例：

    • 有一个铃声接口Bell，里面有ring方法
    • 有一个手机类Cellphone，闹钟功能alarmClock，参数是Bell类型
    • 测试手机类的闹钟功能，通过匿名内部类作为参数，打印：“起床了"
    • 再传入另一个匿名内部类，打印：“上课了"
//AnonymousInnerClassExercise.java


public class AnonymousInnerClassExercise {
    public static void main(String[] args) {
        Cellphone cellphone = new Cellphone();
        cellphone.alarmClock(new Bell() {//通过匿名内部类创建接口
            @Override
            public void ring() {
                System.out.println("起床了");
            }
        });
        cellphone.alarmClock(new Bell() {//每次调用alarmClock()，参数会进行动态绑定
            @Override
            public void ring() {
                System.out.println("上课了");
            }
        });
    }
}

interface Bell {
    void ring();
}
class Cellphone {
    public void alarmClock(Bell bell) {
        bell.ring();
    }
}

成员内部类

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

  1. 可以直接访问外部类的所有成员
  2. 可以添加任意访问修饰符，也即地位和成员相同
  3. 作用域：整个外部类体中都可使用
  4. 成员内部类 直接访问 外部类
  5. 外部类 创建对象再访问 内部类
  6. 外部其他类 三种访问 内部类
  7. 如果外部类 和局部内部类的成员重名时，遵循就近原则。
    • 如果想访问外部类的成员，可以使用 外部类名.this.成员 去访问
//MemberInnerClass.java

package com.learnJava.innerClass;

public class MemberInnerClass {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        System.out.println("外部类调用结果：");
        outer08.t1();//外部类通过调用方法来使用成员内部类

        System.out.println("\n外部其他类调用结果:");
        //外部其他类如何创建内部类？（注意这里是外部其他类，不是外部类）
        //1. 通过创建对象来new一个
        Outer08.Inner08 inner08 = outer08.new Inner08();
        inner08.say();

        //2. 在外部类编写一个方法，用来返回内部类
        Outer08.Inner08 inner08instance = outer08.getInner08Instance();
        inner08instance.say();

        //3. 将1和2合起来，熟练之后可以用
        new Outer08().new Inner08().say();

    }
}

class Outer08{
    private int n1 = 10;
    public String name = "张三";
    //以下成员内部类定义在和属性、方法平级的位置上
    class Inner08 {
        public void say(){
            //可以直接访问外部类的所有成员
            System.out.println("n1=" + n1 + " name=" + name);
        }
    }

    //写一个方法用来返回Inner08实例，对应主函数中的第2点
    public Inner08 getInner08Instance(){
        return new Inner08();
    }

    //写一个方法来使用成员内部类
    public void t1(){
        Inner08 inner08 = new Inner08();
        inner08.say();
    }
}

输出结果

外部类调用结果：
n1=10 name=张三

外部其他类调用结果:
n1=10 name=张三
n1=10 name=张三
n1=10 name=张三

静态内部类

静态内部类是定义在外部类的成员位置的，有static修饰

  1. 可以直接访问外部类的所有静态成员，但不能直接访问非静态成员

  2. 可以添加任意访问修饰符

  3. 作用域为整个类

  4. 访问方式和成员内部类相似，但要加上静态成员相关的限制

★梦之蓝★
关注
专栏目录
java韩顺平学习笔记4（内部类）
weixin_48170312的博客
07-30 124
类的五大成员：属性，方法，构造器，代码块，内部类。
韩顺平笔记(HTML_CSS_JavaScript_RegExp)
10-19
韩顺平笔记(HTML_CSS_JavaScript_RegExp),内容和我看的视频里的是一样的
【韩顺平Java笔记】第5章：程序控制结构
最新发布
随手写写
10-01 795
让程序有选择的的执行,分支控制有三种单分支 if双分支 if-else多分支 if-else if -…-else在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。老师建议: 不要超过 3 层 （可读性不好）将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while 均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过 3 层, 否则，代码的可读性很差】
韩顺平笔记.zip
09-28
韩顺平 老师笔记，java JavaScript linux oracle笔记
笔记 -- Spring By 韩顺平
zhaorubinsujia的博客
07-05 756
Spring 在spring2.5中，是有applicationContext.xml 配置文件的,名字可以随意取，在工作项目中，FcoApiServletApplicationContextConfig 类进行配置。 在容器文件中配置Bean（service/dao/domain/action/数据源），bean元素的作用是，当我们spring框架加载的时候。spring就会自动创建一个be...
韩顺平—— LINUX学习笔记
dahuzi的专栏
05-29 2009
LINUX----（韩顺平版） LINUX 笔记 2010-01-04 08:46:32 阅读468 评论1   字号：大中小 订阅 学习LINUX的两个方向： LINUX系统管理员： LINUX程序员：PC平台开发LINUX软件工程师，LINUX嵌入式开发（单片机，芯片）开发，   学完本书可以完全可以胜任LINUX系统管理员 开源，免费，稳定，安全，处理多并发得到业界认可 LI
韩顺平老师所有课程笔记
04-13
本文档包含韩顺平老师的linux，Java，Oracle，PHP，struts,j2ee,javascript课程笔记
韩顺平java笔记完整版.zip（无笔记，只是代码）
10-10
通过韩顺平老师的Java笔记完整版代码，学习者可以深入理解上述知识点，并通过实践加深对Java编程的理解和掌握。这些代码示例涵盖了广泛的Java应用领域，对于初学者和进阶开发者都是宝贵的资源。
韩顺平编写的java学习笔记(全)
10-20
### 韩顺平编写的Java学习笔记概览 #### Java平台分类与运行机制 - **J2SE（Java 2 Platform, Standard Edition）**: 标准版Java开发平台，适用于桌面应用程序开发。 - **J2EE（Java 2 Platform, Enterprise ...
内部类 Java 韩顺平学java2021 局部内部类、匿名内部类 局部内部类、匿名内部类
qq_60331042的博客
07-19 321
内部类 Java 韩顺平学java2021 局部内部类、匿名内部类 局部内部类、匿名内部类
韩顺平java视频教程百度网盘地址.txt
10-08
韩顺平java基础视频百度网盘地址，欢迎需要学习java的基础的过来下载参考学习，失败的请留言我，我重新上传新的百度网盘地址
Java初学笔记13-【局部内部类、匿名内部类、成员内部类、静态内部类】
爱吃凉拌辣芒果的博客
10-13 324
Java初学笔记1312345678910 1 2 3 4 5 6 7 8 9 10
韩顺平_java设计模式笔记
11-07
先是看到了韩老师的23种设计模式讲解视频觉得很不错，只不过看了一遍后马上就忘记了；有了这个笔记可以随时快速复习之前遗忘的知识内容。23中java设计模式结合生活中用例进行讲解以及spring源码中存在的设计模式才知道原来设计模式如此重要，视频教程链接如下：https://study.163.com/course/courseMain.htm?courseId=1209569921，或者直接在网易云搜索设计模式
韩顺平笔记总结
m0_55901666的博客
11-25 172
韩顺平笔记总结
java韩顺平学习笔记
yuanzic1的博客
08-30 1159
java笔记，仅代表个人学习情况，笔记不全请谅解！
韩顺平jsp学习笔记
aminxu的专栏
12-09 3435
jsp u  j2ee核心13种技术： 程序员必须掌握的技术：java，servlet，jsp。 13种技术规范. u  j2ee程序员修炼成精法门 u  jsp 版本的用户管理系统：将servlet版本改为jsp版本，只使用jsp技术完成（modle1模式开发） 并且在后面可通过jsp版的用户管理系统的改写，非常自然过渡到mv设计模式，更进一步到mvc设计模式 开发工具：myecl
韩顺平JS笔记全
09-27
韩顺平JS笔记全 韩顺平JS笔记全韩顺平JS笔记全韩顺平JS笔记全韩顺平JS笔记全韩顺平JS笔记全韩顺平JS笔记全韩顺平JS笔记全
java入门韩顺平所有资源笔记等B站对应学习视频
04-25
1) 以培养编程思想、提升编程能力为核心目标，达到能分析业务需求，并能用代码实现水平 2) 抛弃传统的以强灌知识点授课方式，每个阶段都有多个项目把知识点真正应用到项目中, 小伙伴在学习过程中有满满成就感，充分...
Java基础_内部类、静态内部类、成员内部类、局部内部类、匿名内部类 （转）
libeyond_的专栏
07-14 770
http://www.cnblogs.com/nliao/p/3308690.html
韩顺平老师Java基础听课笔记（一）
kxvsdih的博客
03-25 1075
Java运行机制： 1.javac 编译.java文件 生成.class文件(javac Hello.java) 2. java运行编译后的.class文件 （java Hello）编译后可在Windows、Linux、mac上运行（一次编译多次运行） 3.在控制台按tab建可以实现命令补全 java开发注意事项： 1.类名必须与文件名相同 2.Java源文件以.java为扩展名，源文件的基本组成部分是类（clas...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值