java基础（笔记）

一. java语言概述

1.1 常用DOS命令

（1）del删除相同后缀文件 例：del *.txt

（2）删除**文件目录**用rd（保证文件夹中无文件），不是del

（3）删除目录下的全部文件，可采取del： 文件名（目录下不再嵌套其他文件目录）

1.2 Java语言特点：

jave语言运行核心机制—内存回收（自动收回无用内存，c++并不能）

但Java还是会出现内存泄漏和溢出问题；

1.3 Java语言环境搭建

（1）什么是JDK，什么是JRE；

（2）JDK,JRE,JVM三者关系

1.4 第一个java程序

1.Java文件扩展名：.java

2.过程

编译中先cd进入文件中，然后javac后输入要编译的**文件名及后缀**

回车后出现.class文件（字节码文件），文件名则是原文件中的类名

后cmd中java后输入字节码文件文件名，后缀省略

程序一旦运行错误，需要重新编译，即javac…

java严格区分大小写

第一个程序！！！！！

1.5 java三种注释方式

(1) //：单行注释（解释说明）

(2) /* */：多行注释

（3） 文档注释（Java特有）

​ 使用方法：javadoc -d 起一个文件夹名字 -author -version java文件名

1.6 总结

（1） 步骤

java程序步骤：编写——编译——运行

编写：将编写的Java代码保存在以".java"结尾的源文件中

编译：使用javac.exe命令编译java源文件。格式：javac 源文件名.java

有几个类，编译下来就有几个字形码文件。

运行：使用java命令解释运行字节码文件（.class文件）。格式：java 类名（不用后缀）

（2） public

在一个java源文件中可以声明多个class，但只有一个类声明为public。

要求public声明的类名跟源文件名相同

（3）程序入口

程序入口是main( )方法，格式固定

格式：public static void main(String[] args)

（4）输出语句

System.out.println( " ")；:先输出，然后自动换行

System.out.print( " ")；只输出

System.out.println( )可作为换行符使用。

每个执行语句后面都要加分号。

二.基本语法

1 关键字和保留字

（1）关键字

（1）定义：被java赋予特殊含义，有专门的用途的词

（2）特点：关键字的所有字母均为小写

（2）保留字

定义：现有的Java版本尚未使用，以后可能会作为关键字使用，自己命名时要避免使用

例：goto const

2 标识符

（1）定义：

凡是自己可以起名字的都叫标识符

例：类名，变量名，方法名，接口名…

规则：

1.数字不可以开头

2.由26个字母，0-9，_，$构成（汉字也可以，但不建议）

3.严格区分大小写，但长度无限制

4.标识符不能包含空格

5.不能使用关键字和保留字，但能包含关键字和保留字

（2）命名规范

包名：多单词组成时所有字母小写；（xxxyyyzzz）

类名，接口名：多单词组成时，首字母大写（XxxYyyZzz）

变量名，方法名：多单词组成时第一个单词首字母小写，第二个单词开始每个单词首字母大写（xxxYyyZzz）

常量名：所有字母都大写。多单词时每个字母用下划线连接：XXX_YYY_ZZZ

如上如不遵守，编译也可以通过，建议严格遵守

3 变量

变量分为：基本数据类型，引用数据类型

（1）基本数据类型

①整型

②浮点型

声明long型变量，变量值要以“L”或“l”结尾

java中浮点型常量默认为double型，声明float型，需要在后面加上“f”或“F”

float（4字节） double（8字节）

float精确到7位

定义浮点型变量时，通常使用double

③字符型

char：一个字符=2字节

表示方式：

内部只能有一个字符；

包括转义字符；

直接使用Unicode值表示字符型常量；

定义格式：char c1=‘a’;

④布尔型：boolean

只有两个值：true false

常常在条件判断和循环条件中使用

例：

(2) 引用数据类型

①字符串型

String不是基本数据类型,而是引用数据类型

String使用：声明string类型时，要是用一对" ",翻译为字符串。

string可以和八种基本数据类型变量做运算，且运算只能是连接运算：+

（3）进制转换

①二进制：

以0b或0B开头

②八进制：

以数字0开头

③十进制：

0-9

④十六进制：

