首页 > 软件编程 > java > Java代码块和内部类

Java之代码块和内部类详解

2025-10-30 09:13:09 作者：懒羊羊不懒@

文章介绍了类的五大成员：成员变量、构造器、方法、代码块和内部类,代码块分为静态代码块和实例代码块,分别在类加载和对象创建时执行,内部类包括成员内部类、静态内部类、局部内部类和匿名内部类,匿名内部类是一种特殊的局部内部类,可以用于创建子类对象

类中的五大成分：

成员变量，构造器，方法，代码块，内部类。前面我们已经学过前三种今天我们来学最后两种。

1、代码块

代码块是类的5大成员之一（成员变量、构造器、方法、代码块、内部类）。

代码块的为两种：

静态代码块：

格式：static{}
特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。
作用：完成列=类的初始化，例如：对静态变量的初始化赋值。

实例代码块：

格式：{}
特点：每次创建对象时，执行实例代码块，并在构造器前执行。
作用：和构造器一样，都是用来完成对象的初始化的，例如：对实例变量进行初始化赋值。

Test类：测试类，演示静态代码块

import java.util.Arrays;

public class Test {
public static int[] cards = new int[10];
//由static修饰的代码块，在类加载的时候执行，只执行一次。
//基本作用：完成对类的静态资源初始化
static{
System.out.println("静态代码块");
//在代码块初始化只是初始化一次，如果放到方法中，每次调用方法都会初始化
cards[0] = 1;
cards[1] = 2;
cards[2] = 3;
cards[3] = 4;
cards[4] = 5;
}
public static void main(String[] args) {
//静态代码块
System.out.println("main方法");
System.out.println(Arrays.toString(cards));
}
}
/*
静态代码块
main方法
[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
 */

Test类：测试实例代码块

public class Test {
private int a;
private String[] directory = new String[4];  //实例变量表示方向，如果用实例代码块表示每个对象的这个数组，都初始化NSEW， 表示东南西北。
//实例代码块，无static修饰，属于对象，每次创建对象都会执行
//基本作用：初始化对象实例资源
{
System.out.println("实例代码块");
a = 10;
directory[0] = "N";
directory[1] = "S";
directory[2] = "E";
directory[3] = "W";
}

public static void main(String[] args) {
//实例代码块
//new 实例代码块();
//没有对象实例代码块{}是不执行的
System.out.println("main方法");
Test i = new Test ();
}
}
/*
main方法
实例代码块
 */

2、内部类

如果一个类定义在另一个类的内部，这个类就是内部类。
场景：当一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类。

内部类的格式

//  把发动机类放到汽车类中。

public  class  Car{

// 内部类

public   class   Engine{

}

}

内部类的种类

成员内部类、静态内部类、局部内部类、匿名内部类。

1.成员内部类

就是类中的一个普通成员，类似前面我们学过的成员变量、成员方法。

public  class  Outer{

// 成员内部类

public   class   Inner{

}

}

成员内部类创建对象的格式

外部类名.内部类   对象名  =  new  外部类（....）.new内部类(...);

Outer.Inner inner = new Outer().new Inner();

成员内部类中可以有普通类中所所以的东西，构造器、成员变量、方法等。成员内部类可以被继承也可继承其他类。

成员内部类中访问其他成员的特点

成员内部类中可以直接访问外部类的静态成员、静态方法。也可以直接访问外部类的实例成员、实例方法。（实例成员属于对象，但是成员内部类属于外部类对象）
成员内部类的实例方法中，可以直接拿到当前寄生的外部类对象：外部类.this()。

Outer 类：内有成员内部类Inner

public class Outer {
// 成员内部类：无static修饰的内部类，属于外部类对象持有。
//注意事项2
private static int a = 100;
public class Inner{
private  int a = 200;
public void show(){
int a = 300;
//任务在这里打印100 200 300 用a
System.out.println(a);
System.out.println(this.a);
System.out.println(Outer.this.a);
}
}
private int ans;

public void setAns(int ans) {
this.ans = ans;
}

public int getAns() {
return ans;
}
}

Test类

public class Test {
public static void main(String[] args) {
//目标：搞清楚内部类的语法
//成员内部类创建对象格式
//外部类对象.内部类对象 对象名 = new 外部类名称.new.内部名称();
Outer.Inner inner = new Outer().new Inner();
inner.show();
}
}
/*
输出结果：
300
200
100
 */

2.静态内部类

有static修饰的内部类，属于外部类自己持有。

public  class  Outer{

// 静态内部类

public static   class   Inner{

}

}

静态内部类创建对象的格式

外部类名.内部类   对象名  =  new  外部类.内部类(...);

Outer.Inner inner = new Outer.Inner();

静态内部类注意点：可以直接访问外部类的静态成员，不能直接访问外部类的实力成员。

3.局部内部类（了解）

4.匿名内部类（重点）

1.认识匿名内部类

是一种特殊的局部内部类；
所谓匿名：是类程序员不需要为这个类声明名字，默认有个隐藏的名字。

匿名内部类格式

new   类或接口（参数值...）{

类体（一般是方法重写）；

}

new  Animal（）{
@Override
public  void  cry(){
}
}

特点：匿名内部类本质是一个子类，并会立即创建出一个子类对象。

作用：用于更方便的创建一个子类对象。

Animal 类：抽象类

public abstract class Animal {
public abstract void cry(); //抽象类没有方法体
}

Cat 类：继承了Animal 类

public class Cat extends  Animal{
//方法重写
@Override
public void cry(){
System.out.println("猫喵喵喵~~");
}

}

Test类：测试类

public class Test {
public static void main(String[] args) {
Animal c = new Cat();
c.cry();
}
}
/*
输出结果：
猫喵喵喵~~
 */

上面的代码使我们在没有学习内部类之前所写的，现在我们学习了匿名内部类，怎么用匿名内部类来写呢？

Animal 类：抽象类

public abstract class Animal {
public abstract void cry(); //抽象类没有方法体
}

Test类：测试类

public class Test {
public static void main(String[] args) {
//匿名内部类本质是一个子类，同时会立即构建一个子类对象
Animal c = new Animal() {
@Override
public void cry() {
System.out.println("猫喵喵喵~~（匿名你内部类）");
}
}; //这里的分号不能忘。
c.cry();
}
}
/*
输出结果：
猫喵喵喵~~（匿名你内部类）
 */

上面代码运行产生的源码：证明了匿名内部类是一个子类。

2.匿名内部类在开发中的常见形式

通常作为一个对象参数传输给方法。

3.匿名内部类在开发中真实使用场景实例

调用别人提供的方法实现需求时，这个方法正好可以让我们传输一个匿名内部类对象给其使用。