Java学习笔记——内部类

最新推荐文章于 2024-07-24 22:15:08 发布
原创 最新推荐文章于 2024-07-24 22:15:08 发布 · 215 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Java #内部类

本文详细介绍了Java中的内部类概念，包括成员内部类、局部内部类、静态内部类和匿名内部类的特点与用法，并提供了相应的代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

内部类

1.内部类
    1.1 成员内部类
    1.2 局部内部类
    1.3 静态内部类
    1.4 匿名内部类

第一节 内部类

内部类：一个类中嵌套（包含）另外一个类。包含的类叫内部类，外层类叫外部类。

成员内部类：

局部内部类：

静态内部类：

匿名内部类：

1.1 成员内部类

作为外部类的成员存在，与成员变量和成员方法平级关系。

1.1.1 声明：
public class Out{
    //成员变量
    //成员方法
    //成员内部类
    访问权限 class In{
        //成员变量
        //成员方法
    }
}

1.1.2 语法说明:
成员内部类的访问权限：任意的

1.1.3 如何创建成员内部类的对象：
  由于成员内部类作为外部类的成员存在，若想访问类成员需要通过对象，所以成员内部类对象需要通过外部类    对象创建
    语法：
    //创建外部类对象
    Out o = new Out();
    //通过外部类找到内部类，通过外部类对象创建内部类对象
    Out.In i = o.new In();

    一步完成:
    Out.In i2=new Out().new In();

1.1.4 如何在成员内部类中访问外部类的成员：
    1.当外部类的属性和内部类属性不同名时，可以直接访问
    2.当外部类属性与内部类属性同名时，格式：
        外部类名.this.属性名
        通过以上格式在内部类中访问外部类的同名属性
    3.成员内部类中不能包含静态成员    

1.1.5 成员内部类的字节码文件格式：
    外部类名$内部类名.class

代码实现：

public class Out {
    //成员变量
    int a = 2;
    //成员方法
    public void fun() {
        System.out.println(a);
    }
    //成员内部类
    public class In{
        //成员内部类的成员变量
        int a = 3;
        //成员内部类的成员方法
        public void fun() {
            Out.this.fun();
            System.out.println(a);
            System.out.println(Out.this.a);
        }
    }
}

import memberInnerClass.Out.In;
public class Test {
    public static void main(String[] args) {
        //先创建外部类对象
        Out o = new Out();
        //System.out.println(o.a);
        //o.fun();  
        //创建成员内部类的对象
        //通过外类的对象创建成员内部类对象
        In i = o.new In();
        //System.out.println(i.b);
        i.fun();
    }
}

1.2 局部内部类

作为局部成员存在，和局部变量平级。

1.2.1 声明：
public class Outer{
    //成员变量
    //成员方法
    //局部内部类所在的方法
    public void fun(){
        //功能代码
        //局部内部类
        访问权限 class Inner{
            //局部内部类的成员变量
            //局部内部类的成员方法
        }
    }
}

1.2.2 说明：
局部内部类的访问权限：只能是默认

1.2.3 如何创建局部内部类对象：
直接在局部内部类所在的方法中创建对象并调用方法

1.2.4 如何在局部内部类中访问外部类的属性：
    1.不同名，直接访问
    2.同名，外部类名.this.属性名
    3 局部内部类中不能包含静态成员。
    4 局部内部类中访问局部变量，局部变量必须是final 常量 ，从jdk1.8之后final可以省略
1.2.5 字节码文件：
    外部类名$编号内部类名.class

代码实现：

public class Outer {
    //成员变量
    int a = 3;
    //成员方法
    public void fun() {
        class Inner{}
        System.out.println("外部类的fun");
    }
    //局部内部类所在的方法
    public void fun3() {
        class In{}
        //局部内部类
        class Inner{
            //成员变量
            int a = 10;
            //成员方法
            public void fun() {
                Outer.this.fun();
                System.out.println(a);
                System.out.println(Outer.this.a);
                System.out.println("局部内部类的fun方法");
            }
        }
        Inner i = new Inner();
        i.fun();
    }
}

