JMU----数科 java期末知识点民间总结（3）

最新推荐文章于 2024-05-21 22:13:42 发布

X_StarX

最新推荐文章于 2024-05-21 22:13:42 发布

阅读量792

点赞数 25

文章标签： java 开发语言

本文链接：https://blog.csdn.net/X_StarX/article/details/135175061

版权

对象赋值、对象克隆

1. 对象赋值：

对象赋值实际上是让一个对象引用指向另一个对象。这并不会创建新的对象，而是让一个变量引用另一个对象的内存地址。因此，两个引用指向的是同一个对象。示例代码如下：

public class MyClass {
    int value;

    public MyClass(int value) {
        this.value = value;
    }

    public static void main(String[] args) {
        MyClass obj1 = new MyClass(10);
        MyClass obj2 = obj1; // 对象赋值

        System.out.println(obj1.value); // 输出 10
        System.out.println(obj2.value); // 输出 10

        obj2.value = 20; // 修改通过 obj2 访问的对象的值

        System.out.println(obj1.value); // 输出 20，因为 obj1 和 obj2 引用同一个对象
        System.out.println(obj2.value); // 输出 20
    }
}

2. 对象克隆：

对象克隆是创建一个新的对象，该对象的值和原始对象相同，但它在内存中拥有不同的地址。Java中的克隆通常通过实现 Cloneable 接口并重写 clone() 方法来实现。示例代码如下：

public class MyClass implements Cloneable {
    int value;

    public MyClass(int value) {
        this.value = value;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone(); // 调用父类的 clone 方法
    }

