Java面向对象之内部类

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量452 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wcg920212/article/details/121644320
版权
本文详细介绍了Java中的内部类，包括局部内部类、匿名内部类、成员内部类和静态内部类的定义、分类及使用方法。通过示例展示了如何在不同场景下有效地运用内部类，强调了其直接访问外部类私有属性的特点和在代码简洁性上的优势。
摘要由CSDN通过智能技术生成

文章目录

1、内部类

1.1、定义

一个类的内部又完整的嵌套了另一个类结构，被嵌套的类称为内部类，嵌套其它类的类称为外部类，是我们类的第五大成员【属性、方法、构造器、代码块、内部类】，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系，注意：内部类是难点，同时也是重点，看底层源码时，有大量的内部类

1.2、分类

定义类在局部位置（方法/代码块）：

  1. 局部内部类
  2. 匿名内部类

定义在成员位置：

  1. 成员内部类
  2. 静态内部类
1.3、基本语法

在这里插入图片描述

package InnerClass01;

public class InnerClass01 {  // 外部其他类
    public static void main(String[] args) {

    }
}

class Outer {  // 外部类
    private int n1 = 100;  // 属性

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

    public void m1() {  // 方法
        System.out.println("m1()");
    }

    {  // 代码块
        System.out.println("代码块...");
    }

    class Inner {  //内部类, 在 Outer 类的内部

    }
}
1.4、内部类的分类

在这里插入图片描述

1.4.1、局部内部类的使用

在这里插入图片描述

package LocalInnerClass;

public class LocalInnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.m1();
        System.out.println("outer02 的 hashcode=" + outer02);
    }
}

class Outer02 {  // 外部类
    private int n1 = 100;

    private void m2() {  // 私有方法
        System.out.println("Outer02 m2()");
    }

    public void m1() {  // 方法
        // 1.局部内部类是定义在外部类的局部位置, 通常在方法
        // 3.不能添加访问修饰符, 但是可以使用 final 修饰
        // 4.作用域: 仅仅在定义它的方法或代码块中
        final class Inner02 {  // 局部内部类(本质仍然是一个类)
            // 2.可以直接访问外部类的所有成员, 包含私有的
            private int n1 = 800;

            public void f1() {
                // 5. 局部内部类可以直接访问外部类的成员, 比如下面 外部类 n1 和 m2()
                // 7. 如果外部类和局部内部类的成员重名时, 默认遵循就近原则, 如果想访问外部类的成员
                // 使用 外部类名.this.成员）去访问
                // Outer02.this 本质就是外部类的对象, 即哪个对象调用了 m1, Outer02.this 就是哪个对象
                System.out.println("n1=" + n1 + " 外部类的 n1=" + Outer02.this.n1);
                System.out.println("Outer02.this hashcode=" + Outer02.this);
                m2();
            }
        }
        // 6. 外部类在方法中, 可以创建 Inner02 对象, 然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }
}
1.4.2、匿名内部类的使用

在这里插入图片描述

package LocalInnerClass;

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.需求: 想使用 IA 接口, 并创建对象
        // 2.传统方式, 是写一个类, 实现该接口, 并创建对象
        // 3.需求是 Tiger/Dog 类只是使用一次, 后面再不使用
        // 4. 可以使用匿名内部类来简化开发
        // 5. tiger 的编译类型  IA
        // 6. tiger 的运行类型  就是匿名内部类 Outer04$1
        /*
        我们看底层 会分配 类名 Outer04$1
        class Outer04$1 implements IA {
            @Override
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        }
        */
        // 7. jdk 底层在创建匿名内部类 Outer04$1, 立即马上就创建了 Outer04$1 实例, 并且把地址
        // 返回给 tiger
        // 8. 匿名内部类使用一次, 就不能再使用
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        };
        System.out.println("tiger 的运行类型=" + tiger.getClass());
        tiger.cry();
        tiger.cry();
        tiger.cry();
        // IA tiger = new Tiger();
        // tiger.cry();
        //演示基于类的匿名内部类
        //分析

        // 1. father 编译类型 Father
        // 2. father 运行类型 Outer04$2
        // 3. 底层会创建匿名内部类
        /*
        class Outer04$2 extends Father{
            @Override
            public void test() {
                System.out.println("匿名内部类重写了 test 方法");
            }
        }
        */
        // 4. 同时也直接返回了 匿名内部类 Outer04$2 的对象
        // 5. 注意("jack") 参数列表会传递给 构造器
        Father father = new Father("jack") {
            @Override
            public void test() {
                System.out.println("匿名内部类重写了 test 方法");
            }
        };
        System.out.println("father 对象的运行类型=" + father.getClass());  // Outer04$2
        father.test();
        // 基于抽象类的匿名内部类
        Animal animal = new Animal() {
            @Override
            void eat() {
                System.out.println("小狗吃骨头...");
            }
        };
        animal.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) {  // 构造器
        System.out.println("接收到 name=" + name);
    }

    public void test() {  // 方法
    }
}

