全面掌握 Java 内部类

java内部类 高效的课件,详细的内容介绍,针对性的代码展示,提高性的练习题目。适合新手或者基础薄弱人员学习,一个PPT解决你编程中常见的错误,最重要的是一人下载多人使用,不受限制,没有隐藏密码 立即下载

一直以来以为自己对 java 基础甚是清楚,然而面试时却连内部类和静态内部类的区别都无法回答圆满,so~重新学习一遍,彻底掌握内部类。

内部类是一种非常有用的特性,它可以把一些逻辑相关的类组织在一起,并控制位于内部的类的可视性,下文中内部类均指非静态内部类。

内部类的学习分为以下10个知识点:

1.创建内部类与连接外部类
2.内部类与向上转型
3.局部内部类
4.匿名内部类
5.局部内部类和匿名内部类
6.嵌套类
7.内部类的继承
8.内部类可以被覆盖吗
9.为什么需要内部类
10.内部类标识符

1、创建内部类与连接外部类

public class Car {
    private int speed = 100;

    class Tyre {
        int getSpeed() { //访问外部类成员
            return speed;
        }
        Car getCar() { //通过.this获取外部类对象
            return Car.this;
        }
    }

    public static void main(String[] args) {
        Car car = new Car();
        Car.Tyre tyre = car.new Tyre();
        tyre.getSpeed();
        System.out.println(car == tyre.getCar()); // true
    }
}

要想创建内部类的对象,必须使用外部类的对象,如上,且必须地具体指明这个对象的类型:OuterClassName.InnerClassName,然后通过 OuterClassInstance.new InnerClassName() 来创建内部类对象。

内部类对象会暗暗连接到创建它的外部类对象上,捕获外部类的对象引用,然后在内部类中访问此外部类的成员时,就是通过这个引用来访问的,并且拥有其外部类的所有元素的访问权。正是由于此原因,Android 中非静态内部类创建静态实例才会造成内存泄漏。

在内部类中通过 OuterClassName.this 可获取外部类对象,如上代码中通过 Car.this 获取 Car 类对象。

2、内部类与向上转型

当将内部类向上转型为基类,尤其是转型为一个接口的时候,此内部类能够隐藏这个接口的实现,如下例:

interface cost{
    double getPrice();
}
public class Car {
    private int speed = 100;
    
    class Tyre implements cost{
        double originalPrice = 100;
        
        @Override
        public double getPrice() {
            return originalPrice * 0.75;
        }
    }

    public static void main(String[] args) {
        Car car = new Car();
        cost tyre = car.new Tyre(); //向上转型
        tyre.getPrice();  // 75.0
    }
}

3、局部内部类

前面提到的都是处于外部类中的内部类,而内部类也可以定义在一个方法里面或者在任意的作用域中,这么做有以下两个理由:

1.如实现某接口的内部类,可以在方法中创建并返回对其的引用

2.要解决一个复杂的问题,需要创建一个类来辅助,但不希望这个类是公共可用的

例1:在方法中定义内部类:

public class Car {
    private int speed = 100;

    cost getTyre() { //方法内部
        class Tyre implements cost {
            double originalPrice = 100;
            @Override
            public double getPrice() { //打折操作
                return originalPrice * 0.75;
            }
        }
        return new Tyre();
    }
    
    public static void main(String[] args) {
        Car car = new Car();
        cost tyre = car.getTyre();
        tyre.getPrice();  // 75.0
    }
}

例2:在任意作用域中定义内部类:

public class Car {
    private boolean hadTyre = true; //是否有轮胎

    cost getTyre() {
        if (hadTyre) { //任意作用域中
            class Tyre implements cost {
                double originalPrice = 100;

                @Override
                public double getPrice() { //打折操作
                    return originalPrice * 0.75;
                }
            }
            return new Tyre();
        }else{
            return null;
        }
    }

    public static void main(String[] args) {
        Car car = new Car();                 
        cost tyre = car.getTyre();
        tyre.getPrice();  // 75.0
    }
}

定义在一个方法里面或者在任意的作用域中的内部类也叫作局部内部类,局部内部类不能有 private 等访问说明符,因为它不是外部类的一部分,但是它可以访问当前代码块内的常量以及外部类中的所有成员:

public class Car {
    private boolean hadTyre = true;
    private double coupon1 = 10; // 外部类成员(10元优惠券)

