修饰符

1、static修饰符
1、static变量
在类中,使用static修饰的成员变量,就是静态变量,反之为非静态变量。
静态变量和非静态变量的区别
静态变量属于类的,"可以"使用类名来访问,非静态变量是属于对象的,"必须"使用对象来访问.

1	public class Student{
2	private static int age;
3	private double score;
4	
5	public static void main(String[] args) {
6	Student s = new Student();
7	//推荐使用类名访问静态成员
8	System.out.println(Student.age);
9	System.out.println(s.age);
10	
11	System.out.println(s.score);
12	}
13	}

静态变量对于类而言在内存中只有一个,能被类的所有实例所共享。实例变量对于类的每个实例都有一份, 它们之间互不影响.

public class Student{
private static int count;
private int num;
public Student() {

count++;
num++;
}
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
Student s3 = new Student();
Student s4 = new Student();
//因为还是在类中,所以可以直接访问私有属性
System.out.println(s1.num);
System.out.println(s2.num);
System.out.println(s3.num);
System.out.println(s4.num);

System.out.println(Student.count);
System.out.println(s1.count);
System.out.println(s2.count);
System.out.println(s3.count);
System.out.println(s4.count);
}
}

在加载类的过程中为静态变量分配内存,实例变量在创建对象时分配内存，所以静态变量可以使用类名来 直接访问,而不需要使用对象来访问.
2、static方法
在类中,使用static修饰的成员方法,就是静态方法,反之为非静态方法。
静态方法和非静态方法的区别

静态方法数属于类的,"可以"使用类名来调用,非静态方法是属于对象的,"必须"使用对象来调用.

静态方法"不可以"直接访问类中的非静态变量和非静态方法,但是"可以"直接访问类中的静态变量和静态 方法
注意:this和super在类中属于非静态的变量.(静态方法中不能使用)

public class Student{
private static int count;
private int num;
public void run(){}
public static void go(){}

public static void test(){
//编译通过
System.out.println(count);
go();

//编译报错
System.out.println(num);
run();
}
}

非静态方法"可以"直接访问类中的非静态变量和非静态方法,也"可以"直接访问类中的静态变量和静态方法

public class Student{
private static int count;
private int num;
public void run(){}
public static void go(){}

public void test(){
//编译通过
System.out.println(count);
go();

//编译通过
System.out.println(num);
run();
}

}

思考:为什么静态方法和非静态方法不能直接相互访问? 加载顺序的问题！ 父类的静态方法可以被子类继承,但是不能被子类重写。

public class Person {
public static void method() {}
}

//编译报错
public class Student extends Person {
public void method(){}
}


例如:
public class Person {
public static void test() {
System.out.println("Person");
}
}

//编译通过,但不是重写
public class Student extends Person {
public static void test(){
System.out.println("Student");
}
}

main:
Perosn p = new Student();
p.test();//输出Person
p = new Person();
p.test();//输出Perosn

和非静态方法重写后的效果不一样，父类的非静态方法不能被子类重写为静态方法。

public class Person {
public void test() {
System.out.println("Person");
}
}

//编译报错
public class Student extends Person {
public static void test(){
System.out.println("Student");
}
}

3、代码块和静态代码块
【类中可以编写代码块和静态代码块】

public class Person {
{
//代码块(匿名代码块)
}

static{
//静态代码块
}
}

【匿名代码块和静态代码块的执行】
因为没有名字,在程序并不能主动调用这些代码块。
匿名代码块是在创建对象的时候自动执行的,并且在构造器执行之前。同时匿名代码块在每次创建对象的 时候都会自动执行.
静态代码块是在类加载完成之后就自动执行,并且只执行一次.
注:每个类在第一次被使用的时候就会被加载,并且一般只会加载一次.

public class Person {
{
System.out.println("匿名代码块");
}

static{
System.out.println("静态代码块");
}

public Person(){
System.out.println("构造器");
}
}
main:
Student s1 = new Student();
Student s2 = new Student();
Student s3 = new Student();

