Java 内部类

Java基础——内部类 概念及规则 定义在类内部的类称为内部类。 内部类特点 内部类可以直接访问外部类的成员,包括私有成员 外部类想要访问内部类成员,必须创建对象。内部类可以对同一个包中的其他类隐藏 内部类的对象会有一个隐式引用,指向实例化这个对象的外部类对象。但是对于静态内部类却是没有这个附加的指针 只有内部类可以是私有的,而常规类可以是包权限和public的 内部类中声明的所有静态字段都必须是final的,并初始化为一个编译时常量 内部类不允许有static方法,编译报错。 内部类是一个编译器现象,与虚拟机无关。编译器将会把 阅读详情

1、初识内部类

如果一个事物的内部包含另一个事物,那么这是一个类的内部包含另一个类。

例如:身体和心脏的关系,又如汽车和发动机的关系。

把 A 类定义在 B 类的内部,A——内部类(嵌套类),B——外部类(宿主类)。

内部类的特点

  • 内部类提供了更好的封装,把内部类隐藏在外部类之中,不允许同一个包下的其他类访问该内部类。
  • 内部类成员可以直接访问外部类的私有数据。
  • 匿名内部类适合那些仅需要一次使用的类。
  • 方法里定义的内部类称为局部内部类。
  • 内部类比外部类可以多使用三个修饰符:private、protected、static。
  • 非静态内部类不能拥有静态成员。

内部类的分类

  • 成员内部类
    • 非静态内部类
    • 静态内部类
  • 局部内部类
  • 匿名内部类

成员内部类可以看成外部类的成员,可以使用四个访问控制符

外部类仅可以使用两个访问控制符:公共访问权限、包访问权限

private:本类访问
省略不写:包访问
protected:子父类访问
public:公共访问

定义内部类语法格式

修饰符 class 外部类名称 {
    修饰符 class 内部类名称 {
        
    }
}

内用外:随意访问

外用内:使用内部类对象

2、非静态内部类(实例内部类)

Cow.java

// 外部类 奶牛
public class Cow {
	private double weigth;

	public void test() {
		CowLeg cowLeg = new CowLeg(10, "黑白相间");
		cowLeg.show();
	}

	public Cow() {
	}

	public Cow(double weigth) {
		this.weigth = weigth;
	}

	// 非静态内部类 奶牛的腿
	private class CowLeg {
		private double length;
		private String color;

		public CowLeg() {
		}

		public CowLeg(double length, String color) {
			this.length = length;
			this.color = color;
		}

		public void show() {
			System.out.println("本牛腿的颜色是:" + color + ", 长度是:" + length);
			System.out.println("奶牛重量为:" + weigth);
		}
	}
}

测试

public class Application {
	public static void main(String[] args) {
		Cow cow = new Cow(20);
		cow.test();
	}
}

在外部类里包含一个 test() 方法,该方法里创建了一个内部类对象,并调用该对象 show() 方法。

在外部类里使用非静态内部类时,与平时使用普通类并没有太大区别。

编译上面程序,生成了两个字节码文件,一个是 Cow.class,另一个是 Cow$CowLeg.class,前者是外部类 Cow 的 class 文件,后者是 CowLeg 的字节码文件。

成员内部类(静态内部类、非静态内部类)的字节码文件总是这种形式:OuterInner$InnerClass.class

在非静态内部类里可以直接访问外部类的私有成员,是因为在非静态内部类的对象里保存了一个它所寄生外部类对象的引用。

当调用非静态内部类的实例方法时,必须有一个非静态内部类的实例,非静态内部类实例必须寄生在外部类实例里。

在这里插入图片描述

非静态内部类对象中保留外部类对象的引用内存示意图

变量重名怎么访问?

当在非静态内部类的方法内访问某个变量时,查找的顺序是:

本方法所在的局部变量 > 内部类成员变量 > 外部类成员变量

如果外部类成员变量、内部类成员变量、局部变量重名,则可通过使用 this、外部类类名.this 作为限定来区分。

public class Outer {
   public static void main(String[] args) {
      new Outer().show();
   }

   private String name = "外部类成员变量";

   public void show(){
      new Inner().test();
   }


   class Inner{
      private String name = "内部类成员变量";

      public void test() {
         String name = "局部变量";
         System.out.println(name); // 局部变量
         System.out.println(this.name); // 内部类成员变量
         System.out.println(Outer.this.name); // 外部类成员变量
      }
   }
}

