一、概念
- 内部类:在一个类的内部,定义了一个完整的类。
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);
}
// 静态内部类
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);
}