//输出

【匿名代码块和静态代码块的作用】
匿名代码块的作用是给对象的成员变量初始化赋值,但是因为构造器也能完成这项工作,所以匿名代码块 使用的并不多。
静态代码块的作用是给类中的静态成员变量初始化赋值。例如:

public class Person {
public static String name;
static{
name = "tom";
}
public Person(){
name = "zs";
}
}

main:
System.out.println(Person.name);//tom

注：在构造器中给静态变量赋值,并不能保证能赋值成功,因为构造器是在创建对象的时候才指向,但是静 态变量可以不创建对象而直接使用类名来访问.
4、创建和初始化对象的过程

Student s = new Student();

【Student类之前没有进行类加载】
1.类加载,同时初始化类中静态的属性
2.执行静态代码块
3.分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null)
4.调用Student的父类构造器
5.对Student中的属性进行显示赋值(如果有的话)
6.执行匿名代码块
7.执行构造器
8.返回内存地址
注:子类中非静态属性的显示赋值是在父类构造器执行完之后和子类中的匿名代码块执行之前的时候

1public class Person{
2private String name = "zs";
3public Person() {
4System.out.println("Person构造器");
5print();
6	}
7	public void print(){
System.out.println("Person print方法: name = "+name);
}
}

public class Student extends Person{
private String name = "tom";
{
System.out.println("Student匿名代码块");
}

static{
System.out.println("Student静态代码块");
}
public Student(){
System.out.println("Student构造器");
}
public void print(){
System.out.println("student print方法: name = "+name);
}
public static void main(String[] args) {
new Student();
}
}

//输出：
Student静态代码块
Person构造器
student print方法: name = null
Student匿名代码块
Student构造器

Student s = new Student();
Student类之前已经进行了类加载
1.分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null)
2.调用Student的父类构造器
3.对Student中的属性进行显示赋值(如果有的话)
4.执行匿名代码块
5.执行构造器
6.返回内存地址

5、静态导入
静态导包就是java包的静态导入，用import static代替import静态导入包是JDK1.5中的新特性。意思是导入这个类里的静态方法。
好处：这种方法的好处就是可以简化一些操作，例如打印操作System.out.println(…);就可以将其写入一 个静态方
法print(…)，在使用时直接print(…)就可以了。但是这种方法建议在有很多重复调用的时候使用，如果仅 有一到两次调用，不如直接写来的方便

import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Test {
public static void main(String[] args) {
//之前是需要Math.random()调用的
System.out.println(random());
System.out.println(PI);
}
}

2、final修饰符
1、修饰类
用final修饰的类不能被继承,没有子类。
例如:我们是无法写一个类去继承String类,然后对String类型扩展的,因为API中已经被String类定义为final 的了.
我们也可以定义final修饰的类:

public final class Action{

}

//编译报错
public class Go extends Action{

}

2、修饰方法
用final修饰的方法可以被继承,但是不能被子类的重写。
例如:每个类都是Object类的子类,继承了Object中的众多方法,在子类中可以重写toString方法、equals方 法等,但是不能重写getClass方法 wait方法等,因为这些方法都是使用fianl修饰的。
我们也可以定义final修饰的方法:

public class Person{
public final void print(){}
}

//编译报错
public class Student extends Person{
public void print(){

}
}

3、修饰变量
用final修饰的变量表示常量,只能被赋一次值.其实使用final修饰的变量也就成了常量了,因为值不会再变 了。
【修饰局部变量】

1public class Person{
2public void print(final int a){
3//编译报错,不能再次赋值,传参的时候已经赋过了
4	a = 1;
}
}

public class Person{
public void print(){
final int a;
a = 1;
//编译报错,不能再次赋值
a = 2;
}
}

【修饰成员变量-非静态成员变量】

