5.4 内部类
概念：当一个类的定义出现在另外一个类的类体中时，那么这个类叫做内部类（Inner），而这个内部类所在的类叫做外部类（Outer）。
• 类中的内容：成员变量、成员方法、构造方法、静态成员、构造块和静态代码块、内部类。
实际作用： 当一个类存在的价值仅仅是为某一个类单独服务时，那么就可以将这个类定义为所服务类中的内部类，这样可以隐藏该类
的实现细节并且可以方便的访问外部类的私有成员而不再需要提供公有的get和set方法。
内部类的分类：
- 普通内部类 - 直接将一个类的定义放在另外一个类的类体中。
- 静态内部类 - 使用static关键字修饰的内部类，隶属于类层级。
- 局部内部类 - 直接将一个类的定义放在方法体的内部时。
- 匿名内部类 - 就是指没有名字的内部类。
5.4.1 普通内部类
格式：
访问修饰符 class 外部类的类名 {
访问修饰符 class 内部类的类名 {
内部类的类体;
}
}
使用方式：
- 普通内部类和普通类一样可以定义成员变量、成员方法以及构造方法等。
package demo03;
public class NormalOuter {
private int cnt=1;
//定义普通内部类，隶属于外部类成员，属于对象层级
public class NormalInner {
private int ia=2;
public NormalInner() {
System.out.println("普通内部类的构造方法执行啦");
}
public void show() {
System.out.println("外部类的对象cnt是："+cnt);
System.out.println("内部类的对象ia是："+ia);
}
}
}
-
普通内部类和普通类一样可以使用final或者abstract关键字修饰。
-
普通内部类还可以使用private或protected关键字进行修饰。
-
普通内部类需要使用外部类对象来创建对象。
package demo03; public class NormalOuterTest { public static void main(String[] args) { //1.声明外部类的引用指向外部类的对象 NormalOuter no=new NormalOuter(); //2.声明外部类中的内部类的引用指向内部类的对象 NormalOuter.NormalInner ni=no.new NormalInner(); //内部类属于对象层级，所以需要对象.的方式调用 //3.调用show方法 ni.show(); /*普通内部类的构造方法执行啦 外部类的对象cnt是：1 内部类的对象ia是：2 */ System.out.println("--------------------------"); ni.show2(4); } } -
如果内部类访问外部类中与本类内部同名的成员变量或方法时，需要使用this关键字。
public class NormalOuter { private int cnt=1; //定义普通内部类，隶属于外部类成员，属于对象层级 public class NormalInner { private int ia=2; private int cnt=3; public NormalInner() { System.out.println("普通内部类的构造方法执行啦"); } public void show() { System.out.println("外部类的对象cnt是："+cnt); System.out.println("内部类的对象ia是："+ia); } public void show2(int cnt) { System.out.println("形参变量cnt="+cnt); System.out.println("内部类变量cnt="+this.cnt); System.out.println("外部类变量cnt="+NormalOuter.this.cnt); } } }
5.4.2 静态内部类
格式：
访问修饰符 class 外部类的类名 {
访问修饰符 static class 内部类的类名 {
内部类的类体;
}
}
使用方式：
-
静态内部类不能直接访问外部类的非静态成员。
public class StaticOuter { private int cnt = 1; //隶属于对象层级 private static int snt = 2; //隶属于类层级 public static void show() { System.out.println("外部类的show方法！"); } public static class StaticInner { //隶属于类层级 private int ia = 3; private static int snt=4; //内部类层级 public StaticInner() { System.out.println("静态内部类的构造方法！"); } public void show() { System.out.println("ia="+ia); System.out.println("外部类snt="+snt); // System.out.println("外部类的cnt="+cnt); //Error:静态上下文中不能访问非静态的成员，因为此时可能还未创建对象 } public void show2(int snt) { System.out.println("snt="+snt); //形参变量的snt System.out.println("内部类的snt="+StaticInner.snt); //4 System.out.println("外部类的snt="+StaticOuter.snt); //2 new StaticOuter().show(); //创建一个StaticOuter类型使用类名.的方式调用 } } } -
静态内部类可以直接创建对象。
public class StaticOuterTest { public static void main(String[] args) { //声明内部类的引用指向内部类的对象 StaticOuter.StaticInner si=new StaticOuter.StaticInner(); //此时不需要创建对象调用内部类 si.show(); System.out.println("---------------------------"); si.show2(5); } } -
如果静态内部类访问外部类中与本类内同名的成员变量或方法时，需要使用类名.的方式访问。
new StaticOuter().show(); //创建一个StaticOuter类型使用类名.的方式调用
5.4.3 局部（方法）内部类
格式：
访问修饰符 class 外部类的类名 {
访问修饰符 返回值类型 成员方法名（形参列表） {
class 内部类的类名 {
内部类的类体;
}
}
}
使用方式：
-
局部内部类只能在该方法的内部可以使用。
package demo03; public class AreaOuter { private int cnt = 1; public void show() { //声明一个局部变量，在局部内部类使用时，默认时final关键字修饰 int ic=4; //定义局部内部类，只在方法体的内部好使 class AreaInner { private int ia = 2; public AreaInner() { System.out.println("局部内部类的构造方法！"); } public void test() { int ib=3; System.out.println("ia=" + ia); System.out.println("cnt=" + cnt); // ic=5; System.out.println("ic="+ic); } } //声明局部内部类的引用指向局部内部类的对象 AreaInner ai=new AreaInner(); ai.test(); } } -
局部内部类可以在方法体内部直接创建对象。
//声明局部内部类的引用指向局部内部类的对象 AreaInner ai=new AreaInner(); ai.test(); -
局部内部类不能使用访问控制符和static关键字修饰符。
class AreaInner { 类体 } -
局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。
备注：从Java 8开始，只要局部内部类的数值不变，final关键字可省略。
原因：1、new出来的对象在堆内存当中
2、局部变量跟着方法走，在栈内存中
3、方法运行结束后，立刻出栈，局部变量会立刻消失
4、但是new出来的对象会在堆内存当中持续存在，直到垃圾回收消失package demo03; public class AreaOuter { public void show() { //声明一个局部变量，在局部内部类使用时，默认时final关键字修饰 int ic=4; //定义局部内部类，只在方法体的内部好使 class AreaInner { public void test() { // ic=5; Error System.out.println("ic="+ic); } } } }
5.4.4 回调模式
概念：回调模式是指——如果一个方法的参数是接口类型public static void test(AnonymousInterface ia)，则在调用该方法时，需要创建并传递一个实现此接口类型的对象AnonymousInterfaceTest.test(new AnonymousInterfaceImpl());；而该方法在运行时会调用到参数对象中所实现的方法//编译阶段调用接口的方法，运行阶段调用实现类的方法 ia.show();（接口中定义的）。
实现步骤：
-
定义接口：
package demo03; public interface AnonymousInterface { public abstract void show(); } -
创建实现类实现接口
package demo03; public class AnonymousInterfaceImpl implements AnonymousInterface{ @Override public void show() { System.out.println("这里是接口的实现类！"); } } -
创建测试类
package demo03; public class AnonymousInterfaceTest { public static void test(AnonymousInterface ia) { // AnonymousInterface ia=new AnonymousInterfaceImpl(); //接口类型的引用指向实现类的对象 //编译阶段调用接口的方法，运行阶段调用实现类的方法 ia.show(); } public static void main(String[] args) { // AnonymousInterfaceTest.test(new AnonymousInterface()); //Error:接口不能实例化 AnonymousInterfaceTest.test(new AnonymousInterfaceImpl()); } }
5.5.5 匿名内部类
语法格式：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };
//使用匿名内部类的格式进行来得到接口类型的引用
AnonymousInterface ia=new AnonymousInterface() {
@Override
public void show() {
System.out.println("匿名内部类的实现");
}
};
//调用
AnonymousInterfaceTest.test(ia);
5.5.6 lamda 表达式的使用
语法格式：接口/父类类型 引用变量名=（参数列表） -> {方法体}
//从Java 8开始提出Java新特性，可以使用lamda表达式简化上述代码 接口名 对象名=（参数列表） -> {方法体}
AnonymousInterface ai=() -> {
System.out.println("lamda表达式的实现1");
};
AnonymousInterface ai1=() -> System.out.println("lamdon表达式的简化");
AnonymousInterfaceTest.test(ai1);
AnonymousInterfaceTest.test(ai);