内部类访外部类,直接用;

外部类访内部类,须在外部类方法中显式定义内部类对象来访问

public class OuterClass {
   public static void main(String[] args) {
      OuterClass outer = new OuterClass();// 只创建了外部类对象,还未创建内部类对象
      outer.showInner();
   }

   private int outerProp = 20;

   private void showInner() {
      // 访问内部类实例变量,需要显示创建内部类对象
      InnerClass innerClass = new InnerClass();
      System.out.println(innerClass.innerProp);
      innerClass.showOuter();
   }

   private class InnerClass {
      private int innerProp = 10;

      public void showOuter() {
         // 非静态内部类直接访问外部类成员
         System.out.println(outerProp);
      }
   }
}

非静态内部类对象和外部类对象的关系是什么样?

非静态内部类对象有则外部类对象一定有

外部类对象有但非静态内部类对象不一定有

1、不允许在外部类的静态成员中直接使用非静态内部类

public class A {
   class B {
   }

   public static void main(String[] args) {
      // 静态内容不能访问非静态内容。
      // 此处报错
      // new B();
   }
}

2、不允许在非静态内部类中定义静态成员

public class A {
	// 非静态内部类
	class B {
		// 都报错
		static int a;
		static void print(){}
		static {}
	}
}

非静态内部类里不能有静态方法、静态成员变量、静态代码块。

非静态内部类可以有实例代码块,作用与外部类实例代码块作用相同。

3、静态内部类(重点)

static 关键字的作用:把类的成员变成类相关,而不是实例相关。

static 关键字可以修饰内部类,但不可修饰外部类。

使用 static 修饰的内部类称为:静态内部类(类内部类)

静态内部类属于外部类本身,不属于外部类的某个对象。

静态内部类可以包含:静态成员、非静态成员。

根据静态成员不能访问非静态成员的规则:静态内部类里不能访问外部类的实例成员,只能访问外部类的类成员。

即使静态内部类的实例方法也不能访问外部类的实例成员,只能访问外部类的静态成员。

public class Demo01 {

   private int a1 = 10;
   private static int a2 = 20;

   private static class StaticInnerClass {
      private static int a3 = 30;

      public static void show() {
         // 访问外部类非静态成员报错
         // System.out.println(a1);
         System.out.println(a2);
         System.out.println(a3);
      }
   }
}

为什么静态内部类的实例方法也不能访问外部类的实例变量?

因为静态内部类是外部类的类相关的,而不是外部类的对象相关的。

也就是说:静态内部类对象不是寄生在外部类的实例中,而是寄生在外部类的类本身中。

当静态内部类对象存在时,并不存在一个被它寄生的外部类对象,静态内部类对象只持有外部类的类引用,没有持有外部类对象的引用。

如果允许静态内部类的实例方法访问外部类的实例成员,但找不到被寄生的外部类对象,会引起错误。

外部类不能直接访问静态内部类的成员但可以使用 静态内部类的类名.xxx 来访问类成员;

创建一个静态内部类对象来访问实例成员。

public class A {
   public static void main(String[] args) {
      new A().show();
   }

   static class B{
      private static int a1 = 10;
      private int a2 = 20;
   }

   public void show(){
      System.out.println(B.a1);
      System.out.println(new B().a2);
   }
}

除此之外,java 还允许在接口里定义内部类,接口里定义的内部类默认使用 public static 修饰,也就是说:接口里的内部类只能是静态内部类。

类似的,接口里定义内部接口,默认也是使用 public static 修饰,接口里的内部接口也只能是静态内部接口。

例如:MMap<K,V> 接口里定义了一个内部接口 Entry<K,V> 。

4、内部类的使用

1、在外部类内部使用内部类

与平常使用普通类没有什么区别,需要注意的是:不要在外部类的静态成员中使用非静态内部类。

因为静态成员无法访问非静态成员。

2、在外部类以外定义和创建非静态内部类对象

语法格式:

外部类类名.内部类类名 变量名称 = new 外部类类名().new 内部类类名();

代码:

public class Out {
    class In{
   }
}
public class MyTest {
	public static void main(String[] args) {
		// 在外部类以外创建非静态内部类对象
		Out.In in = new Out().new In();
		// =========上面一句和下面三句效果等价=========
		// 1、创建非静态内部类对象的引用
				Out.In in2;
		// 2、创建非静态内部类对象所寄生的外部类对象
				Out out = new Out();
		// 3、通过外部类对象创建内部类对象
				in2 = out.new In();
	}
}

