Java内部类入门指南有哪些？

本文共计1582个文字，预计阅读时间需要7分钟。

Java内部类初探：在深入了解内部类之前，我们首先需要明确内部类的概念，以及它们与外部类之间的关系和调用方式。本文将对内部类与外部类的关系及其调用方式进行总结。

Java内部类主要分为以下三种：

1. 成员内部类：作为外部类的成员存在，可以访问外部类的所有成员，包括私有成员。

2.局部内部类：定义在方法内部，作用域仅限于该方法内部。

3.匿名内部类：没有名字的内部类，通常用于实现接口或继承类。

以下是对内部类的总结：

- 成员内部类可以访问外部类的所有成员，包括私有成员。

- 局部内部类的作用域仅限于定义它的方法内部。- 匿名内部类通常用于实现接口或继承类，没有名字。

成员内部类举例：成员内部类`MyClass`的静态内部类`StaticInnerClass`：

javapublic class MyClass { public static class StaticInnerClass { // 静态内部类成员 }}

局部内部类举例：局部内部类`LocalInnerClass`定义在方法内部：

javapublic class MyClass { public void method() { class LocalInnerClass { // 局部内部类成员 } }}

匿名内部类举例：匿名内部类实现接口或继承类：

javainterface MyInterface { void doSomething();}

new MyInterface() { @Override public void doSomething() { // 实现接口方法 }};

Java内部类初探 之前对内部类的概念不太清晰，在此对内部类与外部类之间的关系以及它们之间的调用方式进行一个总结。

Java内部类一般可以分为以下三种：

成员内部类 静态内部类 匿名内部类 一、成员内部类 内部类的创建：成员内部类的创建需要依赖于外部类对象，没有创建外部类实例之前无法创建成员内部类对象

若在main函数中直接创建成员内部类则会报错：

MemberInner memberInner = new MemberInner();

私有属性访问：成员内部类可直接访问外部类非静态私有属性，外部类访问内部类私有属性则需要通过内部类的对象来访问

在 memberInnerTest() 方法中，可以直接访问外部类中的私有 test 字段，若内部类中有与外部类同名字段，调用外部类需要使用如下方法：

OuterTest.this.test

创建内部类：

在外部类内部创建内部类对象：使用new关键字创建内部类对象

private void createMemberInner(){
MemberInner memberInner = new MemberInner();
memberInner.memberInnerTest();
}

在外部类外部创建内部类对象：需要先创建外部类对象，再通过外部类创建内部类

OuterTest outerTest = new OuterTest();
MemberInner memberInner = outerTest.new MemberInner();

若不需要使用外部类，可以使用如下方式创建内部类

MemberInner memberInner = new OuterTest().new MemberInner();

使用该方法创建内部类需要注意：若外部类中有多个内部类，这种方法会 new 出多个外部类对象，各个类对象都是独立的，因此外部类的成员变量并不会在内部类中共享。

如下代码中，由于new出了两个 OuterVar 类，所以 InnerOne 与 InnerTwo 类输出的成员变量 var 均为0。若想 InnerOne 与 InnerTwo 类共享成员变量 var ，则需用如下方式创建：

OuterVar outerVar = new OuterVar();
InnerOne innerOne = outerVar.new InnerOne();
InnerTwo innerTwo = outerVar.new InnerTwo();
public class OuterVar {
private int var = 0;

class InnerOne{
private void innerOnePrint(){
System.out.println("innerOnePrint:"+var);
var+=1;
}
}

class InnerTwo{
private void innerTwoPrint(){
System.out.println("innerTwoPrint:"+var);
}
}

public static void main(String[] args) {
InnerOne innerOne = new OuterVar().new InnerOne();
InnerTwo innerTwo = new OuterVar().new InnerTwo();

innerOne.innerOnePrint();
innerTwo.innerTwoPrint();
}
}
/* 结果
innerOnePrint:0
innerTwoPrint:0
*/
/*1、成员内部类
2、静态内部类
3、匿名内部类
*/
public class OuterTest {
/*
1、成员内部类
*/
private String test = "OuterTest";

private void createMemberInner(){
MemberInner memberInner = new MemberInner();
memberInner.memberInnerTest();
}

class MemberInner{
private String test = "MemberInnerTest";

public void memberInnerTest(){
System.out.println("MemberInner");
System.out.println(test);
System.out.println(OuterTest.this.test);

}
}

public static void main(String[] args) {
// 成员内部类
OuterTest outerTest = new OuterTest();
MemberInner memberInner = outerTest.new MemberInner();
// MemberInner memberInner = new OuterTest().new MemberInner();

memberInner.memberInnerTest();
}
}


/* 结果
MemberInner
MemberInnerTest
OuterTest */

二、静态内部类 静态内部类定义在外部类的内部，使用static关键字修饰，静态内部类不需要外部类对象产生就能使用，不能访问外部类的成员域，但能访问静态域。

私有属性访问：静态内部类不可直接访问外部类的非静态属性

创建内部类：

在外部类内部创建内部类对象：使用new关键字创建内部类对象

private void createStaticInner(){
StaticInner staticInner = new StaticInner();
staticInner.staticInnerTest();
}

在外部类外部创建内部类对象：可以不创建外部类对象，直接创建内部类对象

StaticInner staticInner = new StaticInner();public class OuterTest {
/*
2、静态内部类
*/
private String test = "OuterTest";

private void createStaticInner(){
StaticInner staticInner = new StaticInner();
staticInner.staticInnerTest();
}


static class StaticInner{
private String test = "StaticInnerTest";

public void staticInnerTest(){
System.out.println("StaticInner");
System.out.println(test);
}
}

public static void main(String[] args) {
// 静态内部类
StaticInner staticInner = new StaticInner();
staticInner.staticInnerTest();
}
}

/* 结果
StaticInner
StaticInnerTest */

三、匿名内部类 使用匿名内部类的前提条件：必须继承一个父类或实现一个接口。 有以下一些特点:

由于匿名内部类是没有类名，所以匿名内部类不能有构造方法 匿名内部类不能定义任何静态成员、方法和类

//匿名内部类
interface Father{
public abstract void talk();

public abstract void eat();
}
public class Test {
public static void main(String[] args) {
//匿名内部类
Father father = new Father() {
@Override
public void talk() {
System.out.println("I'm Father");
}

@Override
public void eat() {
System.out.println("I'm eating");
}
};
father.talk();
father.eat();
}
}

/* 结果
I'm Father
I'm eating */