07.java面向对象高级-内部类

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量45 收藏
点赞数
分类专栏： java面向对象高级部分 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54915265/article/details/133876379
版权

07.java面向对象高级-内部类

1. 内部类

1. 基本介绍

​ 一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类，嵌套其他类的类又称为外部类。内部类的最大特点就是可以直接访问私有属性，并可以体现类与类之间的包含关系。（类的五大成员：属性、构造器、方法、代码块、内部类）

2. 基本语法
示例
class Outer{//外部类
    class Inner {//内部类
        
    }
}
class Other {//外部其他类
    
}
3. 快速入门
public class Innerclass01 {
    public static void main(String[] args) {
        
    }
}
class Outer {
    private int n1 = 100;//属性
    public void m1() {//方法
        System.out.println("m1()");
    }

    public Outer(int n1) {//构造器
        this.n1 = n1;
    }

    {//代码块
        System.out.println("代码块");
    }
    class Inner {//内部类,在Outer类的内部
        
    }
}
4. 内部类的分类
区分

​ 定义在外部类的局部位置上（比如方法内）；

1. 局部内部类（有类名）
2. 匿名内部类（没有类名）

​ 定义在外部类的成员位置上：

  1. 成员内部了诶（没有static修饰）
  2. 静态内部类（使用static修饰）

2. 局部内部类

1. 介绍

说明：局部内部类是定义在外部类的区域位置，比如方法中，并且有类名。

  1. 可以直接访问外部类的所有成员，包括私有的
  2. 不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final
  3. 作用域：仅仅在定义它的方法或代码块中
  4. 局部内部类----访问-----外部类的成员【访问方式：直接访问】
  5. 外部类—访问-----局部内部类的成员【访问方式：创建对象，在访问（注意：必须在作用域内）】
  6. 外部其他类—不能访问----局部内部类【因为局部内部类地位是一个局部变量】
  7. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用 (外部类.this.成员)去访问
2. 演示（介绍1-5知识点）
public class LocalInnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.m1();
    }
}
class Outer02 {
    private int n1 = 100;
    private void m2(){
        System.out.println("m2()");
    }//私有方法
    public void m1() {//方法
        //1. 局部内部类是定义在外部类的局部位置，通常是在方法中
        //3. 不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。
        // 但是可以使用final修饰，因为局部变量也可以使用final
        final class Inner02 {//4. 局部内部类（本质还是一个类）
            //2. 可以直接访问外部类的所有成员，包括私有的
            public void f1() {
                //5. 局部内部类----访问-----外部类的成员【访问方式：直接访问】
                System.out.println("n1 = " + n1);
                m2();
            }
        }
        //6. 外部类在方法中，可创建Inner02对象，然后调用方法
        Inner02 inner02 = new Inner02();
        inner02.f1();

//        class Inner03 extends Inner02 {
//
//        } //添加final后不能被继承
    }
}

3. 匿名内部类(重要)

1. 介绍

说明: 匿名内部类是定义在外部类的局部位置,比如方法中, 并且没有类名

  1. 本质是类
  2. 内部类
  3. 该类没有名字(实际有名字,系统自己给的名字)
  4. 同时还是一个对象
2. 匿名内部类基本语法
new 类或接口(参数列表) {
    类体
};
3.案例演示
/**
 * 演示匿名内部类的使用
 **/
public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}
class Outer04 {//外部类
    private int n1 = 10;//属性

    public void method() {//方法
        //1. 基于接口的匿名内部类
        //2. 需求：想使用IA接口
        //3. 传统方式写一个类，实现该接口，并创建对象
        //4. 我们希望 Tiger只是使用一次，后面不再使用
        //5. 可以使用匿名内部类简化
        //6. tiger的编译类型是：IA
        //7. tiger的运行类型是：就是匿名内部类
        /*
            底层
            class XXXX implements IA {
                public void cry() {
                    System.out.println("老虎哭");
                }
            }
         */
//        IA tiger = new Tiger();
//        tiger.cry();
        //9. jdk底层在创建匿名内部类Outer04$1,立即就创建了Outer04$1实例，并且吧地址返回给tiger
        //10. 匿名内部类使用一次就不能使用了,对象可以反复使用
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎哭");
            }
        };
        tiger.cry();
        //8. 我们查看匿名内部类的类名用hashcode，得到系统自动分配的类名Outer04$1
        System.out.println("tiger的运行类型=" + tiger);

        //2.1 演示基于类的匿名内部类
        //2.2 father编译类型Father
        //2.3 father运行类型 Outer04$2
        //2.4 底层自动生成类名
        //2.5 同时也直接返回了匿名内部类 Outer04$2
        //2.6 注意("jack") 会传递给构造器
        Father father = new Father("jack") {
            @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };
        System.out.println("father对象的运行类型 = " + father);
        father.test();

        //3.1 基于抽象类的匿名内部类
        Animals animals = new Animals() {
            @Override
            public void eat() {
                System.out.println("小狗吃骨头....");
            }
        };
        animals.eat();

    }
}
interface IA {//接口
    public void cry();
}
//class Tiger implements IA {
//    @Override
//    public void cry() {
//        System.out.println("老虎哭");
//    }
//}
//class Dog implements IA {
//    @Override
//    public void cry() {
//        System.out.println("小狗哭");
//    }

