类与接口（二）java的四种内部类详解

引言

一、静态内部类

static

private

public class OuterClass {//外围类

public int aa; //实例成员
private static float f = 1.5f;//private的静态成员

static void println() {
System.out.println("这是静态方法");
}

protected static class StaticInnerClass{//protected的静态内部类

float a;

public StaticInnerClass() {
a = f;// 外围类的private静态变量
println();//外围类的静态方法
}
}
}

class OtherClass{

public static void main(String[] args) {
//创建静态内部类的对象
OuterClass.StaticInnerClass staticInnerClass = new OuterClass.StaticInnerClass();
}
}

二、成员内部类

static final

final

OuterClass.this

OuterClass.this

外围类对象.new

//先创建外围类对象
OuterClass outer=new OuterClass();
//创建成员内部类对象
OuterClass.InnerClass inner=outer.new InnerClass();

1. 成员内部类的对象创建

public class OuterClass {//外围类

public int aa; //实例成员
private static float f = 1.5f;//private的静态成员

public void initInnerClass() {
System.out.println("内部类的初始化方法");
}

public void createInnerClass() {//
//外围类的成员方法中创建成员内部类对象
InnerClass innerClass = new InnerClass();
}

class InnerClass{//成员内部类
private double aa; //与围类的变量aa的名字重复

public InnerClass(){
this.aa = OuterClass.this.aa + f;//明确指定两个aa的所属
initInnerClass();
}
}
}

//其他类
class OtherClass{
public static void main(String[] args) {
//其他类中创建成员内部类
OuterClass oc = new OuterClass();//外部类对象
//创建内部类对象
OuterClass.InnerClass innerClass = oc.new InnerClass();
}
}

class InnerClass{//成员内部类
private double aa; //与围类的变量aa的名字重复

public InnerClass(){
this.aa = OuterClass.this.aa + f;//明确指定两个aa的所属
initInnerClass();
}

public  class InnerInnerCalss2{//成员内部类中的成员内部类
protected double aa = OuterClass.this.aa;//最外层的外围类的成员变量
}//InnerInnerCalss2
}//InnerClass

2. 继承成员内部类

class ChildClass extends OuterClass.InnerClass{

//成员内部类的子类的构造器的格式
public ChildClass(OuterClass outerClass) {
outerClass.super();//通过外围类的对象调用父类的构造方法
}
}

三、局部内部类

final

public class OuterClass {

private int a = 21;

static {//静态域中的局部内部类
class LocalClass1{
//  int z = a; //错误，在静态的作用域中无法访问对象成员
}
}

{//实例初始化块中的局部内部类
class localClass2{
}
}

public OuterClass(){
int x = 2;
final int y = 3;
// x = 3;//若放开此行注释，编译无法通过，因为局部变量x已经是final类型
//构造器中的局部内部类
class localClass3{
int z = y; //可以访问final的局部变量
int b = a;//可以访问类的所有成员
//访问没有用final修饰的局部变量
int c = x;
}
}

public void createRunnable() {

final int x = 4;
//方法中的局部内部类
class LocalClass4 implements Runnable {//
@Override
public void run() {
System.out.println("局部final变量："+x);
System.out.println("对象成员变量："+a);
}

}
}
}

四、匿名内部类

class MyOuterClass {

private int x = 5;

void createThread() {

final int a = 10;
int b = 189;

// 匿名内部类继承Thread类，并重写Run方法
Thread thread = new Thread("thread-1") {

int c = x;  //访问成员变量
int d = a;  //final的局部变量
int e = b; //访问没有用final修饰的局部变量

@Override
public void run() {
System.out.println("这是线程thread-1");
}
};

// 匿名内部类实现Runnable接口
Runnable r = new Runnable() {

@Override
public void run() {
System.out.println("线程运行中");
}
};
}
}

总结