    cost getTyre() {
        if (hadTyre) {
            double coupon2 = 5; // 代码块内常量(5元优惠券)
            class Tyre implements cost {
                double originalPrice = 100;
                @Override
                public double getPrice() {
                    return originalPrice * 0.75 - coupon1 - coupon2;
                }
            }
            return new Tyre();
        } else {
            return null;
        }
    }

    public static void main(String[] args) {
        Car car = new Car();
        cost tyre = car.getTyre();
        System.out.print(tyre.getPrice());  // 60.0
    }
}

书中说可以访问当前代码块内的常量,这里有点不解,coupon2 是常量?

4、匿名内部类

上例中 getTyre() 方法要创建一个 cost 对象,从 cost tyre = car.getTyre(); 看出我们并不关心内部类的名字 Tyre,只要返回的是 cost 类对象就足够了,所以这里可以用匿名内部类来实现,顾名思义,它没有名字,如下例:

public class Car {
    cost getTyre(double p) {
        return new cost() {
            double coupon = 10; // 10元优惠券
            private double price = p; //原价
            @Override
            public double getPrice() {
                return price - coupon;
            }
        };
    }
    public static void main(String[] args) {
        Car car = new Car();
        cost tyre = car.getTyre(100);
        System.out.print(tyre.getPrice());  // 90.0
    }
}

你可能会有疑问,这段代码可以编译通过吗?应该是 getTyre(final double p) 吧?确实,在匿名内部类中使用一个在其外部定义的对象,那么编译器必须要求其参数引用是 final 类型,以上代码在低于 Java 8 的版本编译不会通过,但是在 Java 8 版本不用 final 修饰局部变量也可以编译通过,只不过不能修改值,只能打印输出或赋值给其他变量。

5、局部内部类和匿名内部类

首先来看局部内部类和匿名内部类的对比实现:

public class Car {
    private double coupon2 = 5;
    cost getTyre1(double p) { //局部内部类
        class Tyre implements cost {
            double coupon = 10;
            private double price = p;

            @Override
            public double getPrice() {
                return price - coupon - coupon2;
            }
        }
        return new Tyre();
    }
    cost getTyre2(double p) { //匿名内部类
        return new cost() {
            double coupon = 10;
            private double price = p;

            @Override
            public double getPrice() {
                return price - coupon - coupon2;
            }
        };
    }
}

getTyre() 方法用来创建一个 cost 类对象,我们分别使用局部内部类和匿名内部类实现了这个功能,它们具有相同的行为和能力,既然局部内部类的名字在方法外是不可见的,那为什么我们仍然使用局部内部类而不是匿名内部类呢?唯一的理由是:我们需要一个已命名的构造器,或者需要重载狗仔器,而匿名内部类只能用于实例初始化,所以使用局部内部类而不使用匿名内部类的另一个理由就是:需要不止一个该内部类的对象。

6、嵌套类

如果不需要内部类对象与其外部类对象之间有联系,那么可以将内部类声明为 static,即静态内部类,也称嵌套类,静态内部类和非静态内部类的最大区别就是非静态内部类对象隐士的保存了一个外部类对象的引用,这意味着:

1.不需要外部类的对象就可以创建静态内部类的对象

2.不能从静态内部类的对象中访问非静态的外部类对象

3.静态内部类中可以定义静态或者非静态的成员,而非静态内部类则不能有静态成员。

public class Car {
    private static double price = 100; 
    static class Tyre implements cost {
        private static double coupon = 5; // 3.若为非静态内部类则无法定义为 static 类型
        @Override
        public double getPrice() {
            return price; // 2.若 price 不为 static 则无法访问
        }
    }
    public static void main(String[] args) {
        Car.Tyre tyre = new Car.Tyre(); // 1.静态内部类的创建不依赖外部类对象
    }
}

这也是静态内部类和内部类的关键区别。此外静态内部类也可定义在接口内部:

interface cost {
    class Price { } // 默认为 public 、static
}

如果你想要创建某些公共代码,使得它们可以被某个接口的所有不同实现所公用,那么使用接口内部嵌套类会显得很方便。

7、内部类的继承

怎么继承自一个内部类?内部类的构造必须依赖其外部类对象,所以在继承内部类的时候,事情会变得复杂,比如我们要继承自 Size 类:

class Tyre{
    class Size{}
}

可以这样写:

public class TyreSize extends Tyre.Size{

}