class Father {
    public Father(String name) {//构造器
        super();
    }
    public void test() {

    }
}

abstract class Animals {
    public void eat() {

    }
}

4. 匿名内部类细节

  1. 匿名 内部类的语法比较奇特，请大家注意，因为匿名内部类既是一个类的定义，同事它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，对前面代码分析可以看出这个特点，因此可以调用匿名内部类方法
  2. 可以直接访问外部类的所有成员，包含私有的
  3. 不能添加访问修饰符，因为它的地位就是一个局部变量
  4. 作用域：仅仅在定义它的方法或代码块中。
  5. 匿名内部类—访问----外部成员【访问方式：直接访问】
  6. 外部其他类—不能访问-----匿名内部类（因为匿名内部类的地位就是一个局部变量）
  7. 如果外部类的和内部类中属性重名时，匿名内部类访问的话，默认遵循就近原则，如果要使用外部类的属性 （类名.this.属性名）
public class AnonymousInnerClassDetail {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.f1();
    }
}
class Outer05 {
    private int n1 = 99;
    public void f1() {
        //创建一个基于类的匿名内部类
        Person p = new Person() {
            private int n1 = 100;
            @Override
            public void hi() {
                System.out.println("Overload hi() n1 = " + n1 + " " + Outer05.this.n1);
            }
        };
        p.hi();//动态绑定,运行类型是Outer05$1

        //1. 也可以直接调用
        //2. class 匿名内部类 extends Person {}
        new Person() {
            private int n1 = 100;
            @Override
            public void hi() {
                System.out.println("Overload hi()02");
            }

            @Override
            public void ok(String str) {
                super.ok(str);
            }
        }.ok("jack");

    }
}
class Person {
    public void hi() {
        System.out.println("Person hi()");
    }
    public void ok (String str) {
        System.out.println("Person ok()");
    }
}
//抽象类...接口

5. 匿名内部类实践

1.匿名内部类最佳实践

​ 当做实参直接传递，简洁高效。

public class InnerClassExercise01 {
    public static void main(String[] args) {
        //2. 当实参传递简单高效
        f1(new IL() {
            @Override
            public void show() {
                System.out.println("show()");
            }
        });
        f1(new Picture());//4. 这就是硬编码
    }
    //1.静态方法，形参是接口类型
    public static void f1(IL il) {
        il.show();
    }
}
interface IL {
    void show();
}
//3. 传统方法实现IL接口
class Picture implements IL {
    @Override
    public void show() {
        System.out.println("show() 02");
    }
}
2. 练习

​ 要求：

  1. 有一个铃声接口Bell，里面有个 ring方法。

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

  2. 有一个手机类Cellphone，具有闹钟的功能 alarmclock，参数是Bell类型

  3. 测试手机类的闹钟功能，通过匿名内部类（对象）作为参数打印：起床了

  4. 再传入另一个匿名内部类（对象），打印：上课了

6.成员内部类

1. 说明

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

2. 特征
  1. 可以直接访问外部类的所有成员，包含私有的
  2. 可以添加任意访问修饰符(public、protected、默认、private）因为它的地位就是一个成员
public class MemberInnerClass {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
    }
}
class Outer08 {
    private int n1 = 10;
    public String name = "张三";
    //1. 重要：成员内部类是定义在外部类的成员位置上
    //2. 可以添加任意访问修饰符(public、protected、默认、private）因为它的地位就是一个成员
    private class Inner08 {
        public void say() {
            System.out.println("n1 = " + n1 + " name = " + name);
        }
    }
    //写一个方法展示成员内部类
    public void t1() {
        //使用成员内部类
        Inner08 inner08 = new Inner08();
        inner08.say();
    }
}

  1. 作用域：

    和外部类的其他成员一样，作为整个类体，比如前面的案例，在外部类的成员方法中创建成员内部类对象，再调用方法。

  2. 成员内部类—访问----外部类成员（比如：属性）【访问方式：直接访问】

  3. 外部类—访问----成员内部类【访问方式：创建对象再访问】

  4. 外部其他类—访问----成员内部类（两种方法）