以数字0x或0X开头表示，此处的A-F不区分大小写·

4 运算符

(1) 算数运算符：

• • / * ++ – %

%：结果的符号与被膜数的符号相同

（2）赋值运算符：

= += -= *= /= %=（不会改变本身数据类型）

（3）比较运算符：

== != > < >= <=（结果要么是true，要么是false）

（4）逻辑运算符：

逻辑与和短路与的区别：

逻辑与的判断方式是：

从左到右依次判断，直到结尾（逻辑全程运算）

短路与的判断方式是:

从左到右依次判断，直到出现false为止将不再判断，直接得到结果为false（短路遇false就停）

逻辑或和短路或的区别：

逻辑或的判断方式是：

从左到右依次判断，直到结尾

短路或的判断方式是:

从左到右依次判断，直到出现true为止将不再判断，直接得到结果为true

（5）位运算符：

位运算是直接对整数的二进制进行的运算,相当于二进制左移右移

（6）三元运算符

格式：（条件表达式）？表达式1：表达式2；

条件表达式为true 运行表达式1，为false运行表达式2

运算结果类型取决于表达式1或表达式2的结果类型

三元运算符可以嵌套使用

三元运算符都可以改成if ~else 格式

5 程序流程控制

三种基本流程结构：

（1）顺序结构：

从上到下顺序执行，中间没有任何判断和跳转

（2）分支结构：

​ ①有if_{else，switch}case两种语句结构

​ Switch结构中的表达式，只能是下面6中数据类型之一：

​ byte，short，char，int，枚举类型，string类型

​ ②根据条件，选择性的执行某段代码

（3）循环结构：

​ ①根据循环条件，重复执行某段代码

​ ②有while do~while for三种循环语句

6.使用Scanner

具体步骤：

1.导包：import java.util.Scanner;

2.Scanner的实例化：Scanner 变量名=new Scanner（System in）从键盘输入数据

3.调用Scanner的类的相关方法，来获取指定类的变量

4.各种数据类型的使用方法：

5.char型和String通用，scanner没有提供char型相关方法

7.产生随机数

方法1：

步骤：导包——创建对象——随机生成一个数据——输出

导包：import java.util.Random;

创建对象：Randem r=new Random( )；

随机生成一个数据：num=r.nextInt( 10);//表示0~10.不包括10；

方法2：

公式：例如输出[10,99]

(int)(Math.random( )*(99-10+1)+10)

​ (b-a+1)+a

三.数组

1.一维数组的声明和初始化

例：

静态初始化：

int[] a=new int[]{…};

动态初始化：

String[] a=new String[];

2.数组元素的默认初始化值

1.整型数组：0

2.浮点型数组：0.0

3.char型数组：ASCII码的0

4.Boolean型数组：false

5.引用数据类型数组：null

3.查找

（1）线性查找

1.int型：if(a==b)

2.字符型：if(a.equals(b))

（2）二分法查找

1.首先查找的数组要有序

4.排序

（1）冒泡法：

（2）快速排序法：

5.数组工具

1.java. util.Arrays:操作数组的工具类。

例：boolean x=Array.equals(arr1,arr2)

输出数组信息：

四.面向对象（上）

（1）类和对象

1.创建类

属性=成员变量

方法=成员方法=函数

如果创建了一个类的多个对象，则每个对象都独立拥有一套各自的属性。（非static的）

匿名对象的使用：

1.创建的对象没有赋给一个变量名

2.匿名对象只能使用一次。

（2）方法的声明

方法的声明：权限修饰符 返回值类型 方法名（形参列表）

{ 方法体 }

1.权限修饰符：private public（最大） 缺省 protected

2.返回值类型：有返回值 无返回值

（1）有返回值：如果方法有返回值，必须在方法声明时，指定返回值的类型。

同时需要return关键字来返回指定类型的数据

（2）无返回值：声明方法时用void来表示，无需return，如果使用，直接“return；”

return后不可以声明表达式

3.方法名要见名知意

4.形参列表：方法可以声明0个，1个或多个形参

格式：数据类型1 形参1，数据类型2 形参2，…

5.方法体：方法功能的体现

（3）方法的使用

1.方法的使用中可以调用当前类的属性或方法