编译器会报错: No enclosing instance of type ‘com.example.Tyre’ is in scope ,即缺少 Tyre 类的实例,若要创建位于 Tyre 内部的 Size 类,则必须要有 Tyre 的实例对象,要解决这个问题,需要引入 Tyre 实例且说清它们之间的关联:

public class TyreSize extends Tyre.Size{
    TyreSize(Tyre tyre) {
        tyre.super();
    }
}

编译通过。

8、内部类可以被覆盖吗

如果创建了一个内部类,然后继承其外部类并重新定义此内部类时,内部类可以被覆盖吗?例如:

class Car {
    Car() {
        System.out.println("new Car()");
        new Tyre();
    }
    class Tyre { // 我会被覆盖吗
        Tyre() { System.out.println("new Tyre()"); }
    }
}

public class BigCar extends Car {
    class Tyre {
        Tyre() {System.out.println("BigCar new Tyre()"); }
    }
    
    public static void main(String[] args) {
        new BigCar();
    }
}

在 Car 的构造器中新建的 Tyre 是 Car 中的 Tyre 还是 BigCar 中的 Tyre 呢?运行程序输出:

new Car()
new Tyre()

BigCar 中定义的 Tyre 内部类并没有覆盖 Car 中的 Tyre 内部类,实际上这两个内部类是完全独立的两个实体,各自在自己的命名空间内,没有谁覆盖谁之说。

9、为什么需要内部类

也就是说,内部类存在的意义是什么呢?为什么 Sun 公司如此费心地增加这项语言特性呢?这里将内部类的意义总结为以下四点:

A. 逻辑上被包含且对外隐藏

如果一个类在逻辑上被包含于另一个类,那么将此类设置为另一个类的内部类,比如轮胎类可以写作汽车类的内部类:

public class Car {
    public class Tyre{}
}

上面代码中只存在被包含关系,也可通过组合方式实现,写作内部类是没有必要的,当想对外保密汽车使用何种轮胎时,写作内部类才是有必要的:

public class Car {
    private class Tyre{}
}

B. 实现多重继承

每个内部类都能独立的继承一个接口,无论外部类是否已经继承了某个接口的实现,对于内部类都没有影响。内部类提供可以继承多个抽象类或具体的类的能力,有效的实现了多重继承,网上一个实例简单直观的展示了通过内部类实现多重继承(儿子利用多重继承来继承父亲和母亲的优良基因):

public class Father { //父亲
    public int strong(){
        return 9;
    }
}

public class Mother { //母亲
    public int kind(){
        return 8;
    }
}
public class Son { // 儿子通过内部类实现多重继承
    
    class Father_1 extends Father{
        public int strong(){
            return super.strong() + 1;
        }
    }
    
    class Mother_1 extends  Mother{
        public int kind(){
            return super.kind() - 2;
        }
    }
    
    public int getStrong(){
        return new Father_1().strong();
    }
    
    public int getKind(){
        return new Mother_1().kind();
    }
}

C. 闭包与回调

闭包是一个可调用的对象,它记录了一些信息,这些信息来自于创建它的作用域。通过这个定义,可以看出内部类是面向对象的闭包,因为它不仅包含外部类对象(创建内部类的作用域)的信息,还自动拥有一个指向此外部类对象的引用,在此作用域内,内部类有权操作所有的成员,包括private成员。

通过内部类提供闭包功能比指针更灵活、更安全

例如:一个接口程序员和一个基类作家都有一个相同的方法work,相同的方法名,但是其含义完全不同,这时候就需要闭包。

class Writer { //作家基类
  void work(){}
}
interface programmer{ //程序员接口
  void work();
}

闭包实现代码如下:

public class WriterProgrammer extends Writer {
  @Override
  public void work(){
      //写作
  }
  public void code(){
      //写代码
  }
  class ProgrammerInner implements programmer{
      @Override
      public void work(){
          code();
      }
  }
}

WriterProgrammer 继承自 Writer , 直接实现父类作家的work()方法,然后使用内部类实现程序员的work()方法回调code()方法。如果WriterProgrammer 同时继承自 Writer 且实现 programmer 接口,那么就不能同时实现作家和程序员的意义不同的 work()方法:

class WriterProgrammer extends Writer implements programmer{
       @Override
       public void work() { //programmer的 work

       }
   }

D. 控制框架