public class MemberInnerClass {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
        System.out.println("================");
        //外部其他类使用成员内部类的两种方式
        //1. outer08.new Inner08(); 相当于 new Inner08()当做是outer08成员
        Outer08.Inner08 inner08 = outer08.new Inner08();
        inner08.say();
        System.out.println("==============");
        //2. 在外部类中,编写一个方法可以返回Inner08对象
        Outer08.Inner08 inner08Instance = outer08.getInner08();
        inner08Instance.say();
    }
}
class Outer08 {
    private int n1 = 10;
    public String name = "张三";
    private void hi(){
        System.out.println("hi()被调用");
    }
    //1. 重要：成员内部类是定义在外部类的成员位置上
    //2. 可以添加任意访问修饰符(public、protected、默认、private）因为它的地位就是一个成员
    protected class Inner08 {
        private int n2 = 100;
        public void say() {
            System.out.println("n1 = " + n1 + " name = " + name);
            hi();
        }

    }
    //返回一个Inner08的实例
    public Inner08 getInner08() {
        return new Inner08();
    }
    //写一个方法展示成员内部类
    public void t1() {
        //使用员内部类
        //创建成员内部类的对象，让后使用相关的属性或方法
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.n2);
    }
}
  1. 当外部类和成员内部类中的成员重名时，会遵循就近原则，假如你要调用外部类的成员（类名.this.成员名）

7.静态内部类

1. 说明

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

2. 特征
  1. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
  2. 可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是一个成员。
  3. 作用域：同其他的成员，为整个类体
public class StaticInnerClass {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.m1();
    }
}
class Outer10 {
    private int n1 = 10;
    public static String name = "张三";
    static class Inner10 {
        //1. 静态内部类是定义在外部类的成员位置
        //2. 有static修饰
        //3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
        //4. 可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是一个成员。
        //5. 作用域：同其他成员为一个类体
        public void say() {
            System.out.println(name);
        }
    }
    public void m1() {
        Inner10 inner10 = new Inner10();
        inner10.say();
    }
}
  1. 静态内部类—访问----外部类（比如：静态属性）【访问方式：直接访问所有静态成员】
  2. 外部类—访问----静态内部类【访问方式：创建对象，再访问】
  3. 外部其他类—访问----静态内部类
  4. 如果外部类和静态内部类的成员重名时，静态内部类访问时，遵循就近原则，如果想访问外部类的成员，则使用 (外部类名.成员) 去访问
