文章目录
Java 内部类
基本介绍
一个类的内部又完整的嵌套了另一个结构,被嵌套的类称为 内部类(inner class),嵌套其他类的类称为 外部类 (outer Class),是我们类的第五大成员,内部类可以直接访问其外部类的私有属性。
🚀类的五大成员
1.属性
2.方法
3.构造器
4.代码块
5.内部类
基本语法
内部类分类
1. 定义在外部类局部位置上: (例如方法内)
1)局部内部类
2)匿名内部类
2. 定义在外部类的成员位置上:
1)成员内部类(没用static修饰)
2)静态内部类(使用static修饰)
局部内部类
局部类细节一
局部内部类是定义在外部类的局部位置上的,例如方法中,并且有类名
1. 可以直接访问外部类的所有成员,包括私有属性和私有方法。
2. 不能添加访问修饰符,因为它相当于一个局部变量,局部变量是不可以使用修饰符的,但是可以使用 final 修饰,因为局部变量可以用 final 修饰。
3. 作用域: 只在定义它的方法或者代码块中(和局部变量一样)。
4. 局部内部类访问其外部类的成员可以直接访问,但是外部类访问局部内部类的成员,必须通过创建对象的方式来访问,并且在作用域内。
代码示例
public class LocalInnerClass01 {
public static void main(String[] args) {
Outer outer = new Outer();
outer.fun2();
}
}
class Outer {
private int n1 = 100;
private void fun1() {
System.out.println("外部类fun1方法");
}
public void fun2() {
class Inner {//局部内部类
public void fun() {
System.out.println("n1 = " + n1);
fun1();
}
}
//在作用域内创建内部类对象,访问其fun方法
Inner inner = new Inner();
inner.fun();
}
}
运行结果:
局部类细节二
如果外部类和局部内部类的成员重名时,默认遵循就近原则,如果想要访问外部类的成员,可以使用 外部类名.this.成员 来访问。
代码示例
public class LocalInnerClass02 {
public static void main(String[] args) {
Outer outer = new Outer();
outer.fun1();
}
}
class Outer {
private int num = 100;
public void fun1() {
class Inner {
private int num = 200;//与外部类属性重名
public void fun() {
System.out.println("内部类num = " + num);
System.out.println("外部类num = " + Outer.this.num);
}
}
//在作用域内创建内部类对象,访问其fun方法
Inner inner = new Inner();
inner.fun();
}
}
运行结果:
🚀解读: 外部类名.this. 本质上就是外部类对象,在代码示例中表示调用fun1方法的对象。
匿名内部类
匿名内部类介绍
匿名内部类
定义在外部类的局部位置,比如方法中,并且没有类名,它本质上还是一个类,同时还是一个对象。
匿名内部类基本语法
基于接口的匿名内部类
传统的我们使用接口,首先需要创建一个类实现该接口并且重写接口的方法,然后通过这个类创建对象,最后调用其方法,但是如果我们只想使用一次,那么创建一个类是不是显得很不划算呢?这时候就可以借助匿名内部类来简化开发。
代码示例
public class AnonymousInnerClass {
public static void main(String[] args) {
Hero hero = new Hero();
hero.attack();
}
}
class Hero {
public void attack() {
Skill skill = new Skill() { //匿名内部类
@Override
public void bigMove() {
System.out.println("英雄释放了大招~~~");
}
};
skill.bigMove(); //调用bigMove方法
}
}
//接口
interface Skill {
public void bigMove();
}
运行结果:
🚀解读:
在代码示例中,skill
的编译类型是Skill类型,但是其运行类型就是匿名内部类,在JDK底层实现了这个内部类,我们可以认为这个内部类名字为XXXX,这个内部类实现了Skill接口,如下:
基于类的匿名内部类
代码示例
public class AnonymousInnerClass {
public static void main(String[] args) {
Outer outer = new Outer();
outer.fun();
}
}
class Outer {
public void fun() {
Hero hero = new Hero() {
@Override
public void test() {
System.out.println("匿名内部类重写了test方法");
}
};
hero.test();
}
}
class Hero {
public void test() {
System.out.println("Hero中的test方法");
}
}
运行结果:
🚀解读:
在代码示例中,hero
的编译类型为Hero,但是它的运行类型为匿名内部类,在JDK底层实现了这个内部类,我们可以认为这个内部类名字为XXXX,这个内部类继承了Hero类,如下:
🚨注意: 如果是基于抽象类的匿名内部类,就必须重写其方法。
匿名内部类使用细节
1. 匿名内部类可以直接访问外部类的所有成员,包括私有成员。
2. 不可以添加访问修饰符,因为它相当于一个局部变量。
3. 作用域: 仅仅在定义它的方法和代码块中。
4. 外部其他类不可以访问匿名内部类
5. 如果外部类和匿名内部类的成员重名时,默认遵循就近原则,如果想要访问外部类的成员,可以使用 外部类名.this.成员 来访问。
成员内部类
成员内部类
定义在外部类的成员位置,并且没有 static 修饰。
🚀使用细节:
1. 可以直接访问外部类的所有成员,包括私有的。
2. 可以添加任意访问修饰符(public、protected、默认、private),因为它本身就是一个成员。
3. 作用域: 和外部类的其他成员一样,为整个类体。
4. 外部类访问成员内部类,可以在其成员方法中创建对象再访问。
5. 如果外部类和匿名内部类的成员重名时,默认遵循就近原则,如果想要访问外部类的成员,可以使用 外部类名.this.成员 来访问。
6. 外部其他类访问成员内部类有两种方式:
//方式一 构建外部类对象
Outer.Inner inner = outer.new Inner();
//方式二 在外部类中定义方法,返回内部类对象
Outer.Inner instance = outer.getInstance();
代码示例
public class MemberInnerClass {
public static void main(String[] args) {
Outer outer = new Outer();
outer.fun2();
//外部其他类访问成员内部类
//方式一 构建外部类对象
Outer.Inner inner = outer.new Inner();
//方式二 在外部类中定义方法,返回内部类对象
Outer.Inner instance = outer.getInstance();
}
}
class Outer {
private int num1 = 10;
public void fun1() {
System.out.println("fun1方法");
}
//外部类访问内部类
public void fun2() {
Inner inner = new Inner();
inner.fun();
}
public Inner getInstance() {
return new Inner();
}
class Inner {
private int num1 = 20;//与外部类属性重名
public void fun() {
System.out.println("Inner_num1 = " + num1);
System.out.println("Outer_num1 = " + Outer.this.num1);
}
}
}
运行结果:
静态内部类
静态内部类
定义在外部类的成员位置,并且使用 static 修饰。
🚀使用细节:
1. 可以直接访问外部类的所有静态成员,包括私有的,但不能访问非静态成员。
2. 可以添加任意访问修饰符(public、protected、默认、private),因为它本身就是一个成员。
3. 作用域: 和外部类的其他成员一样,为整个类体。
4. 外部类访问成员内部类,可以在其成员方法中创建对象再访问。
5. 如果外部类和匿名内部类的成员重名时,默认遵循就近原则,如果想要访问外部类的成员,可以使用 外部类名.成员 来访问。
6. 外部其他类访问静态内部类有两种方式:
//外部其他类访问静态内部类
//方式一 new Outer.Inner();
Outer.Inner inner = new Outer.Inner();
//方式二 在外部类中定义方法,返回内部类对象
Outer.Inner inner1 = new Outer().getInner();
代码示例
public class StaticInnerClass {
public static void main(String[] args) {
Outer outer = new Outer();
outer.fun1();
//外部其他类访问静态内部类
//方式一 new Outer.Inner();
Outer.Inner inner = new Outer.Inner();
//方式二 在外部类中定义方法,返回内部类对象
Outer.Inner inner1 = new Outer().getInner();
}
}
class Outer {
private static int num = 10;
//外部类访问内部类
public void fun1() {
Inner inner = new Inner();
inner.fun();
}
public Inner getInner() {
return new Inner();
}
static class Inner {
private static int num = 20;//与外部类属性命名冲突
public void fun() {
System.out.println("Outer_num = " + Outer.num);
System.out.println("Inner_num = " + num);
}
}
}
运行结果: