Java---个人编程错误收集---01

最新推荐文章于 2022-05-05 14:55:25 发布

ALLACS

最新推荐文章于 2022-05-05 14:55:25 发布

阅读量328

点赞数

分类专栏： # JAVA学习文章标签： Java 错误

本文链接：https://blog.csdn.net/m0_37428263/article/details/93755678

版权

JAVA学习专栏收录该内容

19 篇文章 0 订阅

订阅专栏

1.错误信息：Local variable num defined in an enclosing scope must be final or effectively final

引用自：https://blog.csdn.net/sf_climber/article/details/78326984

报错代码：

package cn.MulThreadOthers.java.mhz;
/**
 * Lambda表达式其实是匿名内部类的一种简化，因此它可以部分取代匿名内部类
 * Lambda表达式与匿名内部类一样，都可以直接访问"effectively final"的局部变量，以及外部类的成员变量
 * Lambda表达式创建的对象与匿名内部类生成的对象一样，都可以直接调用从接口中继承的默认方法
 * volatile用于保证线程数据的同步性,也就是可见性
 * @author MHZ
 *
 */
public class MyJavaMulThreadVolatile {
	//不能写到main方法内部，这样编译会报错，lambda表达式和匿名内部类只能访问到外部的成员变量和内部的使用final修饰的局部变量
	//private volatile static int num  = 0;
	public static void main(String[] args) throws InterruptedException {
		int num = 0;
		//lambda表达式
		new Thread(()->{
			while(num==0) {
				
			}
		}).start();
		Thread.sleep(1000);
		num = 1;
		//内部匿名类
		new Thread(new Runnable() {
			public void run()
			{
				while(num == 0)
				{
					System.out.println("");
				}
			}
		}).start();
	}
}

编译结果：

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
	Local variable num defined in an enclosing scope must be final or effectively final
	Local variable num defined in an enclosing scope must be final or effectively final

	at cn.MulThreadOthers.java.mhz.MyJavaMulThreadVolatile.main(MyJavaMulThreadVolatile.java:17)

问题处理：

首先翻译报错信息，我们得出局部内部类和匿名内部类只能访问final的局部变量或者与final具有同等作用的外部变量，后来通过查看文档和资料，我们得到结论，这是由于作用域中变量的生命周期导致的。

首先知道一点：内部类和外部类是处于同一个级别的,内部类不会因为定义在方法中就会随着方法的执行完毕就被销毁。这样的话，当外部类的方法结束的时候，局部变量就会被销毁了，但是内部类对象可能还存在，这样就出现了一个矛盾：内部类对象访问了一个不存在的变量，为了解决这个问题，就将局部变量复制了一份作为内部类的成员变量，这样当局部变量死亡后，内部类仍可以访问它，实际访问的是局部变量的”copy”。这样就好像延长了局部变量的生命周期。

问题又出现了：将局部变量复制为内部类的成员变量时，必须保证这两个变量是一样的，也就是如果我们在内部类中修改了成员变量，方法中的局部变量也得跟着改变，怎么解决问题呢？

就将局部变量设置为final，对它初始化后，我就不让你再去修改这个变量，就保证了内部类的成员变量和方法的局部变量的一致性。这实际上也是一种妥协。

若变量是final时：

若是基本类型，其值是不能改变的，就保证了copy与原始的局部变量的值是一样的；

若是引用类型，其引用是不能改变的，保证了copy与原始的变量引用的是同一个对象。

这就使得局部变量与内部类内建立的拷贝保持一致。

所以，我们根据要使得内部类中变量不变的思想，有两种方式来解决这个问题：

第一，将外部类的成员变量声明为static，这样成员变量成为了类变量，延长了生命周期

package cn.MulThreadOthers.java.mhz;
/**
 * Lambda表达式其实是匿名内部类的一种简化，因此它可以部分取代匿名内部类
 * Lambda表达式与匿名内部类一样，都可以直接访问"effectively final"的局部变量，以及外部类的成员变量
 * Lambda表达式创建的对象与匿名内部类生成的对象一样，都可以直接调用从接口中继承的默认方法
 * volatile用于保证线程数据的同步性,也就是可见性
 * @author MHZ
 *
 */
public class MyJavaMulThreadVolatile {
	//不能写到main方法内部，这样编译会报错，lambda表达式和匿名内部类只能访问到外部的成员变量和内部的使用final修饰的局部变量
	private volatile static int num  = 0;
	public static void main(String[] args) throws InterruptedException {
		//lambda表达式
		new Thread(()->{
			while(num==0) {
				
			}
		}).start();
		Thread.sleep(1000);
		num = 1;
		//内部匿名类
		new Thread(new Runnable() {
			public void run()
			{
				while(num == 0)
				{
					System.out.println("");
				}
			}
		}).start();
	}
}

第二：将局部变量声明为final类型的，同时要注意volatile和final不能联用

package cn.MulThreadOthers.java.mhz;
/**
 * Lambda表达式其实是匿名内部类的一种简化，因此它可以部分取代匿名内部类
 * Lambda表达式与匿名内部类一样，都可以直接访问"effectively final"的局部变量，以及外部类的成员变量
 * Lambda表达式创建的对象与匿名内部类生成的对象一样，都可以直接调用从接口中继承的默认方法
 * volatile用于保证线程数据的同步性,也就是可见性
 * @author MHZ
 *
 */
public class MyJavaMulThreadVolatile {
	//不能写到main方法内部，这样编译会报错，lambda表达式和匿名内部类只能访问到外部的成员变量和内部的使用final修饰的局部变量
	public static void main(String[] args) throws InterruptedException {
		//lambda表达式
		final int num = 0;
		new Thread(()->{
			while(num==0) {
				
			}
		}).start();
		Thread.sleep(1000);
		//内部匿名类
		new Thread(new Runnable() {
			public void run()
			{
				while(num == 0)
				{
					System.out.println("");
				}
			}
		}).start();
	}
}

又如下面的例子：

第一种方式：

class OutClass {
	private int age = 12;
	private final int x = 5;
	public void outPrint() {
		class InClass {
			public void InPrint() {
				System.out.println(x);
				System.out.println(age);
			}
		}
		new InClass().InPrint();
	}
}

第二种方式：

class OutClass {
	private int age = 12;
	private static int x;
	public void outPrint() {
		class InClass {
			public void InPrint() {
				System.out.println(x);
				System.out.println(age);
			}
		}
		new InClass().InPrint();
	}
}

第三种方式：

class OutClass {
	private int age = 12;
	public void outPrint(final int x) {
		class InClass {
			public void InPrint() {
				System.out.println(x);
				System.out.println(age);
			}
		}
		new InClass().InPrint();
	}
}