3、在外部类外部定义和创建静态内部类对象

语法格式:

外部类类名.内部类类名 变量名称 = new 外部类类名.内部类类名();

代码:

public class Out {
	static class In{
	}
}
public class MyTest {
	public static void main(String[] args) {
		Out.In in = new Out.In();
	}
}

4、调用静态内部类的构造器时无需使用外部类对象,所以创建静态内部类的子类也比较简单。

public class Out {
   static class In{
   }
}
public class SubIn extends Out.In {}

使用静态内部类比使用非静态内部类要简单很多,只要把外部类当成静态内部类的包空间即可~

因此当程序需要使用内部类时,优先考虑使用静态内部类。

5、局部内部类

局部内部类在开发中很少使用,了解即可~

一般定义类需要重复使用,而局部内部类作用域只在方法之内,作用域太小。

如果把一个内部类放在方法里定义,那这个内部类就是一个局部内部类,局部内部类仅在方法里有效。

由于局部内部类无法在方法以外的地方使用,也就无法使用访问控制符合 static 修饰符。

public static void main(String[] args) {
   class InBase{
      int a;
   }
   class InSub extends InBase{
      int b;
   }
   InSub inSub = new InSub();
   inSub.a = 10;
   inSub.b = 20;
   System.out.println(inSub.a);
   System.out.println(inSub.b);

}

6、匿名内部类

特点:

  • 适合只需要一次使用的类
  • 创建匿名内部类时会立即创建一个该类的实例,类的定义立即消失
  • 用完一次后,无法重复使用

规则:

  • 匿名内部类不能是抽象类。创建匿名内部类时会立即创建一个该类的实例。
  • 匿名内部类里不能定义构造器。因为匿名内部类没有类名。
  • 匿名内部类中允许定义代码块,来完成需要在构造器中做的事。

语法格式:

new 实现接口() | 父类构造器(参数列表){
    // 匿名内部类类体
}

匿名内部类必须实现一个接口或继承一个父类,但最多只能实现一个接口或继承一个父类。

最常用的创建匿名内部类的方式创建某个接口类型的对象。

示例代码:

interface Product{
   String getName();
   double getPrice();
}

public class AnonymousTest {

   public static void main(String[] args) {
      AnonymousTest test = new AnonymousTest();
      test.show(new Product() {
         @Override
         public String getName() {
            return "名侦探柯南";
         }

         @Override
         public double getPrice() {
            return 60;
         }
      });
   }


   void show(Product product){
      System.out.println("名称:" + product.getName());
      System.out.println("花费:" + product.getPrice());
   }

}

当通过实现接口来创建匿名内部类时,匿名内部类里不能显式定义构造器,内部只有一个隐式无参构造器,所以 new 接口名称() 括号里不能传任何参数。

但如果通过继承父类来创建匿名内部类时,匿名内部类将拥有和父类相同参数列表的构造器。

public abstract class Device {
   private String name;
   public abstract double getPrice();

   public Device() {
   }

   public Device(String name) {
      this.name = name;
   }

   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }
}
public class AnonymousTest2 {

   public static void main(String[] args) {
      AnonymousTest2 test2 = new AnonymousTest2();
      // 调用有参构造器创建Device匿名实现类对象
      test2.show(new Device("笔记本") {
         // 实现抽象方法
         @Override
         public double getPrice() {
            return 100;
         }
      });

      System.out.println("-------------------");
      // 调用无参构造器创建Device匿名实现类对象
      AnonymousTest2 test3 = new AnonymousTest2();
      test3.show(new Device() {
         // 实例代码块
         {
            System.out.println("匿名内部类的实例代码块");
         }

         // 实现抽象方法
         @Override
         public double getPrice() {
            return 60;
         }
         // 重写父类实例方法
         @Override
         public String getName(){
            return "轻薄笔记本";
         }
      });
   }


   public void show(Device device) {
      System.out.println("名称:" + device.getName());
      System.out.println("价格:" + device.getPrice());
   }
}
java中的内部类详细总结 内部类不是很好理解,但说白了其实也就是一个类中还包含着另外一个类。如同一个人是由大脑、肢体、器官等身体结果组成,而内部类相当于其中的某个器官之一,例如心脏:它也有自己的属性和行为(血液、跳动) 立即下载

相关推荐

RK3588多路MIPI摄像头采集与WiFi低延迟传输实战指南

