Java中为什么匿名对象中方法,调用局部变量必须加final呢,求详解

Java中为什么匿名对象中方法,调用局部变量必须加final呢,求详解。在网上找了很久,基本没看到想要的答案,最好从Java虚拟机内存分配角度讲一讲,其他角度亦可。

老师只告诉这么用就好了,问了也说不知道,匿名对象在哪没研究过

求大神回复

5个回答

局部内部类(包括匿名局部内部类和普通内部类)中使用局部变量,那么这个局部变量必须使用final修饰。这里说的事局部内部类,不是普通静态内部类和非静态内部类,因为他们不能访问方法体内的局部变量。

java要求所有被局部内部类访问的局部变量都是用final修饰是因为:对于普通局部变量他的作用域就是该方法内,当方法结束该局部变量就随之消失;但局部内部类可能产生隐式的“闭包”,闭包将使得局部变量脱离他所在的方法继续存在。
请看下面的例子是局部变量脱离他所在的方法继续存在的例子:

 public class ClosureTest   
{  
 public static void main(String[] args)  
 {  
  //定义一个局部变量  
  final String str = "Java";  
  //在内部类里访问局部变量str  
  new Thread(new Runnable()  
  {  
   public void run()  
   {  
    for (int i = 0; i < 100 ; i++ )  
    {  
     //此处将一直可以访问到str局部变量  
     System.out.println(str + " " + i);  
     //暂停0.1秒 www.sctarena.com 
     try  
     {  
      Thread.sleep(100);  
     }  
     catch (Exception ex)  
     {  
      ex.printStackTrace();  
     }  
    }  
   }  
  }).start();               //①  
  //执行到此处,main方法结束  
 }  
}  

上面定义了一个局部变量str。正常情况下,当程序执行完①行代码之后,main方法的生命周期就结束了,局部变量str的作用域也会随之结束。但只要新线程里run方法没有执行完,匿名内部类的生命周期就没有结束,将一直可以访问str局部变量的值,这个就是内部类会扩大局部变量作用域的实例。

由于内部类可能扩大局部变量的作用域,如果再加上这个被内部类访问的局部变量没有使用final修饰,也就是说这个变量的值可以随时改变,那将引起极大的混乱,因此java编译器要求所有被内部类访问的局部变量必须使用final修饰符修饰。

wojiushiwo945you
毕小宝 回复ycyz311: 就是存在匿名内部类访问外部环境中的局部变量的情况的。变量是存放在栈里面的,不存在扩大内存分配区域的问题啊。
4 年多之前 回复
ycyz311
ycyz311 回复毕小宝: 首先,感谢您详细的解释,局部变量加final后扩大其生命周期,可是我原先是这么想的: 我原先以为匿名内部类中的方法,访问不到局部变量,所以纠结匿名内部类存放在堆、栈还有其他什么区,局部变量放在堆中,加上final后,扩大他的内存分配区域, 难道跟这个没关系吗
4 年多之前 回复
ycyz311
ycyz311 回复毕小宝: 首先,感谢您详细的解释,局部变量加final后扩大其生命周期,可是我原先是这么想的: 我原先以为匿名内部类中的方法,访问不到局部变量,所以纠结匿名内部类存放在堆、栈还有其他什么区,局部变量放在堆中,加上final后,扩大他的内存分配区域, 难道跟这个没关系吗
4 年多之前 回复

先插一句,java8开始匿名内部类使用的外部变量不再被强制用final修饰。外部变量要么是final的,要么自初始化后值不会被改变,这两种都是可以在匿名内部类中使用且编译通过。否则就编译报错:error: local variables referenced from an inner class must be final or effectively final。
我觉得类似“final增强内部变量的生存期”这样的说法不完全准确。
先说一下final的外部变量。匿名内部类编译后,final的外部变量(就是常量了),存储到常量池中的,编译期间,匿名内部类使用到该常量的地方都会被替换为对应的“常量值”,比如使用了外部的String str = "java" , 匿名内部类所有用到str的地方都会被替换为"java" 。这样一来,从字节码级别看,内部类引用外部变量的痕迹被抹得一干二净。
再说一下非final的外部变量。当一个匿名内部类被创建时,其构造函数是自动生成的,如果有在内部类中使用到外部变量(非final修饰),那么这种外部变量是作为匿名内部类构造函数的参数,传递到内部类中使用的。当然,这种参数传递是一种传值传递(实际上所有java的参数传递都传值的,基本类型自不必说,Object及其子类作为函数参数,实际上传的值,就是对象在内存的存储地址),因此在内部类中对该外部变量的“值”修改是无效的;另外,如果外部变量在外部类中有修改,那么内部类使用该变量时可能值已经不是预期的那个“数”了。所以内部类使用的外部变量,不允许有任何的修改才能避免上述问题。
所以java编译器会检查匿名内部类使用的变量值有没有修改过,当然对于final的编译器就不用检查了,因为是常量嘛。java8之前的版本为了省事,就干脆强制是final的才能给匿名内部类用。