特殊的：方法A中又调用方法A（递归）

2.方法中不可以定义方法。

（4）方法再论

1.方法的重载：

定义：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或参数类型不同即可

判断方法：跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系

2.可变个数形参

可变个数形参的格式：数据类型 … 变量名

传入的参数可以是0个，1个，多个

可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载

可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载

可变个数形参在方法的性参中，必须声明在末尾

可变个数形参在方法的性参中，最多只能声明一个形参

（5）变量

变量的赋值：

1.如果变量是基本数据类型，此时赋值的是变量所保存的数据值

2.如果变量是引用数据类型，此时赋值的是变量所保存的地址值

（6）递归

1.递归：一个方法体内调用自己

（7）特征之一：封装与隐藏

（1）问题的引入

（2）封装性的体现

将类的属性私有化（private），同时提供公共的（public）方法来获取（getXxx）和设置（setXxx）此属性的值

1.get和set用法

2.封装性的体现需要权限修饰符配合

四种权限修饰符（从小到大排列）：private、缺省、protected、public

四种都可以来修饰类的内部结构：属性，方法，构造器，内部类

修饰类只能使用缺省或public

（8）类的成员：构造器

1.构造器的作用：

（1）造对象 Person p1=new Person()(构造器)

（2）初始化对象的属性

2.构造器说明:

（1）如果没有显式定义类的构造器，则默认提供一个空参的构造器（如上）

（2）定义构造器的格式：权限修饰符 类名（形参列表）{}

（3）一个类中定义的多个构造器构成重载

（4）一旦显式定义了类的构造器之后，系统就不在提供默认的空参构造器了。

（5）一个类中至少要有一个构造器

（9）关键字：this

1.this可以用来修饰：属性、方法、构造器

2.this修饰属性和方法：

​ this理解为当前对象。

3.this调用构造器

（1）不能通过this（形参列表）调用自己

（2）this（形参列表）必须声明在构造器的首行

（3）构造器内部最多只能声明一个this（形参列表），用来调用其他构造器

（10）关键字：package

1.为了更好的实现项目中类的管理，提供包的概念

2.使用package声明类和接口所属的包，声明在源文件的首行

3.包属于标识符，遵循标识符的命名规则，规范（xxxyyyzzz），见名知意

4.每点一次，就代表一层文件目录

5.同一个包下，不能定义重名的类和接口，不同包下可以使用

（11）关键字：import

1.import：导入

2.在源文件中显式的使用import结构导入指定包下的类、接口

3.声明在包的声明和类的声明之间

4.如果需要导入多个结构，则并列写出即可

5.可以使用“xxx.*”的方式，表示可以导入xxx包下的所有结构

6.如果使用的类或接口是java.lang包下定义的，可以省略import结构

7.如果使用的类或接口是本包下定义的，则可以省略import结构

8.如果在源文件中，使用了不同包下同名的类，则必须至少有一个类需要以全类名的方式显示

9.使用“xxx.*”方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，仍需要显式导入

10.inport static：导入指定类或接口中的静态结构。

（12）属性可以赋值的位置

显式初始化和在代码块中赋值，主要看代码的位置。

（13）匿名对象

五.面向对象（中）

（1）特征之二：继承性

1.继承性的好处：

①：减少代码冗余，提高代码的复用性

②：便于功能的扩展

③：为之后的多态性的使用，提供了前提

2.继承性的格式：

class A extends B{}

A:子类、派生类、subclass

B“父类、超类、基类、superclass

3.继承性的体现：

一旦子类A继承父类B，子类A中就获取了父类B中声明的所有的属性、方法

特别的：父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构

只是因为封装性的影响，使得子类不能直接调用父类的结构而已。

子类继承父类以后，还可以声明自己特有的属性和方法，实现功能的扩展。

4.java中继承性的规定：

①：一个类可以被多个子类继承

②：Java中类的单继承性：一个类只能有一个父类

5.Object：

①：如果我们没有显式的声明的一个类的父类的话，则此类继承于java.lang.object类

②：所有java类除（java.lang.object）都直接或间接继承于java.lang.object类

（2）方法的重写

1.返回值类型：