本文详细介绍了基于RK3588平台实现多路MIPI摄像头同步采集并通过WiFi进行低延迟传输的完整实战方案。文章深入剖析了从V4L2驱动配置、多线程采集、环形缓冲区设计到UDP网络传输优化的核心技术,旨在帮助开发者在工业检测、智能安防等场景下构建高并发、高实时性的视频流系统,实现端到端延迟控制在100毫秒以内的目标。

tensor9flow的博客 791

【Java|基础篇】内部类

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

云泽野の编程日记 1万+

USB2.0物理层实战:手把手教你用示波器抓取D+/D-信号(附波形分析)

本文是一份针对硬件工程师的USB2.0物理层信号调试实战指南。文章详细讲解了如何使用示波器捕获和分析D+/D-差分信号,从基础设置、核心信号状态解读,到信号完整性分析与常见问题排查,手把手教你定位USB通信故障。内容涵盖USB2.0协议物理层关键概念,并附有基础解码思路,旨在提升工程师的底层调试能力。

s8t9u0v1w的博客 462

Java——内部类

成员内部类是定义在一个外部类的成员位置的的类,没有 static 修饰。class MemberInnerClass { // 成员内部类静态内部类是定义在一个外部类的成员位置的的类,有 static 修饰。static class StaticNestedClass { // 静态内部类它的地位就相当于外部类的一个静态成员。局部内部类定义在方法、构造器或代码块内部,类似于方法的局部变量。它的作用域仅限于定义它的块中。class LocalInnerClassA { // 在构造器中定义局部内部类。

Stewie Lee的博客 1万+

NXP S32K-144开发环境搭建与Keil MDK 5调试实战

嵌入式开发中,Cortex-M系列微控制器凭借其高性能和低功耗特性广泛应用于汽车电子和工业控制领域。以NXP S32K-144为例,该芯片采用Cortex-M4内核,支持SWD两线制调试协议,通过CoreSight调试系统可实现硬件断点、实时内存访问等高级功能。开发环境搭建涉及Keil MDK 5工具链配置、RTX5实时系统集成以及CMSIS-DSP算法库调用,其中SWD接口优化和ITM跟踪技术能显著提升调试效率。在汽车电子等对可靠性要求高的场景中,结合MPU内存保护单元和窗口看门狗等安全机制,可构建符合功

weixin_33722405的博客 327

山景BP10_128DBG开发板ADC_Key驱动

最近在学习山景BP10_128DBG开发板,想使用开发板上的按键。看了看原理图和之前用过的按键好像有点不一样。常见的按键都是判断IO口是否被拉低或拉高来判断按键是否被按下。山景BP10_128DBG开发板上的按键是ADC按键,每个按键按下之后ADC的采样值是不同的,通过ADC采样回来的值进而判断哪个按键按下。这种方式核心思想就是用一个ADC通道来节约IO口,对于IO紧张的芯片是一个不错的解决思路。

weixin_56646002的博客 1314

java中的内部类

匿名内部类是没有名称的内部类。在Java中调用某个方法时,如果该方法的参数是接口类型,除了可以传接口实现类外,还可以使用实现接口的匿名内部类作为参数,在匿名内部类中直接完成方法的实现。}}@OverrideSystem.out.println("学生韩梅梅正在吃饭");}}@OverrideSystem.out.println("老师李华正在吃饭");}}}}}}}@OverrideSystem.out.println("学生韩梅梅正在吃饭");}...

yahid的博客 1万+

Windows系统监控实战:Grafana+Prometheus+node_exporter配置全攻略

本文提供了一套完整的Windows系统监控解决方案,详细介绍了如何使用Grafana、Prometheus和node_exporter(Windows版为windows_exporter)构建可视化监控平台。从环境准备、组件安装配置,到数据可视化与常见问题排查,手把手指导您实现从数据采集到仪表盘展示的全过程,帮助您从被动救火转向主动预警,有效保障Windows服务器稳定运行。

assembly8low的博客 253

java内部类