在main方法中有一个变量a,之后再在main方法中开启一个线程,并且在此线程中使用了a,如果a不是final的话,那么当main函数执行完,a就不存在了。而你在线程中还要使用这个变量,显然要定义成final。定义成final的目的是增强变量的生存期,使在匿名内部类对象中使用的时候这个变量还存在。

lhs472194266
凌海森 个人认为应该不是增强变量的生存期 ,而是为了保证一致性。
大约 4 年之前 回复
ycyz311
ycyz311 回复weixin_29987797: 首先,感谢您详细的解释,局部变量加final后扩大其生命周期,可是我原先是这么想的: 我原先以为匿名内部类中的方法,访问不到局部变量,所以纠结匿名内部类存放在堆、栈还有其他什么区,局部变量放在堆中,加上final后,扩大他的内存分配区域, 难道跟这个没关系吗
4 年多之前 回复
ycyz311
ycyz311 回复weixin_29987797: 首先,感谢您详细的解释,局部变量加final后扩大其生命周期,可是我原先是这么想的: 我原先以为匿名内部类中的方法,访问不到局部变量,所以纠结匿名内部类存放在堆、栈还有其他什么区,局部变量放在堆中,加上final后,扩大他的内存分配区域, 难道跟这个没关系吗
4 年多之前 回复
先插一句,java8开始匿名内部类使用的外部变量不再被强制用final修饰。外部变量要么是final的,要么自初始化后值不会被改变,这两种都是可以在匿名内部类中使用且编译通过。否则就编译报错:error: local variables referenced from an inner class must be final or effectively final。
我觉得类似“final增强内部变量的生存期”这样的说法不完全准确。
先说一下final的外部变量。匿名内部类编译后,final的外部变量(就是常量了),存储到常量池中的,编译期间,匿名内部类使用到该常量的地方都会被替换为对应的“常量值”,比如使用了外部的String str = "java" , 匿名内部类所有用到str的地方都会被替换为"java" 。这样一来,从字节码级别看,内部类引用外部变量的痕迹被抹得一干二净。
再说一下非final的外部变量。当一个匿名内部类被创建时,其构造函数是自动生成的,如果有在内部类中使用到外部变量(非final修饰),那么这种外部变量是作为匿名内部类构造函数的参数,传递到内部类中使用的。当然,这种参数传递是一种传值传递(实际上所有java的参数传递都传值的,基本类型自不必说,Object及其子类作为函数参数,实际上传的值,就是对象在内存的存储地址),因此在内部类中对该外部变量的“值”修改是无效的;另外,如果外部变量在外部类中有修改,那么内部类使用该变量时可能值已经不是预期的那个“数”了。所以内部类使用的外部变量,不允许有任何的修改才能避免上述问题。
所以java编译器会检查匿名内部类使用的变量值有没有修改过,当然对于final的编译器就不用检查了,因为是常量嘛。java8之前的版本为了省事,就干脆强制是final的才能给匿名内部类用。