public class Test {
    public static void main(String[] args) {
        Outer o = new Outer();
        //局部内部类具有作用域，所以调用外部类对象的fun3方法时会声明局部内部类并创建对象调用方法
        o.fun3();
    }
}

1.3 静态内部类（重点）

static关键字用法：修饰成员变量，成员方法，代码块
static关键字的第四个用法，修饰内部类（有要求的）
static修饰的内部类是静态内部类
static只能修饰类成员
使用static修饰的成员内部类是静态内部类

1.3.1 声明：
public class Out{   
    访问权限 static class In{
    }
}

1.3.2 说明：
访问权限：任意的，一般使用public
使用static修饰的内部类，自动提升为普通类，相当于一个独立的类，和外部类级别相同

1.3.3 创建对象：
不需要外部类的对象，可以直接创建静态内部类的对象
    格式：外部类.内部类 标识符 = new 外部类.内部类构造方法

1.3.4 访问外部类的成员：
    1 静态内部类能直接访问外部类的静态成员
    2 非静态的成员只能通过创建外部类对象访问
    3 静态内部类中可以包含静态成员

1.3.5 字节码文件格式：
    外部类名$内部类名.class（与成员内部类一样）

代码实现：

public class OuterClass {
    static String s = "hello";
    int a = 10;
    public void fun() {
        System.out.println("外部类的fun");
    }
    //静态内部类
    public static class InnerClass{
        int b = 20;
        public void fun() {
            System.out.println(s);
            System.out.println();
            System.out.println("内部类的fun");
        }
    }
}

import staticInnerClass.OuterClass.InnerClass;
public class Test {
    public static void main(String[] args) {
        //可以不创建外部类对象，直接创建静态内部类对象
        InnerClass i = new InnerClass();
        i.fun();    
    }
}

1.4 匿名内部类

1.4.1 什么是匿名内部类：
      没有名字的内部类
1.4.2 原理产生原因：
    由于接口和抽象类不能创建对象，若一个接口的实现类只需要使用一次，或一个抽象类的子类只需要使用一次，可以使用匿名内部类，匿名内部类只能创建一个对象

代码实现：

public interface I {
    public abstract void fun();
}

public class Test{
    public static void main(Strng[]args){
        I i = new I(){
            public void fun(){
                //功能代码
            }
        };
        i.fun1();//使用匿名内部类的对象（接口引用）调用匿名内部类中重写的接口中的方法
    }
}



1.4.3 匿名内部类的注意事项：

1 匿名内部类中必须把抽象方法全部实现
2 匿名内部类中可以声明独有的属性和方法，但是由于接口引用不能访问实现类中独有的属性和方法，所以一般不在匿名内部类中声明独有的属性和方法
3 匿名对象：若在匿名内部类中声明了独有的方法或属性，可以使用匿名对象访问，不能通过对象名.方法名()访问。


1.4.4 lambda 表达式
入门使用  
USB leishe= ()->System.out.println("镭蛇和电脑连接成功，开始工作");

代码实现：

public static void main(String[]args){
    //匿名对象调用成员方法
    new I(){
        public void fun(){}
        public void fun1(){
            System.out.println("匿名内部类的fun1");
        }
    }.fun1();//使用匿名内部类的匿名对象调用匿名内部类中独有的方法
    //new Animal().eat();
}

1.4.4 匿名内部类的字节码文件格式：

    测试类$编号.class

    匿名内部类只能使用一次，即便两次声明的匿名内部类完全一致，也是两个匿名内部类

总结

