一、内部类
1、引入
类的成员包括：
(1)属性：成员变量；
(2)方法：成员方法；
(3)构造器；
(4)代码块；
(5)内部类；
其中1、2是代表这类事物的特征；
其中3、4是初始化类和对象用的；
其中5是协助完成2的功能的实现，表现；
2、内部类
当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。
在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。
Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。
Inner class的名字不能与包含它的外部类类名相同；
3、分类
根据内部类的所在的位置不同：
(1)成员内部类：(static成员内部类和非static成员内部类)外部类中方法外；
(2)局部内部类：匿名内部类，方法体内(也可以在代码块内)
4、
二、成员内部类
1、概述及分类
成员内部类：定义在 类中方法外 的类。
(1)有 static 修饰的：静态成员内部类，简称 静态内部类；
(2)没有 static 修饰的：非静态成员内部类，简称 成员内部类；
思考：什么情况下会用到成员内部类(方法外声明的？)
当描述一个事物时，发现它的内部还有一个完整的结构需要用一个类来描述；
并且发现这内部的结构，如果独立存在是没有意义的，必须在这个外部类中才有意义。而且这个内部结构只为这个外部类服务。
例如：Body身体，发现它内部还有完整的结果，如：心脏，发现心脏单独创建对象没有意义，只有在 Body 对象中才有意义，而且只为 Body 对象服务。
2、成员内部类的特点
(1)成员内部类作为类的成员的角色：
① 和外部类不同，Inner class 还可以声明为 private或 protected；
② 可以调用外部类的结构；
③ Inner class 可以声明为 static的，但此时就不能再使用外层类的非static 的成员变量；
(2)成员内部类作为类的角色：
① 成员内部类，可以出现原本类中能够定义的所有的成员：
属性：可以有静态属性和非静态属性；
方法：可以有静态方法和非静态方法，如果静态内部类是抽象类，还可定义抽象方法；
构造方法：有参方法、无参方法；
代码块：可以有静态代码块和非静态代码块；
内部类：允许，但很少再写内部类(臃肿)
② 可以声明为 abstract 类，因此可以被其他的内部类继承；
③ 可以声明为 final 类；
④ 编译以后生成 OuterClass$InnerClass.class 字节码文件(也适用于局部内部类)
(3)注意
① 非 static 的成员内部类中的成员不能声明为 static 的，只有在外部类或 static 的成员内部类才可声明 static 成员；
② 外部类访问成员内部类的成员，需要“内部类.成员” 或 “内部类对象.成员” 的方式；
③ 成员内部类可以直接使用外部类的所有成员，包括私有的数据；
④ 当想要在外部类的静态成员部分使用内部类时， 可以考虑内部类声明为静态的；
2、静态成员内部类(静态内部类)
(1)语法格式
【修饰符】 class 外部类 【 extends 父类】 【implements 父接口们】{
【其他修饰符】 static class 内部类 【 extends 父类】 【implements 父接口们】{
}
}
注意：
① 只有成员内部类才能用 static 修饰，其他的外部类，局部内部类等够不可以用 static 修饰。
② 外部类，内部类的父类，父接口都没有关系，各是各自的。
(2)特点
① 静态内部类中不能使用外部类的非静态的成员；
② 在外部类中，使用静态内部类，和使用其他的类一样的原则；
如果使用静态内部类的静态成员，直接“静态内部类名.”
如果使用静态内部类的非静态成员，直接“静态内部类对象名.”
③ 在外部类的外面，使用静态内部类：
如果使用静态内部类的静态成员，直接“类名”；
使用 外部类名.静态内部类名.静态方法；
使用 import 包.外部类名.静态内部类名； 然后在代码中使用“静态内部类名”
④ 静态内部类不会随着外部类的初始化一起初始化，而是要在使用到这个静态内部类才会初始化；
(3)小节
① 同级的来说静态的不能直接使用非静态的；
② 访问一个类的静态成员，用 “类名.” 即可；访问一个类的非静态成员，用“对象名.”即可；
③ 当使用到这个类时，这个类才会进行初始化；
(4)Demo：
1 packagecom.java.test;2 //import com.java.test.Outer.Inner;
3
4 public classTestStaticInner {5 public static voidmain(String[] args) {6 //访问内部类的静态方法
7 //Inner.test();//上面有导包语句，import 包.外部类名.静态内部类名;
8
9 Outer.Inner.test();//外部类名.静态内部类名.静态方法(不使用导包语句)
10
11 //访问内部类的非静态方法
12 //Inner in = new Inner();//上面有导包语句，import 包.外部类名.静态内部类名;
13 Outer.Inner in = newOuter.Inner();14in.method();15
16 Outer out = new Outer(); //内部类不会初始化
17 out.outMethod(); //该方法中用到内部类，内部类会进行初始化
18}19}20 classOuter{21 private int i = 1;22 private static int j = 2;23
24 static{25 System.out.println("外部类的静态代码块");26}27
28 static classInner{29 static{30 System.out.println("静态内部类的代码块");31}32
33 public voidmethod(){34 System.out.println("静态内部类的非静态方法");35 //System.out.println(i);//错误，不能访问非静态的
36System.out.println(j);37}38
39 public static voidtest(){40 System.out.println("静态内部类的静态方法");41}42}43 //外部类访问内部类
44 public voidoutMethod(){45 Inner in = newInner();46 in.method();//非静态方法，用对象名.访问
47
48 Inner.test();//静态方法，用类名.访问
49}50 }
(5)
3、成员内部类(非静态内部类)
(1)语法格式
【修饰符】 class 外部类 【 extends 父类】 【implements 父接口们】{
【其他修饰符】 class 内部类 【 extends 父类】 【implements 父接口们】{
}
}
(2)特点
① 在非静态内部类中，不能出现任何和 static 有关的声明；
② 在非静态内部类中，可以随意访问外部类的所有的成员，包括静态的和非静态的；
③ 在外部类的静态成员中，不能使用非静态的成员内部类；
④ 在外部类的外面使用
第一步：先创建外部类的对象
第二步：要么通过外部类的对象，去创建内部类的对象
Outer out = new Outer();
Outer.Inner in = out.new Inner();
要么通过外部类的对象，去获取内部类的对象
Outer out = new Outer();
Outer.Inner in = out.getInner();
(3)Demo
1 public classTestNonStaticInner {2 public static voidmain(String[] args) {3 //Outer.Inner in = new Outer.Inner();//错误的
4
5 //在这里使用Inner,因为此时的Inner是Outer的非静态成员，所以需要用到Outer的对象
6 Outer out = newOuter();7 //Outer.Inner in = out.new Inner();
8 Outer.Inner in =out.getInner();9in.method();10}11}12 classOuter{13 private int i = 1;14 private static int j = 2;15
16 classInner{17 public voidmethod(){18 System.out.println("非静态内部类的非静态方法");19System.out.println(i);20System.out.println(j);21}22}23
24 public static voidoutTest(){25 //Inner in = new Inner();//静态的方法不能访问非静态的成员
26}27 public voidoutMethod(){28 Inner in = newInner();29in.method();30}31
32 publicInner getInner(){33 return newInner();34}35 }
(4)练习案例：创建一个外部类，里面有一个抽象内部类，并有一个抽象方法，要求写一个类去继承该内部类；
代码：
1 public classTest {2 public static voidmain(String[] args) {3 MySub my = new MySub(newOuter());4my.test();5}6}7 classOuter{8 abstract classInner{9 public abstract voidtest();10}11}12 class MySub extendsOuter.Inner{13MySub(Outer out){14 out.super();//需要外部类的对象，才能调用非静态内部类的构造器
15}16
17@Override18 public voidtest() {19 System.out.println("hello");20}21 }
(5)小节
① 使用非静态内部类名时，可以使用：import 包.外部类名.内部类名； 或 外部类名.内部类名；
② 要调用非静态内部类的构造器，需要用到外部类的对象；
③ 因为子类的构造器的首行一定要调用父类的构造器，默认调用父类的无参构造(需要借助外部类对象)；
④ 继承抽象内部类，要重写抽象类的抽象方法；
注意：内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的 .class 文件，但是前面冠以外部类的类名和 $ 符号。如：Person$Heart.class
三、局部内部类
1、概述
局部内部类：定义在类中方法中(方法内、代码块内、构造器内)的类，就是局部内部类。
即只有当前所属的方法才能使用它，出了这个方法外面就不能使用了。
2、分类
(1)有名字的局部内部类：简称局部内部类；
(2)没名字的局部内部类：简称 匿名内部类。
3、语法格式
局部内部类定义格式：
【修饰符】 class 外部类名称 {
【修饰符】 返回值类型 外部类方法名称(参数列表) {
【修饰符】 class 有名字的局部内部类名称 {
// ...
}
}
}
说明：如果子类调用的是父类的无参构造，那么()中实参列表不用写；
如果子类调用的是父类的有参构造，那么()中传入实参列表；
定义一个类的时候，权限修饰符规则：
(1)外部类：public / default
(2)成员内部类：public / protected / default / private
(3)局部内部类：不加任何修饰符
4、特点
(1)局部内部类的修饰符，只能有 abstract 或 final；
(2)局部内部类有使用的作用域；
(3)如果局部内部类在静态方法中，不能使用外部类的非静态成员；
(4)在局部内部类中，可以使用当前局部内部类所在方法的局部变量，但是要求，这个局部变量必须是 final的常量。
5、扩展
在Java8时，如果某个局部变量被局部内部类使用了，会自动添加final变为常量，一旦变为常量，它的值就不能修改了。
为什么它要这么要求？给局部变量加 final呢？
避免局部内部类对象被返回到外部类的外面使用时，访问不到这个局部变量，所以要把这个局部变量变为final的常量。(常量在方法区中)
原因：
① new出来的对象在堆内存当中。
② 局部变量是跟着方法走的，在栈内存当中。
③ 方法运行结束之后，立刻出栈，局部变量就会立刻消失。
④ 但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。
Demo:
1 public classTestLocalInner {2 public static voidmain(String[] args) {3 Outer out = newOuter();4 Father in = out.test();//在外部类的外面虽然不能使用局部内部类，但是可以得到它的对象
5System.out.println(in.getClass());6 in.method();//在这里仍然可以访问到这个a，那么这个a就不能存在栈中，得挪到方法区，变为常量
7}8}9 abstract classFather{10 public abstract voidmethod();11}12 classOuter{13 private int i = 1;//成员变量，实例变量，非静态成员变量
14 private static int j = 2;//成员变量，类变量，静态变量
15
16 publicFather test(){17 //Inner in = new Inner(); 现在还没有声明该类，不能使用
18
19 final int a = 10;//局部变量==>局部的常量
20
21 //局部内部类
22 class Inner extendsFather{23 public voidmethod(){24System.out.println(i);25System.out.println(j);26System.out.println(a);27}28}29
30 Inner in = newInner();31in.method();32
33 returnin;34}35
36 public voidmethod(){37 //Inner in = new Inner(); 超过了作用域
38}39
40 public static voidfun(){41 //局部内部类
42 classInner{43 public voidmethod(){44 //System.out.println(i);//是因为fun方法是静态的
45System.out.println(j);46}47}48}49 }
6、
四、匿名内部类【重要】
1、概述
匿名内部类：是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。
匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在 new 的后面，用其隐含实现一个接口或实现一个类。
开发中，最常用到的内部类就是匿名内部类了，以接口为例，当你使用一个接口时，都得做如下几步操作：
(1)定义子类
(2)重写接口中的方法
(3)创建子类对象
(4)调用重写后的方法
而匿名类就可以把以上四步合成一步。
前提：匿名内部类必须继承一个父类或者实现一个父接口
2、语法格式
定义格式：
new 父类名或者接口名(){
// 方法重写
@Override
public void method() {
// 执行语句
}
};
特殊：声明匿名内部类与创建它的对象是一起完成的，即匿名内部类只有唯一的对象。
匿名内部类的特点：
(1)匿名内部类必须继承父类或实现接口；
(2)匿名内部类只能有一个对象；
(3)匿名内部类对象只能使用多态形式引用；
3、使用案例
以接口为例，匿名内部类的使用。
定义接口：
1 public abstract class FlyAble{
2 public abstract void fly();
3 }
创建匿名内部类，并调用：
1 public class InnerDemo {
2 public static void main(String[] args) {
3 /*
4 1.等号右边:是匿名内部类，定义并创建该接口的子类对象
5 2.等号左边:是多态赋值,接口类型引用指向子类对象
6 */
7 FlyAble f = new FlyAble(){
8 public void fly() {
9 System.out.println("我飞了~~~");
10 }
11 };
12 //调用 fly方法,执行重写后的方法
13 f.fly();
14 }
15 }
通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。如下所示
1 public class InnerDemo2 {
2 public static void main(String[] args) {
3 /*
4 1.等号右边:定义并创建该接口的子类对象
5 2.等号左边:是多态,接口类型引用指向子类对象
6 */
7 FlyAble f = new FlyAble(){
8 public void fly() {
9 System.out.println("我飞了~~~");
10 }
11 };
12 // 将f传递给showFly方法中
13 showFly(f);
14 }
15 public static void showFly(FlyAble f) {
16 f.fly();
17 }
18 }
将以上两步，也可以简化为一步：
1 public class InnerDemo3 {
2 public static void main(String[] args) {
3 /*
4 创建匿名内部类,直接传递给showFly(FlyAble f)
5 */
6 showFly( new FlyAble(){
7 public void fly() {
8 System.out.println("我飞了~~~");
9 }
10 });
11 }
12 public static void showFly(FlyAble f) {
13 f.fly();
14 }
15 }
4、
五、
2051
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