绝世小帅
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java面向对象编程总结
weixin_64926930的博客
04-29 1380
在经过十周的java学习后，我对于原本一窍不通的课程又有了新的理解，它也并不是原本我不认识之前高冷的模样，我在慢慢的接触它，认识它，了解它。但现在为止，我对于我所学习的java中的“面向对象编程”做一个个人总结，其中观点仅代表个人，如有错误，敬请纠正。 在我所学习的教材中，将“面向对象编程”分为1,2,3三个章节，我也将我所学习的内容分为三个点来进行总结。 面向对象编程1 什么是面向对象 在这个章节里面，我们知道了什么是面向对象，如果用一个比喻来说的话，面向对象就像是养花一样，买个花瓶，再买束鲜花，不喜
07-面向对象高级（面向对象）
weixin_42688085的博客
12-09 2245
感谢你的路过，希望学生的笔记能给你一点微不足道的参考（1/100） Java面向对象思维导图，[完整Java体系的链接] 一，继承格式 1.1继承的由来？    多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要 继承那一个类即可。多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。通过继承，可以使多种事物之间形成一种关系体系 1.2继承是怎么定义的？     继承就是
头歌平台Java实验：Java面向对象高级
jing13_13的博客
04-18 2428
2.实现Demo接口，完善接口中的show方法，打印输出 “实现了接口中的show方法”System.out.println("实现了接口中的show方法");1.编写MyInterface接口，含一个抽象方法sayHi，返回值为void。System.out.println("接口定义完成");根据提示，在右侧编辑器补充代码，完成接口的书写和接口的实现。实现了接口中的show方法。
Java面向对象之异常处理
qq15035899256的博客
01-28 1812
本文是继续Java面向对象的学习，认识常见的异常，并且使用try..catch..处理异常，认识关键字throws和throw，自定义异常类
Java面向对象高级--匿名内部类
吴英强的技术博客
10-08 1455
1、匿名内部类的定义 内部类：在一个类中，还有另外一个类称为内部类。 匿名内部类：如果一个类在整个操作中只使用一次的话，就可以将其定义为匿名内部类。匿名内部类实在抽象类和接口的基础上发展起来的。 interface A{ public void printInfo() ; //定义接口 } class B implements A{ // 实现接口 public void prin
Java面向对象（知识点整理）
热门推荐
yang642019851的博客
02-22 6万+
文章目录面向对象类与对象匿名对象创建对象的内存分析栈(stack)堆(heap)方法区PC寄存器本地方法栈内部类成员内部类局部内部类匿名内部类静态内部类包装类拆箱和装箱操作字符串转换基本数据类型和包装类型的区别Integer类型的重点抽象类抽象方法不能被实例化常见问题抽象类和普通类的区别接口面向接口编程思想全局常量和抽象方法的简写接口的实现 implements接口的继承 extends接口与抽象类的区别多态多态的体现多态的使用：对象的类型转换InstanceofObject类Object的多态toStri
java面向对象
黎小小的博客
08-21 4万+
本文内容是根据毕晓东老师的视频教程总结而得。包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、static关键字、单例设计模式、继承、多态、内部类、异常、包等java基础知识。 1、面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是一种思想 面向过程强调的是功能、行为 面向对象：将功能封装进对象，强调具备了功能的对象 面向对象是基于面向过程的 面向过程例子： ...
【JAVA学习】2、面向对象编程的核心——对象和类
陈艺荣
09-18 1471
【JAVA学习】面向对象编程的核心——对象和类前言面向过程VS面向对象基础概念优缺点比较面向对象三大基础特性封装继承多态面向对象编程的五大基本原则单一职责原则SRP(Single Responsibility Principle)开放封闭原则OCP(Open－Close Principle)里式替换原则LSP(the Liskov Substitution Principle LS)依赖倒置原则DIP(the Dependency Inversion Principle DIP)接口分离原则ISP(the
Educoder/头歌JAVA——JAVA面向对象：封装、继承和多态
舟舟的博客
12-13 1万+
面向对象的三个基本特征是：封装、继承和多态。 封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）。封装和继承的目的都是：代码重用。而多态则是为了实现另一个目的 —— 接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
Educoder/头歌JAVA——JAVA面向对象：JAVA中的异常
舟舟的博客
12-19 7430
相信大家在学习 Java 的过程中或多或少都遇到了很多错误，这些错误一般都是以Exception结尾的，这些都是 Java 异常类的衍生类，我们会好奇 Java 中的异常到底是怎么工作的，又是如何起作用的，如何在我们程序出错的时候提醒我们的？其中的原理又是什么呢？ 本次实训我们就来系统的学习 Java 中非常重要的模块 —— Java 异常。
Java interview-高级Java面试题2023.zip
01-03
Java基础知识点：包括数据类型、面向对象特性、异常处理、集合框架等。 Java核心技术：如多线程、网络编程、序列化等都有详细的解释和示例。 常用框架：如Spring、MyBatis等框架的使用方法和内部原理都有涉及。 ...
Java面向对象编程头歌
05-23
Java面向对象编程头歌是一个专门为Java开发者设计的学习资源，旨在系统化地讲解Java面向对象编程（Object-Oriented Programming, OOP）的核心概念和实用技巧。该资源结合理论知识和实际案例，通过视频教程、示例代码...
Java面向对象入门至精通
06-15
掌握面向对象的三大特征封装 、 继承 、多态 ；掌握java中的类，变量，方法，构造器，代码块，包，接口，内部类，Lambda表达式，枚举；以及toString()方法、equals方法、hashCode方法、instanceof修饰符等等； 课程...
OOP-II：专注于高级面向对象编程的Java项目
02-18
匿名内部类，lambda函数，性能分析以发现和优化关键代码块。 学生将学习代码开发的行业标准。 学生将设计和实施具有更高级用户界面设计的中型项目，例如具有GUI和事件驱动实现的Web或移动应用程序； 使用版本控制...
Java面向对象的三大特性和面向对象的进阶
04-21
主要简述Java面向对象基础，进阶，高级；从封装、继承、多态、接口、内部类、抽象类和代码块 适合刚开始的新手参考，毕竟我也是自学的 主要可以使用在计算机刚入门的小伙伴或者回来看一看复习一下简单的基础的 ① 凡...
进阶2 探索图形化编程：扩展图形组件与切片开发的魅力
优树搭的博客
05-30 1280
当这些切片成功地通过图形程序串联起来后，在后续进行程序升级或维护时，大家会惊喜地发现，图形程序就如同清晰的路标一般，可以非常便捷地通过图形程序准确地定位到相关切片，并对这些切片进行在线查看、编辑和执行等操作。而且，这些切片的代码长度通常不会太长，相比传统开发的代码，阅读起来要容易得多，这无疑会给系统后续的工作带来极大的便利。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 852
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1186
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 477
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
java面向对象高级
11-05
Java面向对象高级主要包括继承、多态、抽象类、接口、内部类等概念和技术。其中，继承是指一个类可以通过关键字extends继承一个已有的类，从而获得父类的属性和方法，并且可以在子类中增加自己的属性和方法。多态是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值