1 内部类  
    1.1 成员内部类
        成员内部类和非静态属性、方法 级别相同

        注意：
            成员内部类可以直接访问外部类的非静态的属性和方法
            成员内部类可以访问外部类的静态属性和方法
            成员内部类中属性及方法和外部类的属性及方法相同时使用  外部类名.this.属性|方法
            成员内部类中不能包含静态属性和方法

    1.2 局部内部类
        局部内部类，是包含在方法中，使用范围只限制在方法内。
        注意：
        局部内部类可以直接访问外部类的非静态的属性和方法
        局部内部类可以访问外部类的静态属性和方法
        如果局部内部类中属性及方法和外部类的属性及方法相同   外部类名.this.属性|方法
        局部内部类不能包含静态属性和方法
        局部内部类使用局部变量，局部变量必须是常量  final修饰

    1.3 静态内部类
        静态内部类：相当于一个外部类
        只有内部类才可以是静态的

        注意：
            静态内部类可以直接访问外部类的静态属性和方法
            静态内部类不能直接访问外部类的非静态属性和方法，需要创建对象访问
            静态内部类中可以包含静态成员

    1.4 匿名内部类
        匿名内部类就是内部类的简写，主要用在接口中创建对象 

        Usb mouse=new Usb(){
            public void service(){

            }

        };
        mouse.service();

面试题

       //要求：使用已知的变量，在控制台输出30，20，10。
      　class Outer {
             public int num = 10;
              class Inner {
                 public int num = 20;
                  public void show() {
                      int num = 30;
                      System.out.println(num); 
                     System.out.println(this.num);
                     System.out.println(Outer.this.num); 
                 }
             }
         }

         class InnerClassTest {
             public static void main(String[] args) {
                 Outer.Inner oi = new Outer().new Inner();
                 oi.show();
             }    
         }