public class Person{ private final int a;
}
只有一次机会,可以给此变量a赋值的位置: 声明的同时赋值
匿名代码块中赋值

【修饰成员变量-静态成员变量】

public class Person{
private static final int a;
}
只有一次机会,可以给此变量a赋值的位置: 声明的同时赋值
静态代码块中赋值

【修饰引用变量】

main:
final Student s = new Student();
//编译通过
s.setName("tom");
s.setName("zs");

//编译报错,不能修改引用s指向的内存地址
s = new Student();

3、abstract修饰符
abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那 么该类就是抽象类。
1、抽象类和抽象方法的关系
抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
2、语法

public abstract class Action{
public abstract void doSomething();
}


public void doSomething(){...}

对于这个普通方法来讲:
"public void doSomething()"这部分是方法的声明
"{…}"这部分是方法的实现,如果大括号中什么都没写,就叫方法的空实现
声明类的同时,加上abstract修饰符就是抽象类
声明方法的时候,加上abstract修饰符,并且去掉方法的大口号,同时结尾加上分号,该方法就是抽象方法。
3、特点及作用
抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
注:子类继承抽象类后,需要实现抽象类中没有实现的抽象方法,否则这个子类也要声明为抽象类。

public abstract class Action{
public abstract void doSomething();
}

main:
//编译报错,抽象类不能new对象
Action a = new Action();

//子类继承抽象类
public class Eat extends Action{
//实现父类中没有实现的抽象方法
public void doSomething(){
//code
}
}

main:
Action a = new Eat();
a.doSomething();

注:子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。
4、思考
思考1 : 抽象类不能new对象,那么抽象类中有没有构造器?

抽象类是不能被实例化,抽象类的目的就是为实现多态中的共同点,抽象类的构造器会在子类实例化时调
用,因此它也是用来实现多态中的共同点构造，不建议这样使用！

思考2 : 抽象类和抽象方法意义(为什么要编写抽象类、抽象方法)

打个比方，要做一个游戏。如果要创建一个角色，如果反复创建类和方法会很繁琐和麻烦。建一个抽象类
后。若要创建角色可直接继承抽象类中的字段和方法，而抽象类中又有抽象方法。如果一个角色有很多种
职业，每个职业又有很多技能，要是依次实例这些技能方法会显得想当笨拙。定义抽象方法，在需要时继
承后重写调用，可以省去很多代码。
总之抽象类和抽象方法起到一个框架作用。很方便后期的调用和重写
抽象方法是为了程序的可扩展性。重写抽象方法时即可实现同名方法但又非同目的的要求。

接口

1、接口的本质
普通类：只有具体实现
抽象类：具体实现和规范(抽象方法) 都有！ 接口：只有规范！
【为什么需要接口?接口和抽象类的区别?】
接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了： 规范和具体实现的分离。
抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法。接口是完全面 向规范的，规定了一批类具有的公共方法规范。
从接口的实现者角度看，接口定义了可以向外部提供的服务。从接口的调用者角度看，接口定义了实现者能提供那些服务。
接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的系统之间模块之间的接口定义 好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。大家在工作以后，做系 统时往往就是使用“面向接口”的思想来设计系统。
【接口的本质探讨】
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天 使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人；如果你是坏人，则 必须欺负好人。
接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计 模式都只针对具备了抽象能力的语言（比如c++、java、c#等），就是因为设计模式所研究的，实际上就是如何合 理的去抽象。
2、接口与抽象类的区别
抽象类也是类,除了可以写抽象方法以及不能直接new对象之外,其他的和普通类没有什么不一样的。接 口已经另一种类型了,和类是有本质的区别的,所以不能用类的标准去衡量接口。
声明类的关键字是class,声明接口的关键字是interface。
抽象类是用来被继承的,java中的类是单继承。
类A继承了抽象类B,那么类A的对象就属于B类型了,可以使用多态一个父类的引用,可以指向这个父类的任意子类对象
注:继承的关键字是extends
接口是用来被类实现的,java中的接口可以被多实现。
类A实现接口B、C、D、E…,那么类A的对象就属于B、C、D、E等类型了,可以使用多态一个接口的引用,可以指向这个接口的任意实现类对象
注:实现的关键字是implements
3、接口中的方法都是抽象方法
接口中可以不写任何方法,但如果写方法了,该方法必须是抽象方法