①：父类重写的方法返回值类型为void，则子类重写的返回值类型只能是void

②：父类重写的方法返回值类型为A型，则子类重写的返回值可以是A类或A的子类

③：父类重写的方法返回值类型为基本数据类型，则子类方法的返回值类型必须是相同的基本数据类型

2.子类方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

（3）关键字：super

1.super关键字的使用：

①：super理解为：父类的

②：super可以用来调用：属性、方法、构造器

2.super的使用：

我们可以在子类的方法或构造器中，通过使用“super.方法”或“super.属性”，显式的调用父类中声明的属性或方法。但是，通常情况下，我们省略“super.”

（同名的方法类似）同下

特殊情况：当子类和父类中定义了同名的属性时，我们想要在子类中调用父类中声明的属性，则必须显式的使用“super.属性”的方式表明是父类中声明的属性。（想要父类中的属性，而不要子类中重写的属性）

3.super调用构造器：

①：我们可以在子类的构造器中显式的使用“super(形参列表)”的方式。调用父类中指定的构造器

②：“super(形参列表)”的使用，必须声明在子类构造器的首行！

③：在类的构造器中，针对于“this(形参列表)”或“super(形参列表)”只能二选一，不能同时出现

④：在构造器的首行，没有显式的声明“this(形参列表)”或“super(形参列表)”，则默认调用父类中空参的构造器“super(空)”

⑤：在类的多个构造器中，至少有一个类的构造器中使用了“super（形参列表）”，调用父类中的构造器

（4）子类对象的实例化过程

（5）特征之三：多态性

多态性的理解：可以理解为一个事物的多种形态

何为多态性：

对象的多态性：父类的引用指向子类的对象

多态性的使用：有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，在运行期，我们实际执行的是子类重写后的方法（编译看左边，执行看右边）

多态性的使用前提：

①：有类的继承关系

②：子类中要有方法的重写

对象的多态性只适用于方法，不适用于属性

（6）instanceof关键字

有了对象的多态性以后，内存中实际上加载了子类所特有的属性和方法，但是由于变量声明为父类类型，导
致编译时，只能调用父类中所声明的属性和方法。子类所特有的属性和方法无法调用

如何才能调用子类所特有的属性和方法：使用强制类型转换符（向下转型）Man m1=(Man)p2

使用强转时可能会出现ClassCastException的异常

instanceof的使用：A：判断a是否是类A的实例。是，返回true，不是返回false。

instanceof使用情景：为了避免在向下转型时避免出现ClassCastException的异常，所以在转型之前，先进行instanceof判断，一旦返回true，就向下进行转型，返回false，不转型

（7）== 运算符

==：运算符

1.可以使用在基本数据类型变量和引用数据类型变量

2.如果比较的是基本数据类型结构，比较两个变量保存的数据是否相等。（不一定类型相同）

3.如果比较的是引用数据类型变量，比较两个对象的地址值是否相同。即两个引用是否指向同一个对象实体

（8）equals()方法的使用

1.是一个方法，而非运算符

2.只能适用于引用数据类型

3.object中定义的equals()和==的作用是相同的：即比较两个对象的地址值是否相同。即两个引用是否指向同一个对象实体

4.像String、Date、File、包装类等都重写了object类中的equals（）方法。重写以后比较的不是两个引用的地址是否相同，而是比较两个对象的“实体内容”是否相同

5.通常情况下，我们自定义的类如果使用equals()的话，通常也是比较两个对象的“实体内容”是否相同，那么我们就需要对object中的equals类进行重写

（9）toStrin()方法的使用

1.像String、Date、File、包装类等都重写了object类中的toStrin()方法。使得在调用对象的的toString（）时，返回实体内容。

2.自定义类也可以重写toStrin()方法，当调用此方法，返回对象的实体内容。

（10）包装类

1.java提供了8种基本数据类型的包装类，使得基本数据类型的变量具有类的特征

2.基本数据类型，包装类，String类型的转换

①：基本数据类型---->包装类：调用包装类的构造器

②：包装类---->基本数据类型：调用包装类的xxxValue（）

③基本数据类型，包装类---->String类型

④：String类型---->基本数据类型，包装类

调用包装类的parseXxx()：