Java进阶学习笔记19——内部类
CCH2024的专栏
05-26 541
Java进阶学习笔记
JAVA学习笔记——第十一章 枚举和注解
最新发布
showy0的博客
12-12 1243
JAVA学习笔记——第十一章 枚举和注解，包括面向对象高级的作业+枚举和注解，干货满满，这一章枚举是重点，注解主要是了解基本的几个和元注解即可
JAVA 常用类
qq_45474921的博客
02-27 242
JAVA 常用类 内部类 概念 在一个内的内部再定义一个完整的类 特点 编译之后可生成独立的字节码文件。 内部类可直接访问外部类的私有成员而不破坏封装。 可为外部类提供必要的内部功能组件 //定义一个内部类 class Outer{ class Inner{} } //生成的字节码文件分别为Outer.class和Outer$Inner.class 分类 成员内部类 在类的内部定义，与实例变量、实例方法同级别的类。 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。
内部类
Janna_woo的博客
05-27 363
内部类概述内部类定义格式内部类的访问特点代码演示成员内部类局部内部类匿名内部类匿名内部类在开发中的使用 内部类概述 内部类：就是在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类 内部类定义格式 public class 类名 修饰符 class 类名{ } } 范例： public class Outer 修饰符 class Inner } }   内部类的访问特点 内部类可以直接访问外部类的成员，包括私有 外部类药访问内.
java基础:内部类
ACBYCL的博客
08-15 245
Java基础：内部类
JavaSE进阶5之内部类
qq_34306228的博客
04-02 613
JavaSE进阶5之内部类内部类内部类的使用场景、作用内部类的分类静态内部类成员内部类局部内部类 内部类 内部类就是定义在一个类里面的类，里面的类可以理解成（寄生），外部类可以理解为（宿主） public class People{ public class Heart{ } } 内部类的使用场景、作用 当一个事务的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构可以选择使用内部类来设计。 内部类通常可以方便访问外部类的成员，包括
007—内部类知识详解总结
xiaodi2016的博客
10-23 367
类的成员 属性 静态属性 非静态属性 方法 静态方法 非静态方法 构造器 代码块 静态代码块 非静态代码块 内部类: 将一个类写到了另一个类的内部 成员内部类 参考 成员变量 常见于源码 静态成员内部类 静态成员变量 常见于源码 局部内部类 局部变量 ...
面向对象编程：Java学习笔记——类与对象设计原则
Java学习笔记主要聚焦于面向对象编程这一核心概念。面向对象编程（Object-Oriented Programming, OOP）是Java编程中的重要理论基础，它将现实世界中的事物抽象为对象，强调了对象的属性（属性描述了对象的状态）和...
Java学习笔记——良葛格
06-12
"Java学习笔记——良葛格"是一份专为初学者设计的教程资料，由良葛格精心编写，旨在帮助读者掌握JDK5.0版本的Java基础知识。JDK（Java Development Kit）是Java开发的核心工具集，包含了编译器、调试器和运行环境等...
JAVA学习笔记——第八章 面向对象中级（一）
showy0的博客
07-24 1945
JAVA学习笔记——第七章 面向对象中级（一）包含IDEA、包、访问修饰符、面向对象三大特Object类和断点调试等基础内容。
Java基础——定义一个外嵌类——内涵内部类
博樽
05-11 461
public class Outer { //定义一个外嵌类 private double index1 = 66.66; int x=10; class Inner { //定义一个内部类 private double index2 = 0.3333; void print() { //测试三个同名变量index的访问方式 double index = 14.14; System.out.p
Java中outer标签的用法
热门推荐
高冷的恒哥
10-29 2万+
在Java开发的过程中，经常会遇到碰到某些情况从而直接跳出循环，一般来说可以使用break直接跳出循环，但是对于嵌套了好几层的循环，break则显得有些不足，这个时候就可以使用Java的标签了，一般使用outer，注意：这里的outer并不是关键字，而仅仅是一个标签。假如我们把outer替换为其他的词语，也是可以的，当然，相应的下面的outer也要替换。下面我们以实例代码来说明： 首先编写一个很
java 内部public类_Java内部类详解
weixin_33910305的博客
03-05 1035
成员内部类public class OuterClass {private String name;private int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void...
java 内部类（inner class）详解
weixin_33824363的博客
06-30 1181
一、为何使用内部类 内部类提供了更好的封装，只有外部类能访问内部类 内部类可以独立继承一个接口，不受外部类是否继承接口影响 内部类中的属性和方法即使是外部类也不能直接访问，相反内部类可以直接访问外部类的属性和方法，即使private 利于回调函数的编写 一个内部类的例子： public class OuterClass { ...
java提高篇（七）-----详解内部类
chenssy 的技术博客
10-25 270
可以将一个类的定义放在另一个类的定义内部，这就是内部类。 内部类是一个非常有用的特性但又比较难理解使用的特性(鄙人到现在都没有怎么使用过内部类，对内部类也只是略知一二)。 第一次见面 内部类我们从外面看是非常容易理解的，无非就是在一个类的内部在定义一个类。 public class OuterClass { private String name ; pr...
题目：在如下例子：pubic class OuterClass {private double d1 = 1.0； // insert code here}，下面哪几个内部类的定义是正确的___
qq_42449963的博客
03-22 1088
题目：在如下例子：pubic class OuterClass {private double d1 = 1.0; // insert code here}，下面哪几个内部类的定义是正确的___ A：class InnerOne { public static double methoda() { return d1; } } B：public class InnerOne { static double methoda() { return d1; } } C：private class InnerOn
08内部类
qq_41662145的博客
10-16 151
内部类 一般内部类 内部类概述 在类中定义的类内部类叫做内部类 内部类访问特点 内部类可以直接访问外部成员，包括私有 外部类要访问内部类的成员，必须创建对象 外部类名.内部类名 对象名 = 外部类对象.内部类对象 public class Main { public static void main(String[] args) { // 创建内部类对...
Java学习笔记——Set接口和Map接口
冷漠的小猿
08-14 4883
Set接口和Map接口 1.了解Set集合的特点 2.掌握Set集合下常用实现类的使用 3.了解Map集合的特点 4.掌握Map集合下常用实现类的使用 5.掌握Map集合的遍历方式 6.掌握Collections工具类 第一节 Set接口 1.1 Set接口常用方法 方法名 描述 ...
Java学习笔记——分支语句（if、switch）
冷漠的小猿
08-09 1558
分支语句 1.三种程序基本结构 2.if语句 3.switch语句 第一节：程序基本结构 顺序结构 选择结构 循环结构 1.1 顺序结构 程序从上到下一行一行的执行代码，没有判断和中转。 1.2 选择结构 有选择性的执行或者跳过指定代码 1.3 循环结构 重复执行一段代码，直到条件不成立。 Java的选择结构使用选择语句来实现： 1 if语句 2 switch语...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值