abstract class Animal {  // 抽象类
    abstract void eat();
}

在这里插入图片描述

package LocalInnerClass;

public class AnonymousInnerClassDetail {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.f1();
        // 外部其他类 ---> 不能访问 ---> 匿名内部类
        System.out.println("main outer05 hashcode=" + outer05);
    }
}

class Outer05 {
    private int n1 = 99;

    public void f1() {
        // 创建一个基于类的匿名内部类
        // 不能添加访问修饰符, 因为它的地位就是一个局部变量
        // 作用域: 仅仅在定义它的方法或代码块中
        Person p = new Person() {
            private int n1 = 88;

            @Override
            public void hi() {
                // 可以直接访问外部类的所有成员, 包含私有的
                // 如果外部类和匿名内部类的成员重名时, 匿名内部类访问的话,
                // 默认遵循就近原则, 如果想访问外部类的成员, 则可以使用 (外部类名.this.成员) 去访问
                System.out.println("匿名内部类重写了 hi 方法 n1=" + n1 +
                        " 外部内的 n1=" + Outer05.this.n1);
                // Outer05.this 就是调用 f1 的 对象
                System.out.println("Outer05.this hashcode=" + Outer05.this);
            }
        };
        p.hi();  // 动态绑定, 运行类型是 Outer05$1
        // 也可以直接调用, 匿名内部类本身也是返回对象
        // class 匿名内部类 extends Person {}
        // new Person(){
        // @Override
        // public void hi() {
        // System.out.println("匿名内部类重写了 hi 方法, 哈哈...");
        // }
        // @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() " + str);
    }
}
// 抽象类/接口...
1.4.2.1、匿名内部类的最佳实践

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

package LocalInnerClass;

public class InnerClassExercise01 {
    public static void main(String[] args) {
        // 当做实参直接传递, 简洁高效
        f1(new IL() {
            @Override
            public void show() {
                System.out.println("这是一副名画...");
            }
        });
        // 传统方法
        f1(new Picture());
    }

    // 静态方法, 形参是接口类型
    public static void f1(IL il) {
        il.show();
    }
}

// 接口
interface IL {
    void show();
}

// 类->实现 IL => 编程领域 (硬编码)
class Picture implements IL {
    @Override
    public void show() {
        System.out.println("这是一副名画 XX...");
    }
}
1.4.2.2、匿名内部类实践

在这里插入图片描述

package LocalInnerClass;

public class InnerClassExercise02 {
    public static void main(String[] args) {
        /*
        1. 有一个铃声接口 Bell, 里面有个 ring 方法
        2. 有一个手机类 Cellphone, 具有闹钟功能 alarmClock, 参数是 Bell 类型
        3. 测试手机类的闹钟功能, 通过匿名内部类(对象)作为参数, 打印: 懒猪起床了
        4. 再传入另一个匿名内部类(对象), 打印: 小伙伴上课了
        */
        CellPhone cellPhone = new CellPhone();
        // 1. 传递的是实现了 Bell 接口的匿名内部类 InnerClassExercise02$1
        // 2. 重写了 ring
        // 3. Bell bell = new Bell() {
        //      @Override
        //      public void ring() {
        //          System.out.println("懒猪起床了");
        //      }
        //    }
        cellPhone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
        });
        cellPhone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("小伙伴上课了");
            }
        });
    }
}

interface Bell {  // 接口
    void ring();  // 方法
}

class CellPhone {  // 类

    public void alarmClock(Bell bell) {  // 形参是 Bell 接口类型
        System.out.println(bell.getClass());
        bell.ring();  // 动态绑定
    }
}
1.4.3、成员内部类的使用

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package LocalInnerClass;

public class MemberInnerClass01 {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
        // 外部其他类, 使用成员内部类的两种方式
        // 第一种方式
        // outer08.new Inner08(); 相当于把 new Inner08()当做是 outer08 成员
        // 这就是一个语法, 不要特别的纠结
        Outer08.Inner08 inner08 = outer08.new Inner08();
        inner08.say();
        // 第二方式 在外部类中, 编写一个方法, 可以返回 Inner08 对象
        Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
        inner08Instance.say();
    }
}

class Outer08 {  // 外部类
    private int n1 = 10;
    public String name = "张三";

    private void hi() {
        System.out.println("hi()方法...");
    }