应用程序框架就是被设计用以解决某类特定问题的一个类或一组类,而控制框架就是一类特殊的应用程序框架,它用来解决响应事件的需求,主要用来响应事件的系统被称作事件驱动系统。 Java Swing 库就是一个控制框架,它优雅的解决了 GUI 的问题,并使用了大量的内部类

控制框架的完整实现是由单个类创建的,内部类用来表示解决问题所必须的各种不同的 action,另外内部类能够很容易的访问外部类的任意成员,可以让这种实现更轻松。

例如控制温室的运作:控制灯光、水、温度调节器的开关等,每个行为都是完全不同的,使用内部类可以在单一的类中产生对同一个基类 Event 的多种导出版本,对于温室系统的每一种行为,都继承一个新的 Event 内部类,并在要实现的 action() 中编写控制代码:


public class GreenhouseControls{

    public class LightOn extends Event {
        public void action() {
            //开灯...
        }
    }

    public class LightOff extends Event {
        public void action() {
            //关灯...
        }
    }

    public class WaterOn extends Event {
        public void action() {
            //开水闸...
        }
    }
    
    // 其他操作...
}

10、内部类标识符

每个类都会产生一个.class文件,其中包含了如何创建该类型的对象的全部信息,内部类也必须生成一个 .class 文件,从而可以包含它自己的 Class 对象信息,这些类文件的命名有严格的规则:外部类名字+“$”+ 内部类名字,例如:

class Car {
    class Tyre {}
}

生成的 .class 文件包括:

Car.class
Car$Tyre.class

如果内部类是匿名的,编译器会简单的产生一个数字作为其标识符,如果内部类是嵌套在别的内部类之中,只需直接将它们的名字加在其外部类标识符与"$"后面,这是 Java 的标准命名方式,产生的文件自动都是平台无关的。

总结

本文主要参考 Java 编程思想书中对内部类部分的讲解思路,将各部分知识点转换为自以为更易理解的例子嗯总算较为全面的理解内部类了以后应该不会怕啦hhh

参考文章:

BruceEckel. Java编程思想:第4版[M]. 机械工业出版社, 2007.

关注公众号,Get 更多知识点
Java 内部类 Java 的使用 分别介绍了 成员内部类、方法内部类、静态内部类 立即下载

相关推荐

NRF52832调试方法1——HardFault_Handler问题定位

一、遇到问题 keil debug模式下,直接点击全速运行(Run)发现程序卡死,点击stop按钮后,停到了HardFault_Handler位置,如下图所示。 此时使用navigate backwards(蓝色左箭头)是无效的,找不到程序卡在哪里。 二、解决办法 此时首先观察register窗口 若Stack为MSP,则复制R13(SP)的值到memory观察窗的地址搜索栏。每一行显示连续的28个地址上的存储信息,每个地址上存有一个字节。 从第21个位置起的连续四个字节是LR的值,

小梁的博客 3651

Spring AOP

一、AOP一、AOP1. AOP简介和作用面向切面编程,一种编程范式,指导开发者如何组织程序结构面向对象编程在不惊动原始设计的基础上为其进行功能增强。简单的说就是在不改变方法源代码的基础上对方法进行功能增强。:无入侵式/无侵入式2. AOP中的核心概念:正在执行的方法,例如:update()、delete()、select()等都是连接点。):进行功能增强了的方法,例如:update()、delete()方法,select()方法没有被增强所以不是切入点,但是是连接点。

jklaaxasdas的博客 319

KV Cache 详解:新手也能理解的 LLM 推理加速技巧

(Autoregressive)生成的,即每次生成一个 token,然后将其作为输入继续生成下一个 token。:如果序列太长,超过了 KV Cache 的存储限制,就需要丢弃最早的 tokens(类似滑动窗口)。时,每次只会生成一个新 token,然后再把这个 token 作为输入继续生成下一个 token。,只缓存计算过的 K,VK, V,每次只计算新 token 的 K,VK, V,从而提升推理效率。:如果输入的 prompt 发生变化,之前的 KV Cache 不能复用,必须重新计算。

Harry的博客 7418

Spring对使用@Configuration @Component的类中 “内部类的特殊处理”

Spring对使用@Configuration @Component的类中 “内部类的特殊处理”

Brucelwl的博客 3692

基于小波变换的信号降噪处理及仿真研究_信号处理方法推荐--1(转载自用,侵删)...

