Java—代码块、内部类
目录
类中的五大成分：成员变量，构造器，方法，代码块，内部类。前面我们已经学过前三种今天我们来学最后两种。
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.匿名内部类在开发中真实使用场景实例
调用别人提供的方法实现需求时，这个方法正好可以让我们传输一个匿名内部类对象给其使用。
Test类
import javax.swing.*;
import java.awt.event.ActionEvent;
public class Test {
public static void main(String[] args) {
//目标：搞清楚几个匿名内部类的使用场景
//需求：创建一个登录窗口，窗口上只有一个登录按钮
JFrame win = new JFrame();
win.setSize(300, 200);
win.setLocationRelativeTo(null); //居中显示
win.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel panel = new JPanel();
win.add(panel);
JButton btn = new JButton("登录");
panel.add(btn);
//Java要求必须传输给这个按钮添加一个点击事件监视器对象，这个对象可以监视用户的点击操作，就可以做出反应
btn.addActionListener(new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("登录成功~");
}
});
win.setVisible(true);
}
}
案例2：对象数组排序
使用comparator接口的匿名内部类实现对数组进行排序
对象数组排序
import java.util.Arrays;
import java.util.Comparator;
public class Testt {
public static void main(String[] args) {
Student []s = new Student[5];
s[0] = new Student("张三", 18);
s[1] = new Student("李四", 19);
s[2] = new Student("张三", 50);
s[3] = new Student("李白", 5);
s[4] = new Student("王五", 10);
for (int i = 0; i < s.length; i++) {
System.out.println(s[i].getName() + " " + s[i].getAge());
}
Arrays.sort( s, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getAge() - o2.getAge();
}
});
System.out.println("排序后：____________");
for (int i = 0; i < s.length; i++) {
System.out.println(s[i].getName() + " " + s[i].getAge());
}
Agent 垂直技术社区，欢迎活跃、内容共建。
更多推荐
36
0- 0
已为社区贡献11条内容
所有评论(0)