public interface Action{
public abstract void run();

//默认就是public abstract修饰的
void test();
public void go();
}

4、接口中的变量都是静态常量(public static final修饰)
接口中可以不写任何属性,但如果写属性了,该属性必须是public static final修饰的静态常量。注:可以直接使用接口名访问其属性。因为是public static修饰的
注:声明的同时就必须赋值.(因为接口中不能编写静态代码块)

public interface Action{
public static final String NAME = "tom";
//默认就是public static final修饰的int AGE = 20;
}
main: System.out.println(Action.NAME); System.out.println(Action.AGE);

5、一个类可以实现多个接口

public class Student implements A,B,C,D{
//Student需要实现接口A B C D中所有的抽象方法
//否则Student类就要声明为抽象类,因为有抽象方法没实现
}
main:
A s1 = new Student(); B s2 = new Student(); C s3 = new Student(); D s4 = new Student();

注:
s1只能调用接口A中声明的方法以及Object中的方法s2只能调用接口B中声明的方法以及Object中的方法s3只能调用接口C中声明的方法以及Object中的方法s4只能调用接口D中声明的方法以及Object中的方法
注:必要时可以类型强制转换
例如 : 接口A 中有test() ， 接口B 中有run()

A s1 = new Student();
s1.test();

B s2 = new Student();
s2.run();

if(s1 instanceof B){
((B)s1).run();
}

6、一个接口可以继承多个父接口

public interface A{
public void testA();
}

public interface B{
public void testB();
}

//接口C把接口A B中的方法都继承过来了
public interface C extends A,B{
public void testC();
}

//Student相当于实现了A B C三个接口,需要实现所有的抽象方法
//Student的对象也就同时属于A类型 B类型 C类型
public class Student implements C{
public viod testA(){}
public viod testB(){}
public viod testC(){}
}

main:
C o = new Student();
System.out.println(o instanceof A);//true
System.out.println(o instanceof B);//true
System.out.println(o instanceof C);//true
System.out.println(o instanceof Student);//true
System.out.println(o instanceof Object);//true
System.out.println(o instanceof Teacher);//false

//编译报错
System.out.println(o instanceof String);

注:System.out.println(o instanceof X);

如果o是一个接口类型声明的变量,那么只要X不是一个final修饰的类,该代码就能通过编译,至于其结果 是不是true,就要看变量o指向的对象的实际类型,是不是X的子类或者实现类了。

注:一个引用所指向的对象,是有可能实现任何一个接口的。(java中的多实现)
7、接口的作用
接口的最主要的作用是达到统一访问，就是在创建对象的时候用接口创建
【接口名】 【对象名】= new 【实现接口的类】
这样你像用哪个类的对象就可以new哪个对象了，不需要改原来的代码。
假如我们两个类中都有个function()的方法，如果我用接口，那样我new a()；就是用a的方法，new b（）就是用b的方法
这个就叫统一访问，因为你实现这个接口的类的方法名相同，但是实现内容不同总结：
1、Java接口中的成员变量默认都是public,static,final类型的(都可省略),必须被显示初始化,即接 口中的成员变量为常量(大写,单词之间用"_"分隔)
2、Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化 3、Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法 4、接口中没有构造方法,不能被实例化
5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口
6、Java接口必须通过类来实现它的抽象方法
7、当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类
8、不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例
9、 一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承.
【实例】

