Java之代码块和内部类详解

目录

• 1、代码块
• 2、内部类
• 1.python成员内部类
• 2.静态内部类
• 3.局部内部类（了解）
• 4.匿名内部类（重点）
• 1.认识匿名内部类
• 2.匿名内部类在开发中的常见形式
• 3.匿名内部类在开发中真实使用场景实例
• 案例2：对象数组排序
• 总结

类中的五大成分：

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

1、代码块

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

代码块的为两种：

静态代码块：

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

实例代码块：

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

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

import Java.util.Arrays;

public class http://www.devze.comTest {
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)python {
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{

}

}

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

外部类名.内部类   对象名  = yNKiVPdJTW 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); //居中显示
winyNKiVPdJTW.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());
}

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程客栈(www.devze.com)。