3.自动装箱：

4.自动拆箱：

六.面向对象（下）

（1）static关键字

1.static：静态的

2.static可以用来修饰：属性、方法、代码块、内部类

​ （1）：static修饰属性：静态变量（类变量）

​ 属性按是否使用static修饰，又分为静态属性和非静态属性（实例变量）

​ 实例变量：我们创建了类的多个对象，每个对象都拥有一套独立的非静态属性。当修改其中一个对象的 非静态属性时，不会影响其他对象中属性值的修改

​ 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变 量，会导致其他对象调用此静态变量时，是已经修改过的

​ （2）：关于属性的其他说明：

​ ①：静态变量随着类的加载而加载（可以通过“类.静态变量”的方法进行调用）

​ ②：静态变量的加载早于对象的创建

​ ③：由于类只会加载一次，则静态变量在内存中也只会存在一份：存在于方法区的静态域中

3：static来修饰方法：静态方法

​ ①：静态变量随着类的加载而加载（可以通过“类.静态方法”的方法进行调用）

​ ②：静态方法中，只能调用静态的方法或属性

​ 非静态方法中，既可以调用静态的方法和属性，也可以调用非静态的方法和属性

​ 4.static使用注意点：

​ 在静态的方法中，不能使用this关键字和super关键字

​ 5.开发中，如何确定一个属性是否要声明成为static。

​ 属性是可以被多个对象所共享的，不会随着对象的不同而不同。

​ 6.开发中，如何确定一个方法是否要声明成为static。

​ ①:操作静态属性的方法，通常设置为static

​ ②:工具类中的方法通常声明为static,比如Math，Arrays，Collections

​ ③：类中的常量也常常声明为static

（2）单例设计模式

​ ①：饿汉式：

​ ②：懒汉式：

​ 区分：

​ 饿汉式：坏处：对象加载时间过长

​ 好处：线程安全

​ 懒汉式：好处：延迟对象的创建

​ 坏处：线程不安全。——>到多线程内容时在修改

（3）理解main方法的语法

​ 1.main()方法作为程序的入口

​ 2.mian(形参)，形参中的数组可以直接赋值使用

（4）类的成员：代码块

​ 1.作用：用来初始化 类，对象

​ 2.代码块如果有修饰，只能使用static（即静态代码块）

​ （1）：静态代码块：

​ ①：内部可以有语句

​ ②：随着类的加载而执行，而且只执行一次

​ ③：作用：初始化静态类的信息

​ ④：如果一个类中定义了多个代码块，则按照声明先后顺序的执行

​ ⑤：静态代码块的执行要优先于非静态代码块的执行

​ ⑥：静态代码块中只能调用静态的属性和方法

​ （2）：非静态代码块：

​ ①：内部可以有语句

​ ②：随着对象的创建而执行

​ ③：每创建一个对象，就执行一次非静态代码块

​ ④：作用：可以在创建对象时，对对象的属性进行初始化

​ ⑤：非静态代码块中，可以调用非静态的属性和方法，也可以调用静态的属性和方法

（5）关键字：final

​ 1.final：最终的

​ 2.final可以修饰的结构：类、方法、变量

​ （1）修饰类：代表此类不能被其他类继承（比如：String类，System类，StringBuffer类）

​ （2）修饰方法：表明此方法不可以被重写（比如：Object类中的getClass）

​ （3）修饰变量：此时的“变量”称为常量

​ ①：final修饰属性：可以考虑的位置有显式初始化、代码块中赋值、构造器中初始化

​ ②：final修饰局部变量：尤其是使用final修饰形参时，表明形参是一个常量，所以不能在方 法体中重新修改形参变量的值，只能在方法体中使用该形参

​ ③：static final：全局常量

（6）抽象类与抽象方法

1.abstract关键字的使用：

​ （1）abstract：抽象的

​ （2）可以用来修饰的结构：类、方法

​ 修饰类：

​ ①：此类不能实例化

​ ②：抽象类中一定有构造器，便于子类对象实例化的调用（子类对象实例化的全过程）

​ ③：开发中，都会提供抽象类的子类，让子类对象实例化，完成相关操作

​ 修饰方法：