> interface SwimInterface{
void swim();
}
class Fish{
int fins=4;
}
class Duck {
int leg=2;
void egg(){};
}

class Goldfish extends Fish implements SwimInterface {
@Override
public void swim() {
System.out.println("Goldfish can swim ");
}
}

class SmallDuck extends Duck implements SwimInterface {
public void egg(){
System.out.println("SmallDuck can lay eggs ");
}
@Override
public void swim() {
System.out.println("SmallDuck can swim ");
}
}

public class InterfaceDemo {
public static void main(String[] args) {
Goldfish goldfish=new Goldfish();
goldfish.swim();

SmallDuck smallDuck= new SmallDuck();
smallDuck.swim();
smallDuck.egg();
}
}

内部类

上一小节，我们学习了接口，在以后的工作中接口是我们经常要碰到的，所以一定要多去回顾。接下来 介绍一下内部类。很多时候我们创建类的对象的时候并不需要使用很多次，每次只使用一次，这个时候 我们就可以使用内部类了。
1、内部类概述
内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内 部类，而A类相对B类来说就是外部类了。
内部类不是在一个java源文件中编写俩个平行的俩个类,而是在一个类的内部再定义另外一个类。 我们可以把外边的类称为外部类,在其内部编写的类称为内部类。
内部类分为四种：
1.成员内部类
2.静态内部类
3.局部内部类
4.匿名内部类
2、成员内部类（实例内部类、非静态内部类）
注：成员内部类中不能写静态属性和方法
【定义一个内部类】

//在A类中申明了一个B类，此B类就在A的内部，并且在成员变量的位置上，所以就称为成员内部类
public class Outer {
private int id;
public void out(){
System.out.println("这是外部类方法");
}

class Inner{
public void in(){
System.out.println("这是内部类方法");
}
}
}

【实例化内部类】
实例化内部类，首先需要实例化外部类，通过外部类去调用内部类

public class Outer {
private int id;
public void out(){
System.out.println("这是外部类方法");
}

class Inner{
public void in(){
System.out.println("这是内部类方法");
}
}
}


public class Test{
public static void main(String[] args) {
//实例化成员内部类分两步
//1、实例化外部类
Outer outObject = new Outer();
//2、通过外部类调用内部类
Outer.Inner inObject = outObject.new Inner();
//测试，调用内部类中的方法
inObject.in();//打印：这是内部类方法
}}

分析：想想如果你要使用一个类中方法或者属性，你就必须要先有该类的一个对象，同理，一个类在另 一个类的内部，那么想要使用这个内部类，就必须先要有外部类的一个实例对象，然后在通过该对象去 使用内部类。
【成员内部类能干什么？】

1. 访问外部类的所有属性(这里的属性包括私有的成员变量，方法)

public class Outer {
private int id;
public void out(){
System.out.println("这是外部类方法");
}

class Inner{
public void in(){
System.out.println("这是内部类方法");
}

//内部类访问外部类私有的成员变量
public void useId(){
System.out.println(id+3);。
}

//内部类访问外部类的方法
public void useOut(){
out();
}
}
}