综述作者:aresmiki链接:https://www.zhihu.com/question/23701194/answer/167005497来源:知乎著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。非平稳信号处理应该是现在信号处理技术最新的也是最热的研究方向了,信号处理方法从最早的时域统计到傅里叶变换的频域分析,是人们认识信号本质的一次巨大飞跃,给了分析人员换个角度看世界的...

weixin_32144483的博客 1252

第四章、Isaacsim在GUI中构建机器人(3):添加摄像头和传感器

本节。

m0_47719040的博客 2504

【Java|基础篇】内部类

内部类就是在一个类中再定义一个类,内部类也是封装的体现.它可以被声明为public、protected、private 或默认访问控制符。内部类可以访问外部类的所有成员变量和方法,包括私有成员。内部类可以用来实现一些特殊的功能,比如实现回调函数、事件处理等。常见的内部类包括实例内部类(成员内部类)、静态内部类、本地内部类、匿名内部类等。内部类在Java中的一个重要特性,要重点掌握实例内部类,静态内部类和匿名内部类.希望这篇文章能帮到你!专栏:《从零开始的Java学习之旅》在不断更新中,欢迎订阅!

云泽野の编程日记 1万+

西南科技大学模拟电子技术实验七(集成运算放大器的非线性应用)预习报告

将电位器Rp调至中心位置,用双综示波器观察并绘制方波U0的波形,测量其幅值和频率;将电位器RP调至中心位置,用示波器观察并绘制锯齿波U0的波形,记录;示波器基线调零,Ui输入1000HZ、幅值为2V的正弦信号,观察并记录Ui与U0波形,读出图中波形跳变时的Ui临界值;用万用表电位器RP调至预测结果位置,用示波器观察并描绘三角波输出U0及方波输出uo’,测其幅值、频率及Rp值,记录之。示波器基线调零,U输入1000HZ、幅值为2V的正弦信号,观察UI与U0波形。理论算法公式:当Ui

Welcome To My6n Blog 3947

Java内部类

Java内部类介绍

cnds123的专栏 2588

GEE:面对对象土地利用分类(结合SNIC、GLCM 和机器学习算法)

本文将介绍在Google Earth Engine中结合SNIC、GLCM和机器学习算法的的土地利用/土地覆盖(LULC)分类方法。结果如下图所示,

养乐多的博客 5622

手把手教你学AUTOSAR(13.1)--基于 AUTOSAR 的开发实战实例(一)

通过上述几个基于 AUTOSAR 的开发实战实例,你可以全面了解如何从需求分析、系统设计、软件开发、集成测试到部署和验证等多个环节进行 AUTOSAR 系统的开发。这些实例不仅涵盖了不同的应用场景,还提供了具体的代码实现和技术细节,帮助你更好地应用 AUTOSAR 标准。

MHD0815的博客 1195

Java内部类(超级详细)

自定义函数接口,只需要编写一个只有一个抽象方法的接口即可。csharp复制代码// 自定义函数接口 @FunctionalInterface //这个注解是可选的,但加上该标注编译器会帮你检查接口是否符合函数接口规范。// 使用自定义函数接口书写Lambda表达式 } }*需要注意的是:*

BASK2312的博客 446

Joule 终于会说 ABAP 了:从 ADT 提效到 ABAP AI SDK + ISLM 自建企业级 AI 场景的落地路线

生成结构化摘要(故障现象、初步原因、处理动作、备件消耗)自动给出建议分类(电气、机械、软件、网络)把摘要回写到工单抬头,方便后续统计与知识沉淀如果你用 CAP 来做这类服务,通常会在 Node.js 层封装一个对 AI Hub 的调用,再通过 OData 或 Event 把结果写回 SAP。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 348

Java内部类可以public吗,Java 内部类