​ ①：抽象方法：只有方法的声明，没有方法体，后面加分号

​ ②：包含抽象方法的类一定是抽象类；反之抽象类中可以没有抽象方法

​ ③：若子类重写了父类中的所有的抽象方法，此子类方可实例化
​ 若子类没有重写父类中的抽象方法，则此子类也要是一个抽象类，用abstract修饰

​ （3）abstract注意点：

​ ①：abstract不能用来修饰：属性，构造器等结构

​ ②：abstract不能由来修饰私有方法、静态方法、final的方法、final的类

（7）抽象类的匿名子类：

在匿名子类中重写父类的方法

3.创建匿名子类的匿名对象

（8）接口（interface）

1.使用interface来定义

2.在Java中接口和类是并列的两个结构

3.如何定义接口：定义接口中的成员

​ ①：jdk7及以前：只能定义全局常量和抽象方法
​ 全局常量：public static final（格式）（但是书写时可以省略）

​ 抽象方法：public abstract（格式)（书写时可以省略）

​ ②：jdk8：除了定义了全局常量和抽象方法外，还可以定义静态方法、默认方法

4.接口不能定义构造器，意味着接口不可以实例化

5.java开发中，通过让类去实现（implements）的方式来使用
如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
如果实现类没有覆盖接口中所有的抽象方法,则此实现类仍为一个抽象类

​ 接口无法造对象，只能通过实现类去造对象（多态性）
​
6.java可以实现多接口–>弥补了java单继承性的局限性
格式：class AA extend BB implement CC，DD

7.接口与接口之间可以继承，而且可以多继承

（9）接口创建方法（4种）

①：接口中定义的静态方法只能通过接口来调用

②：如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的默认方法，
那么子类在没有重写的情况下，默认调用的是父类中的同名同参数方法———>类优先原则

③：如果实现类实现了多个接口，而这些多个接口中都定义了同名同参数的默认方法
那么在实现类没有重写此方法的情况下，报错。———>接口冲突
这就需要我们必须在实现类中重写此方法

④：调用接口中原来的方法，格式：接口.super.方法名

（10）类的成员：内部类

1.java中允许将一个类A声明在另一个类B中，则类A叫作内部类，类B称为外部类

2.内部类的分类：成员内部类（静态，非静态） vs 局部内部类（方法内，代码块内，构造器内）

3.成员内部类：

①：作为一个类：
>类内可以定义属性，方法，构造器
>可以被final修饰，表示此类不能被继承。反之可以被继承
>可以被abstract修饰，表示不能被实例化

②：作为外部类的成员：
>调用外部类的结构
>可以被static修饰
>可以被4种不同的权限修饰符修饰

4.如何实例化成员内部类的对象：

5.如何在成员内部类中区分调用外部类的结构

public class InnerClassTest {
    public static void main(String[] args){
        //创建Dog的实例(静态的成员内部类)
        Person.Dog dog=new Person.Dog();
        dog.show();
        //创建Bird的实例(非静态的成员内部类)
        Person p=new Person();
        //通过对象去调用内里面的结构
        Person.Bird bird=p.new Bird();
        bird.sing();
        bird.display("啄木鸟");
    }

}

class Person{
    String name="小明";
    int age;

    public void eat(){
        System.out.println("人：吃饭");
    }

    //静态成员内部类
    static class Dog{

        //属性
        String name;
        int age;
        //方法
        public void show(){
            System.out.println("卡拉是条狗");
            //静态内部只能调用静态
            //eat();
        }
        //构造器
//        public Dog(String name, int age) {
//            this.name = name;
//            this.age = age;
//        }
    }
    //非静态成员内部类
    class Bird{
        String name="杜鹃";

        public  void sing(){
            System.out.println("叽叽喳喳");
            //Person.this.可省略
            Person.this.eat();
        }

        public void display(String name){
            //属性重名时写法：
            System.out.println(name);//调用形参name(啄木鸟)
            System.out.println(this.name);//调用Bird类中的name(杜鹃)
            System.out.println(Person.this.name);//调用Person中的name(小明)
        }

    }

    public void method(){
        //局部内部类
        class AA{

        }
    }

6.开发中局部内部类的使用：（常用用法）