final增强内部变量的生存期

Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
为什么Java匿名内部类的方法中用到的局部变量都必须定义为final
匿名内部类可以直接使用外部类的局部变量,看上去就像匿名内部类中使用的引用和外部类的引用是一个引用一样。如: public interface Test2 { public void test2(); } public class Test { public void test(int i){ final String str = "123"; new Test2() {
Java匿名类中使用的局部变量为何要加final
这几天,在网上找了一些关于final的知识,当然并不全面,有的一时也没有很好的理解,先收集起来,理理思路,把不懂的画出来,以便更好地学习…… java中的final关键字通常的指的是“这是无法改变的”。它可能被做为三种的修饰词.------数据(基本类型,对象或者数组),方法(类方法、实例方法),类。 final应用于类 如果类被声明为final,则表示类不能被继承,也就是说不能
Java 局部内部类访问局部变量必须加final关键字
局部内部类(包括匿名局部内部类和普通内部类)中使用局部变量,那么这个局部变量必须使用final修饰。这里说的事局部内部类,不是普通静态内部类和非静态内部类,因为他们不能访问方法体内的局部变量。  java要求所有被局部内部类访问的局部变量都是用final修饰是因为:对于普通局部变量他的作用域就是该方法内,当方法结束该局部变量就随之消失;但局部内部类可能产生隐式的“闭包”,闭包将使得局部变量脱
关于局部内部类访问所在方法的参数或局部变量为什么必须是final的
内部类的种类一共分为四种,我看其他几种内部类的时候思路都是很清晰的,然后我就碰到了这一条:“方法中的内部类可以访问外部类成员。对于方法的参数和局部变量,必须有final修饰才可以访问”。于是我就有点疑惑,为什么必须是final的?         于是我就试了一下访问不是final的变量,发现eclipse给出了错误提示:Cannot refer to the non-final local v
局部内部类引用外部类中的局部变量必须是final属性的!
如例中所示,声明了一个局部内部类TimerPrint,这个类中的方法引用了一个局部变量testTxt,必须声明为final!!why? 逻辑上:因为该内部类出现在一个方法的内部,但实际编译时,内部类编译为Outer$1TimerPrint.class,这说明,外部类的这个方法和内部类是处于同一级别的。换句话说是两者的生命周期不一样!start被调用后,非final变量也会随之消失,就会出现内
探索,java线程中使用局部变量:局部变量必须声明为final
java内部类访问局部变量时局部变量必须声明为final,同样,在线程中使用局部变量时,需将局部变量声明为final。 public class Thread2 { private static int num = 0; public static synchronized void printNum(String tag){ try { ...
【java】关于为什么局部内部类/匿名内部类只能访问final修饰的局部变量
public class AAa{     public void fun(){         int i =123;         Object obj = new Object();         // i++;                class LocalClass{             public void localFun() {                 Sy
多线程通过final访问主线程局部变量
文章标题看起来是一个错误命题,因为在java的内存模型中方法的局部变量是放在线程私有的栈里的。下图是java虚拟机的内存模型:rnrnrnrn rnrn那么如何访问呢?这当然是有前提的,首先必须是内部类,局部变量必须加final修饰符。看代码示例:rnrnrnJava代码  rnrnrnrnpublic class FinalTest {  rn    public static void mai
内部类访问局部变量时,为什么需要加final关键字
是变量的作用域的问题,因为匿名内部类是出现在一个方法的内部的,如果它要访问这个方法的参数或者方法中定义的变量,则这些参数和变量必须被修饰为final。因为虽然匿名内部类在方法的内部,但实际编译的时候,内部类编译成Outer.Inner,这说明内部类所处的位置和外部类中的方法处在同一个等级上,外部类中的方法中的变量或参数只是方法的局部变量,这些变量或参数的作用域只在这个方法内部有效。因为编译的时候内
为什么java内部类访问局部变量必须声明为final?
先抛出让我疑惑了很久的一个问题 编程时,在线程中使用局部变量时候经常编译器会提示:局部变量必须声明为final package test; public class ThreadTest { public void function(String a) { new Thread(){ @Override public void run() { Syst
Java8中 局部内部类访问的局部变量不必用final修饰
Java8中,局部内部类访问的局部变量不必为final修饰,这一点和Java7是不一样的。
为什么匿名内部类调用的方法内局部变量必须为final
Why inner classes require “final” outer instance variables ?      finalJTextFieldjtfContent =newJTextField();     btnOK.addActionListener(newjava.awt.event.ActionListener(){         publicvoid
Java 内部类中使用局部变量必须是final
在java中, 方法的内部类可以访问方法中的局部变量,但必须用final修饰才能访问。 原因: 1.当方法被调用运行完毕之后,局部变量就已消亡了。但内部类对象可能还存在, 直到没有被引用时才会消亡。此时就会出现一种情况,就是内部类要访问一个不存在的局部变量。                           2.解决这一问题的办法就是使用final修饰局部变量,通过将fina
为什么内部类调用的外部变量必须是final修饰的?
因为生命周期的原因。方法中的局部变量,方法结束后这个变量就要释放掉,final保证这个变量始终指向一个对象。首先,内部类和外部类其实是处于同一个级别,内部类不会因为定义在方法中就会随着方法的执行完毕而跟随者被销毁。问题就来了,如果外部类的方法中的变量不定义final,那么当外部类方法执行完毕的时候,这个局部变量肯定也就被GC了,然而内部类的某个方法还没有执行完,这个时候他所引用的外部变量已经找不到...
java面试题:final修饰局部变量的问题
/* 面试题:final修饰局部变量的问题 基本类型:基本类型的值不能发生改变。 引用类型:引用类型的地址值不能发生改变,但是,该对象的堆内存的值是可以改变的。 */ class Student { int age = 10; } class FinalTest { public static void main(String[] args) { //局部变量是基本数据
匿名内部类访问方法成员变量需要加final的原因及证明
在java编程中,没用的类定义太多对系统来说也是一个负担,这时候我们可以通过定义匿名内部类来简化编程,但匿名内部类访问外部方法的成员变量时都要求外部成员变量添加final修饰符,final修饰变量代表该变量只能被初始化一次,以后不能被修改。但为什么匿名内部类访问外部成员变量就不允许他修改了呢? 接下来这个例子应该足够把这些说清楚了: 示例代码: public class InnerFinal
Java--局部内部类在访问他所在方法中的局部变量必须用final修饰
当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用 public class JDK18 { public static void main(String[] a
为什么匿名内部类中用外部类的成员变量,外部类的成员变量必须是final
public void sessionCreated(HttpSessionEvent se) { // TODO Auto-generated method stub HttpSessionEvent session = se; System.out.println("Session创建了");// 10秒后 过期时间// 当一个session过期了,就不能用了,但是他还在内存中 并
为什么匿名内部类中引用的局部变量和参数需要final而成员字段不用?
http://www.blogjava.net/DLevin/archive/2011/11/23/364599.htmlrnrnrnrnrnrn昨天有一个比较爱思考的同事和我提起一个问题:为什么匿名内部类使用的局部变量和参数需要final修饰,而外部类的成员变量则不用?对这个问题我一直作为默认的语法了,木有仔细想过为什么(在分析完后有点印象在哪本书上看到过,但是就是没有找到,难道是我的幻觉?呵呵
Java方法变量中的final
今天由于对方法变量中的final有点困惑,在网上查了一下,才发现在方法变量中,final是这么一回事,这里做一下记录! 什么时候方法参数才需要加final关键字? 匿名/局部内部类访问外部方法参数时,外部参数需要加上final关键字。 用代码来解析: public void start(int interval, final boolean beep) { /** *...
JDK8之前,匿名内部类访问的局部变量为什么必须要用final修饰
前不久在学习中意外发现了自己原来忽略的一个小知识点,挺有意思的,现在我来给大家分享一下! 我们先来看一段代码 public class Hello { public static void main(String[] args) { String str=&quot;haha&quot;; new Thread() { @Override public void run() { ...
匿名内部类使用的外部变量为什么要是final的
匿名内部类内部,方法和作用域内的内部类内部使用的外部变量必须是 final 的是为什么?
使用匿名内部类,隐式调用外部变量,外部变量需要final修饰
本文章转自http://www.2cto.com/kf/201306/223568.html ————————————————————————————————
Java在new一个线程时使用的变量一定要用final修饰吗
这个是生命周期问题,举例说明: public static void main(String args[]){ final MyQueue mq = new MyQueue(5); Thread t1 = new Thread(new Runnable() { @Override public void run() { try { Thread.sleep(100)...
jdk7之前,匿名内部类访问局部变量加final修饰的问题(综合两种说法)
当使用匿名内部类的时候,如果匿名内部类需要访问匿名内部类所在方法中的局部变量的时候,必须给局部变量加final进行修饰。不加final修饰的局部变量,匿名内部类是访问不到的。这是为什么呢?网上有两种说法,第一种说法是从java编程思想那本书演化出来的,然而遭到了第二种说法的 反驳。第二种说法是直接反编译代码,用事实说话,然而却并不认同第一种说法。下面是我的见解,欢迎大家留言讨论。一.因为 内部类对...
java中内部类访问局部变量为什么要定义局部变量为final
因为方法内定义的变量是局部变量,离开该方法,变量就失去了作用,也就会自动被消除,而内部类却不会离开它所在方法就失去作用,它有更广的生命周期,下面通过一个实例加以说明:n如例中所示,在外部类Outer中声明了一个内部类TimerPrint,这个类中的方法引用了方法start中的一个局部变量testTxtn逻辑上:因为该内部类出现在一个方法的内部,但实际编译时,内部类编译为Outer$1TimerPr
Java内部类访问外部对象为什么必须是final的呢?
为什么必须是final的呢? 一个谜团 如果你用过类似guava这种“伪函数式编程”风格的library的话,那下面这种风格的代码对你来说应该不陌生: 1 2 3 4 5 6 7 8 9 public void tryUsingGuava() { final int expectedLength = 4; Iterables.f
局部变量被内部类访问时必须用final修饰的问题
今天随手写了点东西,又遇到了这个问题,就是在当内部类想要访问局部变量的时候 ,Java就要求该局部变量必须用final关键字进行修饰。之前写程序的时候经常遇到这样的问题,当时只是奔着快点结局问题的目的也没仔细的思考它本质的原因。rn但是我想Java如此的设计肯定有其目的,于是便静下心来想了一下。rn先贴一个实例。rn/*rn * final修饰局部变量的问题测试rn * rn */rnpublic
java匿名内部类使用外部变量时,外部变量必须是final,为什么?
1,Java中的匿名内部类是如何实现的? 先定义一个接口: 1 2 3 public interface MyInterface { void doSomething(); } 然后创建这个接口的匿名子类: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 publi
Java 8 Lambda 捕获外部变量 -- 不可变的原因
source:http://www.th7.cn/Program/java/201512/720446.shtml 是因为,最后一段说到的,lambda表达式是在另一个线程中执行。 可能会把捕获外部变量的 Lambda 表达式称为闭包,那么 Java 8 的 Lambda 可以捕获什么变量呢? 捕获实例或静态变量是没有限制的(可认为是通过 final 类型的局部变量
java 方法内部类 使用外部的变量为啥要是 final
例子:public class T { public static void main(String[] args) { T test = new T(); test.testRun(); } public void testRun() { Thread t = new Thread(this.getRun()); ...
局部内部类为什么只能访问final修饰的局部变量
[html] view plain copy //只有定义成 final String obj 才不会报错   public void test(final String obj)   {       Thread myThread = new Thread() {            public void run() {                
为什么内部类使用的局部变量必须是final而全局变量可以是no-final
原因在于局部变量和全局变量的区别。 一个全局变量的生命周期伴随该类对象一直存在, 所以可以被内部类所引用。 但是, 一个局部变量的生命周期仅限于方法内部, 而且编译器对它们的处理不一样。 因为内部类隐式复制变量作为它的参数, 如果没有将局部变量声明为final, 则变量一旦被改变, 由于内部类还在引用原始的变量从而导致不易发现的错误。     原文:StackOverflow
JAVA局部变量加final修饰的好处
一般来说有以下这几种用法: 1、for循环中,使用局变量来保存循环数次,并用final修饰,而非直接用getCount()、getSize()、lenght等 2、需要访问集合中的某个对象时,使用局部变量来引用,并用final修饰,而非直接引用 3、需要访问外部某个对象时,使用局部变量来引用,并用final修饰,而非直接引用 4、其它情况   个人理解的好处有: 1、访问局部变量要比
final成员变量和final局部变量
达人科技 2016-10-10 10:00 一 final变量简介 1 final修饰变量时表示该变量一旦获得初始值之后就不可能改变。 2 final既可修饰成员变量,也可修饰局部变量。 二 final修饰成员变量 1 final修饰成员变量时,必须由程序员显示地指定初始值。 2 类变量:必须在静态初始化块中指定初始值或声明该变量时指定初始值,而且只能在两个地方的其中之一指定。
内部类引用外部类的局部变量要用final修饰
为什么内部类引用外部类的局部变量时,此变量要用final修饰nn代码nn public void test() {nn final int i = 3;nn runOnUiThread(new Runnable() {n @Overriden public void run() {n mTvShow.s
局部内部类能访问非final类型局部变量?
答案: 不能。经过查看许多人给出的分析,得出我个人认为比较有说服力的原因:为了克服局部内部类和局部变量的生命周期不一致问题,java只能拷贝局部变量的副本到局部内部类,如下代码 static class A { String name; public A(String name) { this.name = name; }
java为什么匿名内部类的参数引用时final?
https://www.zhihu.com/question/21395848
为什么内部类访问局部变量需要加final修饰?
先看一段代码:public void myRun(final String name){ new Runnable() { public void run() { try { Thread.sleep(1000);
对内部类引用外部方法变量需用final修饰的理解
参考网上的解释,对于下面一种解释比较赞同 因为生命周期的原因。方法中的局部变量,方法结束后这个变量就要释放掉,final保证这个变量始终指向一个对象。 首先,内部类和外部类其实是处于同一个级别,内部类不会因为定义在方法中就会随着方法的执行完毕而跟随者被销毁。问题就来了,如果外部类的方法中的变量不定义final,那么当外部类方法执行完毕的时候,这个局部变量所引用的对象肯定也就被GC了,然而内
Java 8 lambda表达式中为什么要求外部变量为final
我的理解如下,如有错误欢迎指正。 这是由Java对lambda表达式的实现决定的,在Java中lambda表达式是匿名类语法上的进一步简化,其本质还是调用对象的方法。 在Java中方法调用是值传递的,所以在lambda表达式中对变量的操作都是基于原变量的副本,不会影响到原变量的值。 综上,假定没有要求lambda表达式外部变量为final修饰,那么开发者会误以为外部变量的值能够在lambda...
java 为什么匿名内部类和局部内部类只能访问final变量
转:http://feiyeguohai.iteye.com/blog/1500108 为什么匿名内部类参数必须为final类型 1)  从程序设计语言的理论上:局部内部类(即:定义在方法中的内部类),由于本身就是在方法内部(可出现在形式参数定义处或者方法体处),因而访问方法中的局部变量(形式参数或局部变量)是天经地义的.是很自然的 2)  为什么JAVA中要加上一条限制:只能访
注意java8中已经没有匿名内部类和局部内部类只能访问final变量的限制了!
今天写Android代码编译器报错Variable 'arrayAdapter' is accessed from within inner class, needs to be declared final。 于是打算找几篇博客学习学习,结果不管我怎么弄,在java编译器上就是不报错啊! 转念一想,是不是我用JDK1.8的原因,百度一下,知乎证实了我的猜想。 具体见:http://
Java中为什么匿名对象中方法,调用局部变量必须加final呢?
先上代码rnpublic class Mytest1 {rn    static List a1 = new ArrayList();rnrnrn    public static void main(String[] args) {rn        final List a2 = new ArrayList();rn        Thread b = new Thread() {rn   
为什么lambda表达式要用final
转自:http://unmi.cc/java-8-lambda-capture-outer-variables/ 可能会把捕获外部变量的 Lambda 表达式称为闭包,那么 Java 8 的 Lambda 可以捕获什么变量呢? 捕获实例或静态变量是没有限制的(可认为是通过 final 类型的局部变量 this 来引用前两者) 捕获的局部变量必须显式的声明为 final 或实际效果
关于final在局部变量的定义问题
不用初始化变量,可以通过方法的调用传值 来给局部变量赋值 public class Student { public static void main(String[] args) { Student Students = new Student(); Students.ab(5); } public void ab(int b) { final int a; a
内部类中引用的变量必须要声明为final的原因
Cannot refer to a non-final variable mylis inside an inner class defined in a different methodrnrnrnrn查了下看到有人说原因如下:rnrnrnrnrn局部匿名类在源代码编译后也是要生成对应的class文件的(一般会是A$1.class这种形式的文件),那么这个二进制文件是独立于其外围类(A.clas
Java内部类的使用小结 形参为什么要用final
部类是指在一个外部类的内部再定义一个类。类名不需要和文件夹相同。 *内部类可以是静态static的,也可用public,default,protected和private修饰。(而外部顶级类即类名和文件名相同的只能使用public和default)。   注意:内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inne
lambda表达式访问变量和方法
一、lambda表达式(lambda块)中访问变量和方法 1、lambda表达式可以其访问外层作用域定义的局部变量。但是lambda表达式不能修改外层局部变量的值。如: public static void main(String[] args) { double var = 100; // 外层局部变量 DemoFunc df = (n) -> { double res
java中final修饰的局部变量
在java中用final修饰的类,不能被改变; final修饰的类的局部变量,其指向地址不能改变,地址指向的值是可以改变的。也就是说如果为值型,则其值除了初始化之外,不可以被再次赋值;如果为引用型,则表示该引用不能指向其他的对象,但是该引用指向的对象本身是可以改变其值的。 final变量在任何地方都可以被初始化,但是一旦初始化之后,就不能重新指向新的对象,来改变其值。
相关热词 c# clr dll c# 如何orm c# 固定大小的字符数组 c#框架设计 c# 删除数据库 c# 中文文字 图片转 c# 成员属性 接口 c#如何将程序封装 16进制负数转换 c# c#练手项目
立即提问