一、概念
-
内部类：在一个类的内部，定义了一个完整的类。
class Outer{ // 外部类
class Inner{} // 内部类
}
-
内部类编译之后会生成独立的 .class 文件，.class 文件命名方式为：
外部类的类名$内部类的类名.class
-
内部类可以直接访问外部类的成员；通常将内部类作为外部类的组件构成
-
内部类的分类：成员内部类、静态内部类、局部内部类、匿名内部类
二、成员内部类(类比于 实例变量) 【了解：阅读源码时认识】
-
位置：定义在类以内，方法以外
-
成员内部类对象的创建：依赖于外部类的对象创建：
Outer o = new Outer(); // 创建外部类的对象
Outer.Inner i = o.new Inner(); // 创建成员内部类的对象
-
成员内部类可以直接访问外部类的属性 和 方法（私有的也可以访问）
-
外部类的类名.this ：代表当前外部类的对象
外部类类名.this.属性： 访问外部类的属性
外部类类名.this.成员方法(实参)； ：访问外部类的成员方法
-
成员内部类不能定义静态成员(静态属性、静态的方法、静态代码块)
public class TestInner {
public static void main(String[] args) {
Outer o = new Outer();
// 创建成员内部类的对象：必须依赖于 外部类的对象而创建
Outer.Inner i = o.new Inner();
System.out.println(i.n);
i.inner_method();
System.out.println(o.a);
}
}
// 外部类
class Outer{
int a = 3; // 实例变量
// 成员方法
public void outer_method() {
System.out.println("外部类的成员方法....");
}
// 成员内部类(类比于实例变量)
class Inner{
int n = 7;
int a = 6; // 成员内部类中属性
//static int m = 2;
public Inner() {
}
public void inner_method() {
int a = 8;// 局部变量
System.out.println("内部类中成员方法....");
System.out.println("a="+a);
System.out.println("this.a="+this.a); System.out.println("Outer.this.a="
+Outer.this.a);
Outer.this.a = 10;
}
}
}三、静态内部类(类比于： 静态变量)【了解：阅读底层源码时认识】
-
位置：定义在类以内，方法以外，被static 修饰的内部类
-
静态内部类中可以定义实例变量和静态变量 (方法也是一样)
-
创建静态内部类的对象：
外部类类名.静态内部类的类名 引用名 = new 外部类类名.静态内部类名();
-
访问静态内部类的静态成员：可以直接通过类名访问
外部类类名.静态内部类类名.静态属性：访问静态内部类的静态属性
外部类类名.静态内部类类名.静态方法(实参); 访问静态内部类的方法
-
静态内部类只能直接访问外部类静态成员(静态属性和静态方法)；
静态内部类中不能直接访问外部类的非静态成员。
public class TestStaticInner { public static void main(String[] args) { // 创建静态内部类的对象 /* * MyClass.Inner i = new MyClass.Inner(); * * System.out.println(i.m); i.inner_method(); */ //i.inner_static_method(); System.out.println(MyClass.Inner.n); MyClass.Inner.inner_static_method(); } } class MyClass{ int a = 2; // 实例变量 static int b = 5; // 静态变量 public void outer_method() { System.out.println("外部类的成员方法..."); } public static void outer_static_method() { System.out.println("外部类的静态方法...."); System.out.println("b="+b); } // 静态内部类 static class Inner{ int m = 1;// 实例变量 static int n = 2; // 静态变量 public void inner_method() { System.out.println("静态内部类中成员方法...."); System.out.println("b="+b); } public static void inner_static_method() { System.out.println("静态内部类的静态方法..."); } } }
四、局部内部类(类比于：局部变量) 【阅读源码偶尔见到，过渡使用】
-
位置：定义在函数、方法以内
-
创建局部内部类的对象，需要在定义它的方法内部完成对象的创建，同时创建对象应该在类定义以后位置(先定义类，再创建对象)
-
注意：局部内部类既可以定义在成员方法，也可以定义在静态方法。
-
局部内部类可以直接访问外部类成员(静态成员+非静态成员)
注意：此时距内部类定义在 成员方法中情况。
-
局部内部类可以访问定义它的方法内部的局部变量，但是局部变量必须被final修饰，才能被局部内部类访问。
JDK8.0版本及以上，如果JVM检测一个方法中局部变量被此方法内部的局部内部类方法，jvm默认在此局部变量前面加 final，此语法被称为语法糖
public class TestLocalInner {
public static void main(String[] args) {
ClassA ca = new ClassA();
ca.outer_method();
}
}
class ClassA{
int n = 3;// 实例变量
static int f = 8;
public void outer_method() {
System.out.println("外部类的成员方法....");
int m = 6; // 局部变量
System.out.println("m="+m);
// 局部内部类
class Inner{
int a = 1;
public void inner_method() {
System.out.println("局部内部类的成员方法...");
System.out.println("n="+n);
System.out.println("m="+m); // final
}
}
// 局部内部类的对象
Inner i =new Inner();
System.out.println(i.a);
i.inner_method();
}
public void test() {
// System.out.println("m="+m);
}
}五、匿名内部类【根据自身能力可选内容-简化代码】
-
匿名内部类：是一种特殊的局部内部类
-
特点：
(1) 匿名内部类的定义必须继承一个父类或是实现一个接口
(2) 匿名内部类的定义和对象的创建一起完成；并且基于一个匿名内部类
只能创建该类的一个对象
-
语法：
interface IA{ void m1(); void m2(); } // 匿名内部类实现一个接口 IA ia = new IA(){ public void m1(){ // 方法实现的部分 } public void m2(){ // 方法实现的部分 } }; -
匿名内部类的优缺点：
(1) 缺点：可读性不高
(2) 优点：减少代码量，提高编码效率
public class TestAnonymousInner {
public static void main(String[] args) {
// 匿名内部类
IA ia=new IA() {
public void m1() {
System.out.println("匿名内部类覆盖了m1方法");
}
};
ia.m1();
ia.m1();
// 继承一个父类定义一个匿名内部类
ClassD cd = new ClassD() {
public void m1() {
System.out.println("子类覆盖了m1方法.....");
}
};
cd.m1();
cd.m2();
test(new IA(){
public void m1(){
System.out.println("实现部分...");
}
});
}
public static void test(IA ia){
ia.m1();
}
}
interface IA{
void m1();
}
class ClassD{
public void m1() {
System.out.println("父类中m1方法");
}
public void m2() {
System.out.println("父类中m2方法....");
}
}六、Lambda 表达式(JDK8.0开始有的应用)【此内容根据自身能力可选】
- Lambda表达式：实现函数式接口并完成对象的创建，是匿名内部类的简化形式。
-
应用场景：当接口中只有一个抽象方法时(静态方法、默认方法不在其中)
-
语法：
接口名 引用 = (形参列表) -> { // 方法实现部分 }； 语法解释： -> 是JDK8.0新引入一个语法符号 -> 左侧：Lambda表达式参数，即接口方法中形参部分 -> 右侧：指定Lambda表达式执行功能部分，即接口方法中实现部分(1) 无参数、没有返回值
a. 语法结构：接口名 引用 = () -> {// 方法实现部分};
b. 注意：当 {}中只有一行语句时，{}可以省略，但是不建议。
public class TestAnonymousInner3 { public static void main(String[] args) { IC ic = () -> { System.out.println("这是方法实现部分..."); }; ic.mc(); } } interface IC{ void mc(); }(2) 带有参数、没有返回值
a. 语法结构:接口名 引用 = (数据类型 变量名,数据类型 变量) -> {// 方法实现部分 };
b. 注意：Lambda表达式形参列表的数据类型可以省略，编译器自行推断。
public class TestAnonymousInner3 { public static void main(String[] args) { ID id = (a, s) ->{ System.out.println("a="+a); System.out.println("s="+s); }; id.md(2, "小龙"); } } interface ID{ void md(int a,String str); }(3) 带有返回值：
a. 语法结构：接口名 引用名 = (形参列表)->{ return xxx; };
b. 注意：如果{}中只有一条 return 语句，return语句和{}可以省略(一起)。
public class TestAnonymousInner3 { public static void main(String[] args) { IE ie = (int a,int b) -> { return a+b; }; System.out.println(ie.me(3, 5)); // 如果Lambda{}实现中只有 return 语句 IE ie2 = (int a,int b) -> a+b; System.out.println(ie2.me(3, 5)); } } interface IE{ int me(int a,int b); }