    // 1.注意: 成员内部类, 是定义在外部内的成员位置上
    // 2.可以添加任意访问修饰符(public、protected 、默认、private), 因为它的地位就是一个成员
    public class Inner08 {  // 成员内部类
        private double sal = 99.8;
        private int n1 = 66;

        private void hi() {
            System.out.println("Inner08 h1()");
        }

        public void say() {
            // 可以直接访问外部类的所有成员, 包含私有的
            // 如果成员内部类的成员和外部类的成员重名, 会遵守就近原则
            // 可以通过 外部类名.this.属性 来访问外部类的成员
            System.out.println("n1 = " + n1 + " name = " + name + " 外部类的 n1=" + Outer08.this.n1);
            hi();
            Outer08.this.hi();
        }
    }

    // 方法, 返回一个 Inner08 实例
    public Inner08 getInner08Instance() {
        return new Inner08();
    }

    // 写方法
    public void t1() {
        // 使用成员内部类
        // 创建成员内部类的对象, 然后使用相关的方法
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.sal);
    }
}
1.4.4、静态内部类的使用

在这里插入图片描述

package LocalInnerClass;

public class StaticInnerClass01 {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.m1();
        // 外部其他类 使用静态内部
        // 方式 1
        // 因为静态内部类, 是可以通过类名直接访问(前提是满足访问权限)
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();
        // 方式 2
        // 编写一个方法, 可以返回静态内部类的对象实例
        Outer10.Inner10 inner101 = outer10.getInner10();
        System.out.println("============");
        inner101.say();
        Outer10.Inner10 inner10_ = Outer10.getInner10_();
        System.out.println("************");
        inner10_.say();
    }
}

class Outer10 {  // 外部类
    private int n1 = 10;
    private static String name = "张三";

    private static void cry() {
    }

    // Inner10 就是静态内部类
    // 1. 放在外部类的成员位置
    // 2. 使用 static 修饰
    // 3. 可以直接访问外部类的所有静态成员, 包含私有的, 但不能直接访问非静态成员
    // 4. 可以添加任意访问修饰符(public、protected 、默认、private), 因为它的地位就是一个成员
    // 5. 作用域: 同其他的成员, 为整个类体
    static class Inner10 {
        private static String name = "hello world";

        public void say() {
            // 如果外部类和静态内部类的成员重名时, 静态内部类访问的时,
            // 默认遵循就近原则, 如果想访问外部类的成员, 则可以使用 (外部类名.成员)
            System.out.println(name + " 外部类 name= " + Outer10.name);
            cry();
        }
    }

    public void m1() {  // 外部类 ---> 访问 ---> 静态内部类 访问方式: 创建对象, 再访问
        Inner10 inner10 = new Inner10();
        inner10.say();
    }

    public Inner10 getInner10() {
        return new Inner10();
    }

    public static Inner10 getInner10_() {
        return new Inner10();
    }
}

package LocalInnerClass;

public class Test {  // 外部类

    public Test() {  // 构造器
        Inner s1 = new Inner();
        s1.a = 10;
        Inner s2 = new Inner();
        System.out.println(s2.a);
    }

    class Inner {  // 内部类, 成员内部类
        public int a = 5;
    }

