个人主页→VON
收录专栏→java从入门到起飞
目录
一、成员内部类
Java 中的成员内部类是定义在另一个类中的类。它具有与普通类相似的结构,但有一些特殊的访问规则和使用方式。
特性:
定义方式:
成员内部类的定义方式如下:
public class OuterClass {
// 外部类的成员和方法
class InnerClass {
// 内部类的成员和方法
}
}
内部类 InnerClass
定义在外部类 OuterClass
的内部,可以直接访问外部类的成员变量和方法,包括私有成员。
访问规则:
- 外部类可以直接访问内部类的成员,包括私有成员。
- 内部类可以访问外部类的所有成员,包括私有成员。
- 内部类可以被声明为
private
、protected
、public
或package-private
(默认),其访问权限不影响外部类对内部类的访问权限。
实例化:
成员内部类需要通过外部类的实例来实例化,例如:
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();
这里 new InnerClass()
必须依附于一个外部类的实例 outer
。
生命周期:
成员内部类的生命周期和外部类的实例绑定,如果外部类实例被销毁,则内部类实例也无法再被访问。
静态成员:
成员内部类可以包含静态成员(静态字段或静态方法),但不能有静态的顶层类(即不能声明为 static class InnerClass
)。
使用场景:
- 封装性:可以将内部类隐藏在外部类中,只有外部类才能访问,从而增强了封装性。
- 逻辑关联:当内部类只对外部类可见并且仅用于实现外部类的一部分功能时,使用成员内部类能够更清晰地表达逻辑关联性。
- 回调函数:内部类通常用于实现回调函数,例如事件监听器的实现方式。
- 复杂数据结构:可以使用内部类来实现复杂的数据结构,例如迭代器等。
示例:
Outer类 :
package com.von.day15e;
public class Outer {
private int a = 10;
class Inner{
private int a = 20;
public void show(){
int a = 30;
System.out.println(Outer.this.a);//10
System.out.println(this.a);//20
System.out.println(a);//30
}
}
}
Text测试类:
package com.von.day15e;
public class Text {
public static void main(String[] args) {
Outer outer = new Outer();//先创建外部类的对象
Outer.Inner inner = outer.new Inner();//再创建内部类的对象
inner.show();
}
}
结果展示:
二、静态内部类
Java 中的静态内部类是定义在另一个类中且使用 static
修饰的类。静态内部类与非静态内部类(即成员内部类)有着一些重要的区别和特性。
特性:
定义方式:
静态内部类的定义方式如下:
public class OuterClass {
// 外部类的成员和方法
static class StaticInnerClass {
// 内部类的成员和方法
}
}
内部类 StaticInnerClass
被声明为 static
,因此它与外部类 OuterClass
的实例无关,可以直接通过 OuterClass.StaticInnerClass
的方式访问。
访问规则:
- 静态内部类可以直接访问外部类的静态成员和静态方法,包括私有的静态成员。
- 静态内部类不能直接访问外部类的非静态成员和实例方法,因为静态内部类在没有外部类实例的情况下也可以存在。
实例化:
静态内部类的实例化与普通类类似,不需要依附于外部类的实例,例如:
OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
生命周期:
静态内部类的生命周期与外部类的生命周期无关,它独立存在于外部类之外,直到虚拟机结束或被回收。
静态成员:
静态内部类可以包含静态成员(静态字段或静态方法),但不能直接访问外部类的非静态成员。
使用场景:
- 独立功能模块:当内部类不需要访问外部类的实例变量或方法,且希望将其组织为一个独立的类时,可以使用静态内部类。
- 增强封装性:静态内部类可以有效地隐藏实现细节,仅暴露必要的接口给外部。
- 工厂模式:可以将静态内部类作为工厂类,用于创建外部类的实例。
- 辅助类:可以作为外部类的辅助类来实现一些特定的功能,例如迭代器、比较器等。
示例:
Outer类:
package com.von.day15f;
public class Outer {
//静态内部类
static class Inner{
public void show1(){
System.out.println("静态内部类非静态方法");
}
public static void show2(){
System.out.println("静态内部类静态方法");
}
}
}
Text测试类:
package com.von.day15f;
public class Text {
public static void main(String[] args) {
Outer.Inner inner = new Outer.Inner();
inner.show1();//非静态方法
inner.show2();//静态方法
Outer.Inner.show2();//一般用这种方法
}
}
结果展示:
三、局部内部类
局部内部类(Local Inner Class)是定义在方法体内部的类,它与方法的局部变量具有相似的作用域。局部内部类可以访问外部类的成员变量和方法,以及方法中的 final 局部变量(Java 8 之后可以访问非 final 局部变量,但是需要保证该变量在局部内部类中不发生改变)。
特性:
定义方式:
局部内部类的定义位于方法内部,形式如下:
public class OuterClass {
// 外部类的成员和方法
public void outerMethod() {
class LocalInnerClass {
// 局部内部类的成员和方法
}
// 在方法内部实例化局部内部类
LocalInnerClass inner = new LocalInnerClass();
}
}
访问规则:
- 局部内部类只在方法内部有效,出了方法就无法访问。
- 局部内部类可以访问外部类的所有成员,包括私有成员。
- 局部内部类可以访问方法内的局部变量,但是要求局部变量必须是 final 的或者在 Java 8 及以后版本中被隐式声明为 final。
生命周期:
局部内部类的生命周期仅限于方法调用过程中,当方法返回时,局部内部类的对象也会被销毁。
使用场景:
- 当一个类仅在方法内部使用,并且对外部代码没有任何意义时,可以考虑使用局部内部类,这样能够将相关逻辑封装在一起,提高代码的局部性和封装性。
- 在需要实现某些接口或继承某个类,并且仅在方法中使用时,局部内部类是一个比较合适的选择。
示例:
Outer类:
package com.von.day15g;
public class Outer {
int a=10;
public void show(){
int b=20;
//局部内部类
class Inner{
String name;
int age;
public void text1(){
System.out.println("测试一");
}
public void text2(){
System.out.println("测试二");
}
}
Inner inner=new Inner();
inner.text1();
inner.text2();
System.out.println(a);
System.out.println(b);
}
}
Text类:
package com.von.day15g;
public class Text {
public static void main(String[] args)
{
Outer outer = new Outer();
outer.show();
}
}
结果展示:
四、匿名内部类(重点)
匿名内部类(Anonymous Inner Class)是一种没有显式定义类名的内部类,它允许在创建对象的同时定义类的实例。通常情况下,匿名内部类用于创建一个只需使用一次的类的实例,避免了显式定义一个新的类
特性和使用场景:
语法:
匿名内部类的语法比较特殊,通常在创建对象时使用,形式如下:
interface Greeting {
void greet();
}
public class Main {
public static void main(String[] args) {
Greeting greeting = new Greeting() {
public void greet() {
System.out.println("Hello, world!");
}
};
greeting.greet(); // 输出 "Hello, world!"
}
}
在这个例子中,Greeting
是一个接口,通过匿名内部类的方式实现了 greet()
方法。
特性:
- 匿名内部类没有类名,直接在创建对象的地方定义类的实例。
- 匿名内部类必须继承一个类或实现一个接口,不能同时做到。
- 匿名内部类不能定义任何静态成员、方法和初始化块。
- 匿名内部类可以访问外部类的成员变量和方法,但是外部类的局部变量必须是
final
的或者事实上的final
(Java 8+)。
使用场景:
- 事件监听器:在GUI编程中,常常使用匿名内部类作为事件监听器的实现。
- 线程类:在启动线程时,可以通过匿名内部类直接定义线程类的实例。
- 集合类的参数:在某些集合类的方法参数中,需要传递接口实例,可以使用匿名内部类快速实现接口方法。
示例:
Animal类:
package com.von.day15g;
public class Animal {
public void eat() {
System.out.println("吃东西");
}
}
Swim类:
package com.von.day15g;
public interface Swim {
abstract void swim();
}
Text测试类:
package com.von.day15g;
public class Text {
public static void main(String[] args){
new Swim(){
@Override
public void swim() {
System.out.println("匿名内部类实现接口");
}
}.swim();
new Animal(){
@Override
public void eat() {
System.out.println("匿名内部类实现抽象类");
}
}.eat();
methon(
new Animal(){
@Override
public void eat() {
System.out.println("狗吃骨头");
}
});
}
public static void methon(Animal a){
a.eat();
}
}
package com.von.day15g;
public class Text {
public static void main(String[] args){
new Swim(){
@Override
public void swim() {
System.out.println("匿名内部类实现接口");
}
}.swim();
new Animal(){
@Override
public void eat() {
System.out.println("匿名内部类实现抽象类");
}
}.eat();
methon(
new Animal(){
@Override
public void eat() {
System.out.println("狗吃骨头");
}
});
}
public static void methon(Animal a){
a.eat();
}
}
Text2测试类:
package com.von.day15g;
public class Text2 {
public static void main(String[] args) {
Swim s = new Swim(){
@Override
public void swim() {
System.out.println("游泳");
}
};
s.swim();
new Swim(){
@Override
public void swim() {
System.out.println("游泳");
}
}.swim();
}
}