public class Test{
public static void main(String[] args) {
//实例化成员内部类分两步
//1、实例化外部类
Outer outObject = new Outer();
//2、通过外部类调用内部类
Outer.Inner inObject = outObject.new Inner();
//测试
inObject.useId();//打印3，因为id初始化值为0，0+3就为3，其中在内部类就使用了
外部类的私有成员变量id。
inObject.useOut();//打印：这是外部类方法
}
}`

1.如果内部类中的变量名和外部类的成员变量名一样，要通过创建外部类对象 "."属性来访问外部类属性，通过this.属性访问内部类成员属性

1public class Outer {
2private int id;//默认初始化0
3public void out(){
4System.out.println("这是外部类方法");
5	}

借助成员内部类，来总结内部类(包括4种内部类)的通用用法：
1、要想访问内部类中的内容，必须通过外部类对象来实例化内部类。
2、能够访问外部类所有的属性和方法，原理就是在通过外部类对象实例化内部类对象时，外部类对象 把自己的引用传进了内部类，使内部类可以用通过Outer.this去调用外部类的属性和方法，
一般都是隐式调用了，但是当内部类中有属性或者方法名和外部类中的属性或方法名相同的时候，就需 要通过显式调用Outer.this了。
【写的一个小例子】

public class MemberInnerClassTest {
private String name;
private static int age;

public void run(){}

public static void go(){}

public class MemberInnerClass{
private String name;

//内部类访问外部类
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(MemberInnerClassTest.this.name);
System.out.println(MemberInnerClassTest.age);
MemberInnerClassTest.this.run();
MemberInnerClassTest.go();
}
}
//外部类访问成员内部类
//成员内部类的对象要 依赖于外部类的对象的存在
public void test(){
//MemberInnerClass mic = MemberInnerClassTest.this.new
MemberInnerClass();
//MemberInnerClass mic = this.new MemberInnerClass();
MemberInnerClass mic = new MemberInnerClass();
mic.name = "tom";
mic.test("hua");

}

public static void main(String[] args) {
//MemberInnerClass mic = new MemberInnerClass();这个是不行的，this是动
态的。
//所以要使用要先创建外部类对象，才能使用
MemberInnerClassTest out = new MemberInnerClassTest();
MemberInnerClass mic = out.new MemberInnerClass();
//如果内部类是private,则不能访问，只能铜鼓内部方法来调用内部类
mic.name="jik";
mic.test("kkk");

}

}

3、静态内部类
看到名字就知道，使用你static修饰的内部类就叫静态内部类。
既然提到了static，那我们就来复习一下它的用法：一般只修饰变量和方法，平常不可以修饰类，但是内 部类却可以被static修饰。
1）static修饰成员变量：整个类的实例共享静态变量
2）static修饰方法：静态方法，只能够访问用static修饰的属性或方法，而非静态方法可以访问static修 饰的方法或属性
3）被static修饰了的成员变量和方法能直接被类名调用。
4）static不能修饰局部变量，切记，不要搞混淆了，static平常就用来修饰成员变量和方法。 写了一个例子，可以给大家看一下：

public class StaticInnerClassTest {
private String name;
private static int age;

public void run(){}

public static void go(){}

//外部类访问静态内部类
public void test(){
StaticInnerClass sic = new StaticInnerClass(); //静态的内部类不需要依赖
外部类，所以不用this
sic.name = "tom";
sic.test1("jack");

StaticInnerClass.age=10;
StaticInnerClass.test2("xixi");

}

private static class StaticInnerClass{
private String name;
private static int age;
public void test1(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(StaticInnerClass.age);

System.out.println(StaticInnerClassTest.age);
//System.out.println(StaticInnerClassTest.this.name);静态类不能访
问非静态属性

StaticInnerClassTest.go();
//StaticInnerClassTest.this.run();静态类不能访问非静态方法
}
public static void test2(String name){
//只能访问自己和外部类的静态属性和方法
System.out.println(name);
//System.out.println(this.name);静态方法里面连自己类的非静态属性都不能
访问
System.out.println(StaticInnerClass.age);

System.out.println(StaticInnerClassTest.age);
//System.out.println(StaticInnerClassTest.this.name);静态方法不能
访问非静态属性
StaticInnerClassTest.go();
//StaticInnerClassTest.this.run();静态方法不能访问非静态方法
}

}
}

注意：
1、我们上面说的内部类能够调用外部类的方法和属性，在静态内部类中就行了，因为静态内部类没有 了指向外部类对象的引用。除非外部类中的方法或者属性也是静态的。这就回归到了static关键字的用 法。
2、静态内部类能够直接被外部类给实例化，不需要使用外部类对象

Outer.Inner inner = new Outer.Inner();

3、静态内部类中可以声明静态方法和静态变量，但是非静态内部类中就不可以声明静态方法和静态变 量

4、局部内部类
局部内部类是在一个方法内部声明的一个类
局部内部类中可以访问外部类的成员变量及方法
局部内部类中如果要访问该内部类所在方法中的局部变量,那么这个局部变量就必须是final修饰的

public class Outer { private int id;
//在method01方法中有一个Inner内部类，这个内部类就称为局部内部类
public void method01(){class Inner{ public void in(){
System.out.println("这是局部内部类");
}
}
}

局部内部类一般的作用跟在成员内部类中总结的差不多，但是有两个要注意的地方：
1.在局部内部类中，如果要访问局部变量，那么该局部变量要用final修饰为什么需要使用final？
final修饰变量：变为常量，会在常量池中放着，逆向思维想这个问题，如果不实用final修饰，当局部内 部类被实例化后，方法弹栈，局部变量随着跟着消失，这个时候局部内部类对象在想去调用该局部变
量，就会报错，因为该局部变量已经没了，当局部变量用fanal修饰后，就会将其加入常量池中，即使方 法弹栈了，该局部变量还在常量池中呆着，局部内部类也就是够调用。所以局部内部类想要调用局部变 量时，需要使用final修饰，不使用，编译度通不过。

public class Outer {
private int id;
public void method01(){
final int cid = 3;	//这个就是局部变量cid。要让局部内部类使用，就得变为
final并且赋值，如果不使用final修饰，就会报错
class Inner{
//内部类的第一个方法
public void in(){
System.out.println("这是局部内部类");
}
//内部类中的使用局部变量cid的方法
public void useCid(){
System.out.println(cid);
}
}

}
}

1. 局部内部类不能通过外部类对象直接实例化，而是在方法中实例化出自己来，然后通过内部类对象调用自己类中的方法。看下面例子就知道如何用了。

public class Outer {
private int id;

public void out(){
System.out.println("外部类方法");
}
public void method01(){
class Inner{
public void in(){
System.out.println("这是局部内部类");
}
}
//关键在这里，如需要在method01方法中自己创建内部类实例，然后调用内部类中的方法，等待 外部类调用method01方法，就可以执行到内部类中的方法了。
		Inner In = new Inner();
		In.in();
	}	
}		

使用局部内部类需要注意的地方就刚才上面说的：
1、在局部内部类中，如果要访问局部变量，那么该局部变量要用final修饰
2、如何调用局部内部类方法。

public class LocalInnerClassTest {
private String name;
private static int age;

public void run(){}

public static void go(){}

//局部内部类要定义在方法中
public void test(){
final String myname="";
class LocalInnerClass{
private String name;
//	private static int age;不能定义静态属性

public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(myname);
System.out.println(LocalInnerClassTest.this.name);

LocalInnerClassTest.this.run();
LocalInnerClassTest.go();
}
}
//局部内部类只能在自己的方法中用,因为局部内部类相当于一个局部变量，除了方法就找不
到了。
LocalInnerClass lic = new LocalInnerClass();
lic.name="tom";
lic.test("test");
}

}

5、匿名内部类
在这四种内部类中，以后的工作可能遇到最多的是匿名内部类，所以说匿名内部类是最常用的一种 内部类。
什么是匿名对象？如果一个对象只要使用一次，那么我们就是需要new Object().method()。 就可以了，而不需要给这个实例保存到该类型变量中去。这就是匿名对象。

public class Test {
public static void main(String[] args) {
//讲new出来的Apple实例赋给apple变量保存起来，但是我们只需要用一次，就可以这样写Apple apple = new Apple();
apple.eat();
//这种就叫做匿名对象的使用，不把实例保存到变量中。new Apple().eat();
}
}
class Apple{
public void eat(){ System.out.println("我要被吃了");
}

匿名内部类跟匿名对象是一个道理：
匿名对象：我只需要用一次，那么我就不用声明一个该类型变量来保存对象了，
匿名内部类：我也只需要用一次，那我就不需要在类中先定义一个内部类，而是等待需要用的时候，我 就在临时实现这个内部类，因为用次数少，可能就这一次，那么这样写内部类，更方便。不然先写出一 个内部类的全部实现来，然后就调用它一次，岂不是用完之后就一直将其放在那，那就没必要那样。
1.匿名内部类需要依托于其他类或者接口来创建
如果依托的是类,那么创建出来的匿名内部类就默认是这个类的子类
如果依托的是接口,那么创建出来的匿名内部类就默认是这个接口的实现类。
2.匿名内部类的声明必须是在使用new关键字的时候
匿名内部类的声明及创建对象必须一气呵成,并且之后能反复使用,因为没有名字。
【示例】
A是一个类(普通类、抽象类都可以)，依托于A类创建一个匿名内部类对象

main:

A a = new A(){
//实现A中的抽象方法
//或者重写A中的普通方法
};
注:这个大括号里面其实就是这个内部类的代码,只不过是声明该内部类的同时就是要new创建了其对象,
并且不能反复使用,因为没有名字。

例如:
B是一个接口，依托于B接口创建一个匿名内部类对象

B b = new B(){
//实现B中的抽象方法
};

1.匿名内部类除了依托的类或接口之外,不能指定继承或者实现其他类或接口,同时也不能被其他类所 继承,因为没有名字。
2.匿名内部中,我们不能写出其构造器,因为没有名字。
匿名内部中,除了重写上面的方法外,一般不会再写其他独有的方法,因为从外部不能直接调用到。(间接是调用到的）

public interface Work{
void doWork();
}
public class AnonymousOutterClass{
private String name;
private static int age;
public void say(){}
public static void go(){}

public void test(){
final int i = 90;

Work w = new Work(){
public void doWork(){
System.out.println(AnonymousOutterClass.this.name);
System.out.println(AnonymousOutterClass.age);
AnonymousOutterClass.this.say();
AnonymousOutterClass.go();

System.out.println(i);
}
};
w.doWork();
}
}

我们可以试一下不用匿名内部类和用匿名内部类实现一个接口中的方法的区别
【不用匿名内部类】

public class Test {
public static void main(String[] args) {
//如果我们需要使用接口中的方法，我们就需要走3步，1、实现接口   2、创建实现接口类的实
例对象 3、通过对象调用方法
//第二步
Test02 test = new Test02();
//第三步
test.method();
}
}

//接口Test1
interface Test01{
public void method();
}
//第一步、实现Test01接口
class Test02 implements Test01{

@Override
public void method() {
System.out.println("实现了Test接口的方法");
}

}

【使用匿名内部类】

public class Test {
public static void main(String[] args) {
//如果我们需要使用接口中的方法，我们只需要走一步，就是使用匿名内部类，直接将其
类的对象创建出来。
new Test1(){
public void method(){
System.out.println("实现了Test接口的方法");
}
}.method();

}
}

interface Test1{
public void method();
}

解析：其实只要明白一点，new Test1(){实现接口中方法的代码}; Test1(){…}这个的作用就是将接口给实现了，只不过这里实现该接口的是一个匿名类，也就是说这个类没名字，
只能使用这一次，我们知道了这是一个类， 将其new出来，就能获得一个实现了Test1接口的类的实例对象，通过该实例对象，就能调用该类中的方法了，因为其匿名类是在一个类中实现的，
所以叫其匿名内部类，不要纠结为什么Test1(){…}就相当于实现了Test1接口，这其中的原理等足够强大 了，在去学习，不要钻牛角尖，这里就仅仅是需要知道他的作用是什么，做了些什么东西就行。

原文链接:https://blog.csdn.net/weixin_41937552/article/details/117675856