内部类
内部类
概述
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
成员内部类
- 成员内部类 ：定义在类中方法外的类。
class 外部类 {
class 内部类{
}
}
访问特点
- 内部类可以直接访问外部类的成员，包括私有成员。
- 外部类要访问内部类的成员，必须要建立内部类的对象。
创建内部类对象格式：
外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；
定义类：
public class Person {
private boolean live = true;
class Heart {
public void jump() {
// 直接访问外部类成员
if (live) {
System.out.println("心脏在跳动");
} else {
System.out.println("心脏不跳了");
}
}
}
public boolean isLive() {
return live;
}
public void setLive(boolean live) {
this.live = live;
}
}
定义测试类：
public class InnerDemo {
public static void main(String[] args) {
// 创建外部类对象
Person p = new Person();
// 创建内部类对象
Heart heart = p.new Heart();
// 调用内部类方法
heart.jump();
// 调用外部类方法
p.setLive(false);
// 调用内部类方法
heart.jump();
}
}
输出结果:
心脏在跳动
心脏不跳了
内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的 .class文件，但是前面冠以外部类的类名和 符 号 。 比 如 ， P e r s o n 符号 。比如，Person 符号。比如，PersonHeart.class
内部类的同名变量访问
内部类：
package cn.itcast.day04.demo06;
public class Outer {
int num = 10;//外部类的成员变量
public class Inner{
int num = 20;//内部类的成员变量
public void method(){
int num = 30;//内部类方法的局部变量
System.out.println(num);//局部变量，就近原则
System.out.println(this.num);//内部类的成员变量
System.out.println(Outer.this.num);//外部内的成员变量
}
}
}
测试类
package cn.itcast.day04.demo06;
public class Main {
public static void main(String[] args) {
Outer.Inner obj = new Outer().new Inner();
obj.method();
}
}
输出：
30
20
10
局部内部类
如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。“局部”：只有当前的所属方法才能使用它，出了这个方法外面就不能用了。
定义格式：
修饰符 class 外部类名称{
修饰符 返回值类型 外部类方法名称(参数列表){
class局部内部类名称{
//...
}
}
}
局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是有效final的。
从java8+开始，只要局部变量事实不变，那么final关键字可以省略。
原因：
- new出来的对象在堆内存当中。
- 局部变量是跟着方法走的，在栈内存当中。
- 方法运行结束之后，立刻出栈，局部变量就会消失。
- 但是new出来的对象会在堆当中持续存在，知道垃圾回收消失。
public class MyOuter{
public void method(){
int num = 10;//所在方法的局部变量
class MyInner{
public void method1(){
System.out.println(num);
}
}
}
}
匿名内部类【重点】
匿名内部类 ： 是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。开发中，最常用到的内部类就是匿名内部类了。
前提： 匿名内部类必须继承一个父类或者实现一个父接口。
格式：
接口名称 对象名 = new 接口名称(){
//覆盖重写所有的抽象方法
}
new 父类名或者接口名(){
// 方法重写
@Override
public void method() {
// 执行语句
}
};
对格式“new 接口名称（）{…}”进行解析：
- new代表创建对象的动作。
- 接口名称就是匿名内部类需要实现哪个接口。
- {…}这才是匿名内部类的内容。
以接口为例，匿名内部类的使用，代码如下：
定义接口：
public abstract class FlyAble{
public abstract void fly();
}
创建匿名内部类，并调用：
public class InnerDemo {
public static void main(String[] args) {
/*
1.等号右边:是匿名内部类，定义并创建该接口的子类对象
2.等号左边:是多态赋值,接口类型引用指向子类对象
*/
FlyAble f = new FlyAble(){
public void fly() {
System.out.println("我飞了~~~");
}
};
//调用 fly方法,执行重写后的方法
f.fly();
}
}
通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：
public class InnerDemo2 {
public static void main(String[] args) {
/*
1.等号右边:定义并创建该接口的子类对象
2.等号左边:是多态,接口类型引用指向子类对象
*/
FlyAble f = new FlyAble(){
public void fly() {
System.out.println("我飞了~~~");
}
};
// 将f传递给showFly方法中
showFly(f);
}
public static void showFly(FlyAble f) {
f.fly();
}
}
以上两步，也可以简化为一步，代码如下：
public class InnerDemo3 {
public static void main(String[] args) {
/*
创建匿名内部类,直接传递给showFly(FlyAble f)
*/
showFly( new FlyAble(){
public void fly() {
System.out.println("我飞了~~~");
}
});
}
public static void showFly(FlyAble f) {
f.fly();
}
}
另外还要注意绩点问题：
- 匿名内部类，在创建对象的时候，只能使用唯一一次。如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类。
- 匿名对象，在调用方法的时候，只能调用唯一一次。如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
- 匿名内部类是省略了实现类名称，但是匿名对象是省略了对象名称。