    public static void main(String[] args) {
        MyClass obj1 = new MyClass(10);

        try {
            MyClass obj2 = (MyClass) obj1.clone(); // 对象克隆

            System.out.println(obj1.value); // 输出 10
            System.out.println(obj2.value); // 输出 10

            obj2.value = 20; // 修改通过 obj2 访问的对象的值

            System.out.println(obj1.value); // 输出 10，obj1 和 obj2 引用不同的对象
            System.out.println(obj2.value); // 输出 20
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

比喻

1. 对象赋值：

比喻： 想象你和你的朋友一起去购物，你们俩看中了同一双鞋子。你们决定一人买一只，然后共享穿。这样，虽然是同一双鞋子，但是两人共用。

2. 对象克隆：

比喻： 现在，你和你的朋友又看中了同一双鞋子，但这次你们决定各自买一双。这样，虽然是同一双鞋子，但是你们各自有一双独立的。

异常处理机制

异常是什么？

比喻： 想象你在学校考试，突然碰到一道难题，不知道怎么做了。这时候，你会怎么办呢？有两种选择，一是向老师请教，二是放弃，不理这道题。

在Java中，当程序运行过程中遇到问题（比如除零、数组越界等），就会抛出一个异常。异常就像是一道考试中的难题，Java程序可以选择处理这个异常，也可以不理会。

异常处理机制：

在Java中，我们可以使用 try、catch 和 finally 来处理异常。

1. try： 就像你尝试解决一道考试难题一样，使用 try 块包裹可能引发异常的代码。

2. catch： 就像你向老师请教一样，使用 catch 块来捕获并处理异常，提供解决问题的方案。

3. finally： 不管怎样，最终总会有个结局。使用 finally 块来放置一些无论异常是否发生都需要执行的代码，比如资源释放。

public class Exam {
    public static void main(String[] args) {
        try {
            // 尝试解决问题的代码
            int result = divide(10, 0);
            System.out.println("Result: " + result); // 这行代码不会执行
        } catch (ArithmeticException e) {
            // 捕获并处理异常
            System.out.println("Exception caught: " + e.getMessage());
        } finally {
            // 无论异常是否发生，都会执行的代码
            System.out.println("Finally block executed.");
        }
    }

    // 尝试解决问题的方法
    static int divide(int a, int b) {
        return a / b; // 这里有可能会抛出ArithmeticException异常
    }
}

类要具备什么条件才可以序列化

类的序列化是指将一个对象转换成字节序列的过程，以便于在网络上传输或者将对象保存到文件中。在Java中，实现序列化的过程是通过实现 Serializable 接口来实现的。通过序列化，对象的状态信息可以被保存下来，以便在需要的时候进行还原（反序列化）。

在Java中，为了使一个类可以被序列化，即可以通过对象序列化机制将其转换为字节流，需要满足以下条件：

实现 Serializable 接口： 类必须实现 java.io.Serializable 接口。这个接口是一个标记接口，不包含任何方法，它只是用来表明类的对象是可序列化的。

import java.io.Serializable;

public class MyClass implements Serializable {
    // 类的定义
}

所有成员变量也可序列化： 类的所有成员变量（字段）都应该是可序列化的。如果一个类的成员变量是某个不可序列化类的对象，那么该类也必须实现 Serializable 接口。

import java.io.Serializable;

public class Person implements Serializable {
    // 可序列化的成员变量
    private String name;
    private int age;

    // 构造方法等其他代码
}

如果成员变量是 transient（瞬时的），它将不参与序列化。

import java.io.Serializable;

public class Person implements Serializable {
    // 可序列化的成员变量
    private String name;
    private transient int age; // 使用 transient 声明的变量不会被序列化

    // 构造方法等其他代码
}

文件字节输入、输出流

文件字节输入流 - FileInputStream：

FileInputStream 用于从文件中读取字节流。以下是一个简单的例子：

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("example.txt")) {
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data); // 将读取到的字节转换成字符并打印
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这个例子中，通过 FileInputStream 打开一个名为 "example.txt" 的文件，并使用 read() 方法逐字节读取文件内容，直到文件结束（read() 返回 -1）。

文件字节输出流 - FileOutputStream：

FileOutputStream 用于向文件中写入字节流。以下是一个简单的例子：

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputExample {
    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("output.txt")) {
            String data = "Hello, File Output Stream!";
            byte[] bytes = data.getBytes(); // 将字符串转换为字节数组
            fos.write(bytes); // 将字节数组写入文件
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这个例子中，通过 FileOutputStream 创建一个名为 "output.txt" 的文件，并使用 write() 方法将字符串转换为字节数组，并将字节数组写入文件。

文件字符输入、输出流

文件字符输入流 - FileReader：

FileReader 用于从文件中读取字符流。以下是一个简单的例子：

import java.io.FileReader;
import java.io.IOException;

public class FileCharInputExample {
    public static void main(String[] args) {
        try (FileReader reader = new FileReader("example.txt")) {
            int data;
            while ((data = reader.read()) != -1) {
                System.out.print((char) data); // 将读取到的字符打印
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，通过 FileReader 打开一个名为 "example.txt" 的文件，并使用 read() 方法逐字符读取文件内容，直到文件结束。

文件字符输出流 - FileWriter：

FileWriter 用于向文件中写入字符流。以下是一个简单的例子：

import java.io.FileWriter;
import java.io.IOException;

public class FileCharOutputExample {
    public static void main(String[] args) {
        try (FileWriter writer = new FileWriter("output.txt")) {
            String data = "Hello, File Char Output Stream!";
            writer.write(data); // 将字符串写入文件
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，通过 FileWriter 创建一个名为 "output.txt" 的文件，并使用 write() 方法将字符串写入文件。

throw和throws的区别

1. `throw`：

throw 用于在代码块中显式地抛出一个异常。它后面通常紧跟着一个异常对象。使用 throw 关键字，可以在程序中手动抛出异常，使得程序进入异常处理流程。

public void exampleMethod() {
    if (someCondition) {
        throw new SomeException("This is an example exception");
    }
}

在上述例子中，如果 someCondition 的值为 true，那么就会抛出一个 SomeException 异常。

2. `throws`：

throws 用于在方法声明中指定该方法可能抛出的异常类型。它告诉调用者可能会发生的异常，调用者在使用该方法时需要进行相应的异常处理。

public void exampleMethod() throws SomeException {
    // 方法体
}

在上述例子中，exampleMethod 方法声明可能抛出 SomeException 异常。调用该方法的代码需要考虑到可能的异常情况，可以使用 try-catch 块捕获异常，或者将异常继续传递（继续声明 throws）。

区别：

throw 是一个关键字，用于在代码块中抛出指定的异常对象。
throws 是一个关键字，用于在方法声明中指定该方法可能抛出的异常类型，它告诉调用者需要注意处理这些可能的异常。

`throw`：

比喻： 想象你在玩一个接力赛跑游戏，每个人都要把接力棒传递给下一个人。突然间，有个队员摔倒了，这时候你会把接力棒扔给救护员，告诉他有人受伤了。在这个例子中，你就像使用 throw，把问题（队员受伤的异常情况）扔给了救护员。

`throws`：

比喻： 假设你是一位舞蹈老师，你规定了一套很炫的舞蹈动作。你告诉学生们：“大家注意，这里有一些特别难的动作，可能会摔倒，大家小心一点。”这就像使用 throws，你在方法上声明可能发生的异常，让学生们知道需要小心处理。

java Swing的事件处理模式

Swing 是 Java 中用于构建图形用户界面（GUI）的一套库，而事件处理是 Swing 中一个重要的概念。Swing 使用观察者模式来处理事件，主要涉及以下几个部分：

事件源（Event Source）： 事件源是产生事件的组件，比如按钮、文本框等。在 Swing 中，所有的组件都可以充当事件源。
事件监听器（Event Listener）： 事件监听器是一个接口，包含用于处理特定类型事件的方法。在 Java 中，Swing 提供了许多预定义的事件监听器接口，比如 ActionListener、MouseListener、KeyListener 等。
注册监听器（Register Listener）： 在 Swing 中，通过调用组件的 addXxxListener 方法，将特定类型的事件监听器注册到事件源上。这样，事件源就知道在发生相应事件时通知哪个监听器。
事件对象（Event Object）： 当事件源发生特定类型的事件时，会创建一个事件对象。该事件对象包含了事件的相关信息，比如鼠标点击的坐标、按下的键等。
事件处理器（Event Handler）： 事件处理器是实现了事件监听器接口的类，它负责具体处理事件的逻辑。当事件源触发事件时，事件处理器中相应的方法会被调用。

以下是一个简单的 Swing 事件处理模式的例子，假设有一个按钮，点击按钮时触发一个事件：

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class SwingEventExample {
    public static void main(String[] args) {
        // 创建一个 JFrame
        JFrame frame = new JFrame("Swing Event Example");

        // 创建一个按钮
        JButton button = new JButton("Click Me");

        // 注册 ActionListener 到按钮
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 处理按钮点击事件的逻辑
                System.out.println("Button Clicked!");
            }
        });

        // 将按钮添加到 JFrame
        frame.getContentPane().add(button);

        // 设置 JFrame 的一些属性
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

在这个例子中，按钮是事件源，通过调用 addActionListener 方法将一个实现了 ActionListener 接口的匿名内部类注册为事件监听器。当按钮被点击时，事件处理器中的 actionPerformed 方法会被调用，输出 "Button Clicked!"。

Swing 中常见的事件及其对应的监听器接口

ActionEvent - ActionListener：

事件说明： 通常与用户交互有关的动作事件，比如按钮被点击、菜单项被选择等。

监听器接口： ActionListener。

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class MyActionListener implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        // 处理动作事件的逻辑
    }
}

MouseEvent - MouseListener 和 MouseMotionListener：

事件说明： 鼠标事件，包括点击、释放、进入、退出、拖动等。

监听器接口： MouseListener 和 MouseMotionListener。

import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

public class MyMouseListener implements MouseListener {
    @Override
    public void mouseClicked(MouseEvent e) {
        // 处理鼠标点击事件的逻辑
    }

    // 其他 MouseListener 接口方法
}

KeyEvent - KeyListener：

事件说明： 键盘事件，包括按下、释放、敲击等。

监听器接口： KeyListener。

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

public class MyKeyListener implements KeyListener {
    @Override
    public void keyTyped(KeyEvent e) {
        // 处理键盘敲击事件的逻辑
    }

    // 其他 KeyListener 接口方法
}

ItemEvent - ItemListener：

事件说明： 与组件选择有关的事件，比如复选框被选中、下拉框选择了某一项等。

监听器接口： ItemListener。

import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

public class MyItemListener implements ItemListener {
    @Override
    public void itemStateChanged(ItemEvent e) {
        // 处理组件选择事件的逻辑
    }
}