    public static void main(String[] args) {
        Test t = new Test();
        Inner r = t.new Inner();  // 5
        System.out.println(r.a);  // 5
    }
}
一切随心走_水瓶
关注
专栏目录
java类放到对象_java类与对象
weixin_35297190的博客
02-23 220
java类一、类和对象类(class)可以看成对具体事物的抽象特征提取。比如：人这个类，拥有器官的属性、拥有走路、劳动、吃喝玩乐的行为等。类不能使用private、protected修饰。对象(Object, instance)可以看成具体的事物，就是类的实例。比如：小明这个人，就是人类的一个实例。二、类1. 类的定义[修饰符1 修饰符2...] class类名 {...}举个粒子：public ...
匿名内部类练习
weixin_60663636的博客
11-24 910
public class InnerClassExercise02 { public static void main(String[] args) { CellPhone cellPhone = new CellPhone(); //解读 //1. 传递的是实现了 Bell接口的匿名内部类 InnerClassExercise02$1 //2. 重写了 ring //3. Bell bell = new Bell().
012Java基础之内部类
qq_44835120的博客
07-04 255
一个类内部又嵌套了一个完整的类结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class），是类的五大成员（属性、方法、构造器、代码块、内部类）之一，内部类最大的特点就是可以直接访问私有属性，并且可以提现类与类之间的包含关系。 基本语法 class Outer{ class Inner{ } } class Other{ } 1、内部类的分类 1、定义在外部类局部位置上（比如方法体内） 1、局部内部类（有类名） （1）可以直接访问外部类的成员，包括私有的
java内部类
朱颜辞镜花辞树
09-02 351
一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class）。是我们类的第五大成员
Java基础——内部类
Wen先森的博客
02-21 512
基本介绍 一个类的内部又完整的嵌套了另一个类机构。被嵌套的类称为内部类（inner class），嵌套的其他类的类称为外部类（outer class）。是我们类的第五大成员【属性、方法、构造器、代码块、内部类】。内部类最大的特点就是可以直接访问私有属性，并且可以体现类和类之间的包含关系。 如果定义在局部位置（方法/代码块中）： (1)局部内部类（有类名） (2)匿名内部类（没有类名） 定义在成员位置： (1)成员内部类（没用static修饰） (2)静态内部类（使用static修饰） 基本语
JAVA面向对象之内部类
蒋固金（jianggujin）的专栏
12-26 2406
内部类在一个类的内部声明的类，称为内部类（也叫内嵌类）。内部类只能在包含它的类中使用，同时它可以看作是该包含类的一段特殊代码，可以直接使用该包含类的变量和方法。 内部类编译后也会形成一个单独的class，但它附属于其包含类。创建内部类的对象时会有一个对外部类对象的引用，所以一般只能在非静态方法里创建内部类对象。 创建一个外部类Outer，在其非静态方法中调用内部类。public class Ou
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计是计算机科学中的一个重要领域，它基于面向对象编程（OOP）的概念，是一种强大的编程范式。在Java中，OOP的核心概念包括类、对象、封装、继承、多态等。这本书"Java面向对象程序设计"由耿祥义和...
Java面向对象和工具类
06-26
Java面向对象和工具类 Java面向对象是Java编程语言的基础，它提供了一种强大的编程模型，能够帮助开发者创建更加灵活、可维护、可扩展的软件系统。Java面向对象的核心概念包括类、对象、继承、多态、封装、抽象等。...
Java语言面向对象编程思想之类与对象实例详解
08-29
Java语言面向对象编程思想之类与对象实例详解 Java语言面向对象编程思想中，类和对象是两个核心概念。类是对对象的抽象描述，它定义了对象的属性和行为；对象是类的实例化，它具有类的所有属性和行为。下面是对类和...
Java面向对象（高级）- 类的成员之四：代码块
11-19
Java面向对象编程中的类成员之一是代码块，这部分内容主要探讨了Java中代码块的概念、分类、用途以及执行时机。代码块在Java中扮演着初始化类或对象成员变量的角色，特别是在需要复杂计算或获取外部信息来设定初始值...
JAVA面向对象程序设计(期末考试试题及答案).zip
06-05
这个压缩包文件"JAVA面向对象程序设计(期末考试试题及答案).zip"包含了学习和复习Java OOP的关键资源，包括一份详细的资源说明文档和期末考试试题及答案的PDF。 资源说明.docx可能涵盖了学习Java OOP的基础概念、...
【Java基础】 13 内部类
Zhou9841的博客
11-29 185
内部类介绍 一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class)，嵌套其他类的类称为外部类(outer class)。 内部类是我们类的第五大成员(属性、方法、构造器、代码块、内部类)，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。 基本语法 class Outer{ //外部类 class Inner{ //内部类 } } class Other{ //外部其他类 } 内部类的分类 定义
9.内部类
rongyuecho的博客
04-16 248
10.9 内部类 基本介绍 一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类（inner class）， 嵌套其他类的类称为外部类（outer class）。 是我们类的第五大成员【思考：类的五大 成员是哪些？属性、方法、构造器、代码块、内部类】， 内部类最大的特点就是可 以直接访问私有属性，并且可以体现类与类之间的包含关系， 注意：内部类是学习的 难点，同时也是重点，后面看底层源码时，有大量的内部类. 基本语法 class Outer{ //外部类
JAVA创建内部类对象
Kidd的博客
04-11 4432
public class Test { public static void main(String[] args){ // 初始化Bean1 //对于成员内部类，必须先产生外部类的实例化对象，才能产生内部类的实例化对象 //创建成员内部类对象的一般形式为： //外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名() //T...
Spring Boot 学习和使用
cesske的博客
09-24 1070
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
工厂模式的介绍及实现
户伟伟的博客
09-25 109
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 372
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 888
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 736
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
Java面向对象深入：内部类与静态特性解析
"内部类练习-java面向对象深入" 在Java编程中，内部类是一个非常重要的面向对象特性，它允许在一个类的内部定义另一个类。在提供的代码示例中，我们看到一个外部类`Outer`和一个内部类`Inner`。在Java中，内部类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值