1、局部内部类就是定义在外部类的局部位置上,比如方法内,并且有类名。class Outer {//外部类public void show() {//方法class Inter {//局部内部类} } }2、局部内部类可以访问外部类的所有成员,包括私有成员。class Outer {//外部类//私有变量private void method1() {}//私有方法public void show() {//方法class Inter {//局部内部类//调用外部类私有变量。

qq_65501197的博客 1431

FCC 首个扫地机器人豁免落地,Matic 凭什么抢先?

Matic获FCC首个扫地机器人豁免,实为提前布局的合规姿态。其产品在美国组装,并采用已认证射频模组,虽未达65%美国成分门槛,但已具备“本土制造”优势。豁免本质是对既有合规状态的确认,而非解救。此举在商业上放大品牌价值,抢占“安全、合规、本土”叙事高地,凸显供应链安全正取代技术标准成为监管核心。未来合规成本将攀升,规则主导权仍在FCC手中。

致力于lidar应用开发 105

基于 STM32 的全自动洗车监控系统设计与实现

本文提出一种基于 STM32F103RCT6 芯片的全自动洗车监控系统方案,通过多传感器融合与智能控制算法,实现车辆检测、洗车流程自动化及状态远程监控。系统集成硬件选型、电路设计、软件流程及通信功能,可广泛应用于智能洗车场景。

weixin_42300449的博客 970

Java内部类

一、内部类的概念 二、内部类的分析 三、内部类的分类 1. 成员内部类 2. 静态内部类 3. 局部内部类 4. 匿名内部类 匿名内部类与Lambda表达式

骑个小蜗牛的博客 9308

玩转Docker小游戏项目系列:Docker部署魔塔网页经典小游戏

玩转Docker小游戏项目系列:Docker部署魔塔网页经典小游戏

jks212454的博客 1070

java new 一个内部类_java内部类

java内部类的几种类型:成员内部类,静态内部类,方法内部类,匿名内部类。成员内部类:成员内部类是类内部的非静态类。成员内部类不能定义静态方法和变量(final修饰的除外)。这是因为成员内部类是非静态的,类初始化的时候先初始化静态成员,如果允许成员内部类定义静态变量,那么成员内部类的静态变量初始化顺序是有歧义的。例子如下:运行结果为:访问外部类中的a:99,访问内部类中的b:2成员内部类的使用方法...

weixin_29798379的博客 5241

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

Java 内部类详解

在 Java 中,我们通常是把不同的类创建在不同的包里面,对于同一个包里的类来说,它们都是同一层次的。但其实还有另一种情况,有些类可以被定义在另一个类的内部,我们把在一个类里面定义的类称为内部类(InnerClass)或嵌套类,把外面定义的类称为外部类(OutClass)或宿主类。也就是说,在类的内部既可以定义成员变量和方法,也可以定义其他的类。public class Outer { // 外部类class Inner { // 内部类// 方法和属性。

流华追梦的专栏 1318

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

全面掌握 Java 内部类

一直以来以为自己对 java 基础甚是清楚,然而面试时却连内部类和静态内部类的区别都无法回答圆满,so~重新学习一遍,彻底掌握内部类。内部类是一种非常有用的特性,它可以把一些逻辑相关的类组织在一起,并控制位于内部的类的可视性,下文中内部类均指非静态内部类。内部类的学习分为以下10个知识点: 1.创建内部类与连接外部类 2.内部类与向上转型 3.局部内部类 4.匿名内部类

yhao的博客 3636

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

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

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

weixin_30247915的博客 2379

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

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

Itmastergo的博客 235

java 内部类list_java详解内部类

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

weixin_39714835的博客 905

java四种内部类

java四种内部类 成员内部类 静态内部类 局部内部类、 匿名内部类。 1.成员内部类 定义在一个类(外部类)的内部,而且与成员方法、属性平级的类叫成员内部类,…相当于外部类的非静态方法,如果被static修饰,就变成静态内部类了。 public class Person { private int age; private String name; public void run() { System.out.println("run......."); } class User{

罗罗的1024 869

java声明内部类_java内部类

为什么在Java中需要内部类?总结一下主要有以下四点:1.每个内部类都能独立的继承一个接口的实现,所以无论外部类是否已经继承了某个(接口的)实现,对于内部类都没有影响。内部类使得多继承的解决方案变得完整,2.方便将存在一定逻辑关系的类组织在一起,又可以对外界隐藏。3.方便编写事件驱动程序4.方便编写线程代码个人觉得第一点是最重要的原因之一,内部类的存在使得Java的多继承机制变得更加完善。◆Jav...

weixin_35964207的博客 1800

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

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

weixin_30019517的博客 1041

Java中常用的内部类

内部类

m0_74968164的博客 674
上一篇: Java 抽象类
下一篇: Java 接口
暗中映秀
博客等级 码龄8年 19粉丝 39原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址