Java 内部类什么是内部类?在 Java 中,可以将一个类定义在另一个类里面或者一个方法里面,这样的类称为内部类。主要用以下几种成员内部类局部内部类匿名内部类静态内部类Java 成员内部类示例访问权限private 访问权限protected 访问权限public 访问权限package 访问权限public class TestClass {public void a(){LogHelper....

weixin_30247915的博客 2379

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

Java内部类是什么?Java实例内部类、Java静态内部类、Java局部内部类详解

在类内部可定义成员变量和方法,且在类内部也可以定义另一个类。如果在类 Outer 的内部再定义一个类 Inner,此时类 Inner 就称为内部类(或称为嵌套类),而类 Outer 则称为外部类(或称为宿主类)。内部类可以很好地实现隐藏,一般的非内部类是不允许有 private 与 protected 权限的,但内部类可以。内部类拥有外部类的所有元素的访问权限。内部类可以分为:实例内部类、静态内部类和成员内部类,每种内部类都有它特定的一些特点。

Itmastergo的博客 235

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

java 内部类list_java详解内部类

可以将一个类的定义放在另一个类的定义内部,这就是内部类。内部类是一个非常有用的特性但又比较难理解使用的特性(鄙人到现在都没有怎么使用过内部类,对内部类也只是略知一二)。第一次见面内部类我们从外面看是非常容易理解的,无非就是在一个类的内部在定义一个类。public class OuterClass {private String name ;private int age;public String...

weixin_39714835的博客 905

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

java 内部类怎么使用_Java中的内部类的使用

一、内部类的作用1.内部类提供更好的封装,可以把内部类隐藏在外部类里面,不容许同一个包中其他类进行访问。2.内部类的方法可以直接访问外部类的所有数据。3.使用更加方便。二、内部类的分类:1.成员内部类(作为外部类的一个成员)2.静态内部类3.方法内部类(内部类在外部类的一个方法里面)4.匿名内部类三、内部类的使用1.成员内部类的使用:package com.bluesky;public class...

weixin_30019517的博客 1041

Java的内部类

Java的内部类

weixin_52385232的博客 702

java 内部类总结_java内部类总结

内部类是指在一个外部类的内部再定义一个类。内部类作为外部类的一个成员,并且依附于外部类而存在的。内部类可为静态,可用protected和private修饰。(而外部类不可以:外部类只能使用public和默认的)。内部类分为:成员内部类、局部内部类、静态内部类、匿名内部类几种内部类的共性:A、内部类仍然是一个独立的类,在编译之后会内部类会被编译成独立的.class文件,但是前面冠以外部类的类命和$符...

weixin_31008279的博客 194

java 遍历所有内部类_JAVA-内部类

注意:非内部类(外部类或接口)不能被声明为private(私有的)或protected(受保护的),也不能被static修饰可以被final修饰。这是为何???对于外部类(顶级类)来说,只有两种修饰符:public和默认。因为外部类的上一单元就是包。所以外部内就只有这两种作用域同包(包控制权限)或其他任何地方(公开访问权限)。protected的不同包子类可以访问那是针对属性和方法的。类就两种访问...

weixin_36131782的博客 539

java 函数内部类_java中内部类的讲解

java中有一个内部类的概念,由于之前一直比较忙,没有单独拿出时间总结一下,今天我就把内部类的相关知识进行一下汇总,如果有不足之处,欢迎批评指正。1)java内部类的概念。在一个类的的内部定义的类被称为java的内部类。内部类提供了更好的封装。而且它可以直接访问外部类的private成员。2)内部类的分类根据内部类的位置不同,可以大致分为一下两类:1.普通内部类又叫成员内部类,在方法体的外面定义的...

weixin_40002846的博客 254

java 内部类对象_JAVA基础——内部类详解

JAVA内部类详解在我的另一篇java三大特性的封装中讲到java内部类的简单概要,这里将详细深入了解java内部类的使用和应用。我们知道内部类可分为以下几种:成员内部类静态内部类方法内部类匿名内部类这里我们先将以这个分类来详细了解各个内部类的情况。然后给内部类作出总结。一、成员内部类内部类中最常见的就是成员内部类,也称为普通内部类。我们来看如下代码:运行结果为:从上面的代码中我们可以看到,成员内...

weixin_35411480的博客 580

java什么内部类_什么是Java内部类?

内部类内部类,即类内部的类。类中类。形式如下:public class Outter{ // 外部类class Inner{ // 内部类}}1. 理解内部类的作用内部类可以很好的实现隐藏​ 一般的非内部类,是不允许有 private 与protected权限的,但内部类可以内部类拥有外围类的所有元素的访问权限可是实现多重继承匿名内部类优化接口1)隐藏细节​ 平时我们...

weixin_34489829的博客 191
上一篇: Ubuntu16.04 Caffe 安装步骤记录(超详尽)
下一篇: Android 集成 FFmpeg (一) 基础知识及简单调用
王英豪
王英豪 领域专家: 操作系统技术领域 领域专家: 操作系统技术领域
博客等级 码龄11年 440粉丝 49原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址