局部内部类调用局部变量的注意事项
package 内部类;

 class Outer {
    public void fun() { //外部类的成员方法
        int a = 20;
        final int b = 30;
         class Inner {   //成员方法的局部内部类
             public void fun1() { //内部类的方法
                 //内部类调用局部变量时，局部变量必须是有效final的
                 System.out.println(a); //Java8+以后如果局部变量是事实不变的也可不用加final 修饰符
                 System.out.println(b);
             }
         }
    }
}


原因：方法中的局部变量随方法储存在栈中，而类创建的对象储存在堆中，当方法调用完毕后，局部变量会随方法一起消失，如果局部变量发生变化了，类的对象不知道它是否发生变化，所以只能$copy$局部变量的$final$。

下面是匿名内部类的调用



如果接口里只有一种 抽象方法  那这样覆盖重写  还挺方便 …

起码不用  建立class 实现类了…    但这样 接口文件 就会多了啊   感觉很鸡肋啊

1、	什么是内部类

将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。

2、内部类的分类

内部类分为成员内部类与局部内部类。

我们定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。
①成员内部类：

1、成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问

2、成员内部类可以使用成员修饰符：public、static…,它是一个类，可以继承、可以实现接口

成员内部类定义格式:
class 外部类 { 
	修饰符 class 内部类 {
		//其他代码
	}
}

成员内部类代码演示：
public class Outer {
	private int i = 1;
	//外部类成员的位置，定义内部类
	class Inner {
		public void inner() {
			System.out.println("内部类方法inner "+ i);
		}
	}
}

调用规则：



	内部类可以使用外部类成员，包括私有  



	外部类使用内部类必须建立内部类对象




访问方式：

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

结合上面成员内部类的例子，代码演示：
public class Outer_Test {

	public static void main(String[] args) {
		/*
		 * 调用外部类中内部类的方法inner
		 * 
		 * 依靠外部类对象找到内部类，利用内部类对象，调用内部类方法
		 *  访问方式：
					外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
					变量名.内部类方法;
		 */
		Outer.Inner in = new Outer().new Inner();
		in.inner();
	}
}

②局部内部类：

1、局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问

2、局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问

局部内部类定义格式

class 外部类 { 
	修饰符 返回值类型 方法名(参数) {
		class 内部类 {
			//其他代码
		}
	}
}

局部内部类代码演示：
public class JuBu_Outer {
	public void out() {
		class Inner{
			public void inner() {
				System.out.println("局部内部类方法inner");
			}
		}
//		在外部类方法中，创建内部类对象
		Inner in = new Inner();
		in.inner();
	}
}

访问方式：

在外部类方法中，创建内部类对象，进行访问

结合上面局部内部类的例子，代码演示：
public class JuBu_Outer_Test {

	public static void main(String[] args) {
		//调用局部内部类方法inner
		new JuBu_Outer().out();

	}

}

3、内部类的实际使用——匿名内部类

一、定义的匿名内部类有两个含义：

① 临时定义某一指定类型的子类

② 定义后即刻创建刚刚定义的这个子类的对象

③匿名内部类属于局部内部类

二、定义匿名内部类的作用与格式

1、作用：

匿名内部类是创建某个类型子类对象的快捷方式。

格式：
new 父类或接口(){
	//进行方法重写
};

匿名内部类代码演示：
public interface NiMing_inter {
	//创建一个接口，里面有两个抽象方法
	public abstract void smoking();
	public abstract void playing();
}

public class NiMing_interTest {
	
	public static void main(String[] args) {
		//使用内部类实现smoking()、playing()方法
/*
		 * 定义实现类、重写方法、建立实现类对象，合为一步完成
		
		格式：
				new 父类或接口(){
					//进行方法重写
				};		
 */	
		new NiMing_inter() {		//new 父类或接口()
			public void smoking() {		//smoking方法重写
				System.out.println("人在吸烟！");
			}
			public void playing() {		//playing方法重写
				System.out.println("人在玩耍！");
			}
		}.smoking();//调用重写方法
		new NiMing_inter() {		//new 父类或接口()
			public void smoking() {		//smoking方法重写
				System.out.println("人在吸烟！");
			}
			public void playing() {		//playing方法重写
				System.out.println("人在玩耍！");
			}
		}.playing();//调用重写方法
		
//		利用多肽性，父类引用 = 子类对象
		System.out.println("\n——————多态性调用——————");
		NiMing_inter i = new NiMing_inter() {
			public void smoking() {		//smoking方法重写
				System.out.println("人在吸烟！");
			}
			public void playing() {		//playing方法重写
				System.out.println("人在玩耍！");
			}
		};
		i.smoking();
		i.playing();
	}
}

从new开始，到；（分号）结束，创建了接口NiMing_inter实现类的对象:
new NiMing_inter() {		//new 父类或接口()
			public void smoking() {		//smoking方法重写
				System.out.println("人在吸烟！");
			}
			public void playing() {		//playing方法重写
				System.out.println("人在玩耍！");
			}
		};


以上代码也是NiMing_inter的子类匿名对象

原因：

1、使用匿名对象的方式，将定义子类与创建子类对象两个步骤由一个格式一次完成。

2、虽然是两个步骤，但是两个步骤是连在一起完成的。

3、匿名内部类如果不定义变量引用，则也是匿名对象。

使用Junit单元测试

局部内部类封装在外部类的一个方法中，此方法一般会有一个返回值，返回该局部类类型
package com.yzy.innerclass;

import org.junit.Test;

/**
 * @className LocalInnerClass.java
 * @author yangsir
 * @version V1.0
 * @date 2019年8月9日-上午12:03:03
 * @description 如何调用局部内部类
 */
public class LocalInnerClass {
	@Test
	public void test1() {

		// 1常规
		Work w = new Student();// 父类引用指向子类对象
		w.doWork();// 调用子类重写的接口中的方法
		// 匿名类的对象
		Work w1 = new Work() {
			@Override
			public void doWork() {
				System.out.println("工作");
			}
		};
		w1.doWork();// 调用匿名类的方法
		System.out.println("===================================================");
	}

	@Test
	public void test2() {

		// 2匿名类的匿名对象
		new Work() {
			@Override
			public void doWork() {
				System.out.println("工作");

			}
		}.doWork();// 直接用new().work的形式，要重写doWork方法
		System.out.println("===================================================");
	}

	@Test
	public void test3() {

		// 1.调用局部内部类
//		Work work = new LocalInnerClass().getWork();  //new Teacher();  //创建一个局部内部类对象
//		work.doWork();//调用getWork方法输出讲课（已注释）
		// 2.调用
		Work work = new LocalInnerClass().getWork();// 创建一个局部内部类对象
		work.doWork();// 调用
	}

	// 局部内部类
	public Work getWork() {
		// 1局部内部类
//		class Teacher implements Work{//局部内部类实现接口，重写doWork方法，返回值为Teacher
//			@Override
//			public void doWork() {
//				System.out.println("讲课");
//			}
//		} 
//		return new Teacher();//返回一个Teacher对象
		// 2局部内部类 匿名类的匿名对象
		return new Work() {// 直接return一个匿名对象，然后重写里面的方法即可，注意这里的括号
			@Override
			public void doWork() {
				System.out.println("员工在工作");

			}
		};
	}
}

interface Work { // 一个接口
	void doWork();
}

class Student implements Work {// 实现接口的类，有自己的方法

	@Override
	public void doWork() {
		System.out.println("学习");
	}

}


下面放一位小姐姐的总结图