07 - 面向对象编程（高级部分三）
一、类中的成分 - 代码块基本介绍
[*]代码块是类的 5 大成分之一（成员变量、构造器、方法、代码块、内部类）。
代码块分为两种：
[*]静态代码块：
格式：static {}
特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。
作用：完成类的初始化，例如，对静态变量的初始化赋值。
//示例
public class CodeBlock {
//静态资源
public static String name;
public static String[] pokeCards = new String;
//静态代码块
//基本作用：可以完成对类的静态资源的初始化
static {
System.out.println("===静态代码块执行了===");
name = "可乐";
pokeCards = "A";
pokeCards = "2";
.....
}
public static void main(String[] args){
//目标：认识代码块，理解代码块的执行顺序、基本作用
System.out.println("===main方法执行了===");
}
}执行结果：
===静态代码块执行了===
===main方法执行了===
[*]实例代码块：
格式：{}
特点：每次创建对象时，执行实例代码块，并在构造器前执行。
作用：和构造器一样，都是用于完成对象的初始化，例如，对实例对象进行初始化。
public class CodeBlock {
//实例变量
private String name;
private String[] direction = new String;
//实例代码块，无static修饰，属于对象
//基本作用：初始化对象的实例资源
{
System.out.println("===实例代码块执行了===");
name = "可乐"
deirection = "东";
deirection = "南";
deirection = "西";
deirection = "北";
}
public static void main(String[] args){
//目标：认识代码块，理解代码块的执行顺序、基本作用
System.out.println("===main方法执行了===");
new CodeBlock();
}
}执行结果：
===main方法执行了===
===实例代码块执行了===二、内部类
基本介绍
[*]如果一个类定义在另一个类的内部，这个类就称为内部类。
[*]使用场景：当一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类。
public class Car {
//内部类
public class Engine {
}
}
[*]成员内部类
[*]类中的一个普通成员，类似普通成员变量、成员方法。
//外部类
public class OuterClass {
//外部类静态变量
public static String name = "可乐";
//外部类实例变量
private int age;
//外部类静态方法
public static void test() {
}
//成员内部类，无static修饰，属于外部类对象持有的。
public class InnerClass {
public void show() {
System.out.println("成员内部类的show方法");
//成员内部类可以直接访问外部类的静态变量
System.out.println(name);
//成员内部类可以直接访问外部类的静态方法
test();
//成员内部类可以直接访问外部类的实例成员
System.out.println(age);
}
}
}
public class InnerClassDemo {
public static void main(String[] args){
//目标：理解成员内部类的语法
//成员内部类创建对象的格式
//外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
OuterClass.InnerClass oi = new OuterClass().new InnerClass();
oi.show();
//成员内部类中访问外部类成员的特点：
//1、成员内部类可以直接访问外部类的静态成员，也可以直接访问外部类的实例成员
}
}
[*]静态内部类
[*]有 static 修饰的内部类，属于外部类自己持有。
//外部类
public class OuterClass {
//静态内部类
public static class InnerClass{
}
}// 语法
// 外部类名.内部类名 对象名 = new 外部类.内部类();
OuterClass.InnerClass oi = new OuterClass.InnerClass();//外部类
public class OuterClass {
//外部类静态变量
public static String name = "可乐";
//外部类实例变量
private int age;
//外部类静态方法
public static void test() {
}
//静态内部类，有static修饰，属于外部类持有的。
public static class InnerClass {
public void show() {
System.out.println("静态内部类的show方法");
//静态内部类可以直接访问外部类的静态变量
System.out.println(name);
//静态内部类可以直接访问外部类的静态方法
test();
//静态内部类 不可以 直接访问外部类的实例成员
System.out.println(age); 报错
}
}
}
public class InnerClassDemo {
public static void main(String[] args){
//目标：理解静态内部类的语法
//静态内部类创建对象的格式
//外部类名称.内部类名称 对象名 = new 外部类名称.内部类名称();
OuterClass.InnerClass oi = new OuterClass.InnerClass();
oi.show();
//静态内部类中访问外部类成员的特点：
//1、静态内部类可以直接访问外部类的静态成员，不可以直接访问外部类的实例成员
}
}
[*]局部内部类 （了解）
[*]局部内部类是定义在方法、代码块、构造器等执行体中的内部类。
public class OuterClass {
pulic static void main(String[] args) {
}
public static void go() {
//局部内部类
class A{
}
abstract class B{
}
interface C{
}
}
}
[*]匿名内部类（重点）
[*]一种特殊的局部内部类
[*]所谓匿名：指的是程序员不需要为这个类声明名字，默认有个隐藏的名字。
// 语法
new 类 或 接口(参数值) {
类体(一般是方法重写);
};// 示例
new Animal() {
@override
public void eat() {
}
};
[*]特点：匿名内部类本质是一个子类，并会立即创建出一个子类对象。
[*]作用：用于更方便的创建一个子类对象。
// 父类
public abstract class Animal {
public abstract void cry();
}
// main
public class TestDemo{
pulic static void main(String[] args) {
// 匿名内部类 创建子类对象
// 匿名内部类实际有名字，外部类名$编号.class（TestDemo$1.class）
Animal a = new Animal(){
@override
public void cry(){
System.out.println("cat~");
}
}
a.cry();
}
}
[*]匿名内部类在开发中的常见形式
通常作为一个对象参数传输给方法。
示例：学生、老师参加游泳比赛。
// main
public class TestDemo{
pulic static void main(String[] args) {
// 目标：理解匿名内部类在开发中的使用形式，通常作为一个对象参数传输给方法
// 学生
Swim s1 = new Swim() {
@override
public void swimming(){
System.out.println("学生蛙泳...");
}
};
// 对象回调
start(s1);
// 老师
// 对象参数传输给方法
start(new Swim() {
@Override
public void swimming(){
System.out.println("老师蝶泳...");
}
});
}
pulic static void start(Swim s){
System.out.println("===开始===");
s.swimming();
System.out.println("===结束===");
}
}
interface Swim{
void swimming();
}
[*]匿名内部类在开发中的实际使用场景
使用场景一：
调用别人提供的方法实现需求时，这个方法正好可以让我们传入一个匿名内部类对象作为参数给其使用。
public class TestDemo{
pulic 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 ClickListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("用户点击了登录按钮");
}
});
// 设置显示属性
win.setVisible(true);
}
}使用场景二：
使用comparator接口的匿名内部类实现对数组进行排序
public class TestDemo{
pulic static void main(String[] args) {
Student[] students = new Student;
students = new Student("可乐", 16, 170.3);
students = new Student("雪碧", 13, 159.1);
students = new Student("芬达", 18, 168.4);
// 使用匿名内部类重写Comparator比较器方法，实现根据学生的年龄进行排序
Array.sort(students, new Comparator<Student>() {
@Override
public int compare(student o1, student o2){
return o1.getAge() - o2.getAge();
}
});
System.out.println(Array.toString(students));
}
}
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
页:
[1]