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

java的几种布局及其特点

在 Java 中，布局管理器（Layout Manager）用于确定组件在容器中的排列方式。Java 提供了多种布局管理器，每种都有不同的排列方式，适用于不同的界面布局需求。以下是几种常见的布局管理器及其特点：

1. FlowLayout（流式布局）:

   • 特点：按照添加组件的顺序，从左到右、从上到下排列。
   • 适用：适合简单的流式布局，组件按照添加的顺序依次排列。

2. BorderLayout（边界布局）:

   • 特点：将容器分为北、南、东、西、中五个区域，每个区域只能包含一个组件。
   • 适用：适合简单的边界布局，通常用于整个界面的基本布局。

3. GridLayout（网格布局）:

   • 特点：将容器划分为行和列的网格，每个单元格可以包含一个组件。
   • 适用：适合需要按照网格方式排列组件的情况，尤其适用于按钮、文本框等控件的网格布局。

4. BoxLayout（盒状布局）:

   • 特点：可以在水平或垂直方向上排列组件。
   • 适用：适合需要沿着单一方向排列组件的情况，可以实现水平或垂直的盒状布局。

5. CardLayout（卡片布局）:

   • 特点：一次只能显示容器中的一个组件，通过卡片的方式切换显示。
   • 适用：适合需要在同一个位置显示不同组件的情况，常用于实现选项卡式的界面。

6. GridBagLayout（网格袋布局）:

   • 特点：提供了高度灵活性的网格布局，可以更精确地控制组件的位置和大小。
   • 适用：适合需要复杂布局的情况，可以灵活地定位和控制组件。

生动形象的解释

1. FlowLayout（流式布局）：

   • 解释： 想象一条小河，你往水里放了一堆小船，它们会按照你放入的顺序自然地流动。
   • 例子： 假设你有几个按钮，每按一个按钮，它就像一只小船一样被放进河里，它们会从左到右、从上到下依次排列。

2. BorderLayout（边界布局）：

   • 解释： 想象你家的房间是一个大方框，有东南西北四个方向。你可以在东边放个书架，在南边放个电视，每个方向只能放一个东西。
   • 例子： 如果你在东边放了一张图片，然后在西边放了一段文字，它们会分别出现在界面的东边和西边。

3. GridLayout（网格布局）：

   • 解释： 想象你家的墙上是一个大大的九宫格，你可以往每个格子里放东西，就像是一个小格子放一个物品。
   • 例子： 如果你有一组按钮，你可以把它们按照网格布局放在你家的墙上，每个按钮占用一个格子。

4. BoxLayout（盒状布局）：

   • 解释： 想象你家的房子里有一根长长的线，你可以把家具沿着这条线摆放，要么是一排横着的，要么是一排竖着的。
   • 例子： 如果你有一些标签和按钮，你可以选择把它们横着排列，或者竖着排列，就像是把它们放在一根线上。

5. CardLayout（卡片布局）：

   • 解释： 想象你有一叠卡片，每张卡片上有不同的画面。你可以一次只看到一张卡片，其他的被叠在下面。
   • 例子： 如果你有一组面板，每个面板上有不同的信息，你可以使用卡片布局，每次只显示一个面板，就像翻卡片一样。

组件与容器

组件（Component）：

• 解释： 在图形用户界面（GUI）中，组件是构成用户界面的基本元素。它可以是可见的，比如按钮、文本框、标签等，也可以是不可见的，比如事件监听器。组件通常用于显示信息、接收用户输入或执行某些操作。

• 详细解释： 组件是用户界面的砖瓦，是构建整个界面的基础。想象你打开一个应用程序，看到的按钮、输入框、文本标签等，它们都是组件。每个组件都有自己的功能和特点，比如按钮可以被点击执行某个操作，文本框可以输入文字，标签用于显示信息等。

容器（Container）：

• 解释： 容器是用来包含和管理组件的框架或区域。容器可以包含其他组件和容器，形成嵌套的层次结构。容器用于组织和布局组件，使得用户界面看起来有条理、整齐。

• 详细解释： 容器就像是一个盒子或框架，用于存放组件。它可以是窗口、面板或其他特定的容器类。在一个容器中，你可以放置按钮、文本框、标签等组件，也可以放置其他容器，形成层次结构。通过合理的组织和布局，容器能够使界面更加清晰、有序。

组件与容器的关系：

• 组件和容器之间存在一种包含关系。容器可以包含一个或多个组件，也可以包含其他容器。通过这种包含关系，可以构建出复杂的用户界面。

• 例子： 想象你在设计一个简单的登录界面。界面本身就是一个容器，容器内部包含用户名输入框（文本框组件）、密码输入框（文本框组件）、登录按钮（按钮组件）等。这些组件放置在容器中，容器负责管理它们的位置和布局，最终呈现给用户一个整洁的登录界面。

定义线程要执行的任务对象，应该实现哪个接口

线程

线程（Thread）是计算机科学中的一个概念，是操作系统能够进行运算调度的最小单位。在更为具体的层面上，线程是进程的一部分，是进程内的一个执行流，是 CPU 调度和分派的基本单位。

以下是线程的一些关键特点：

1. 轻量性： 线程相比于进程更为轻量，占用的资源较少，更容易创建和销毁。一个进程可以包含多个线程。

2. 并发执行： 多个线程可以在同一时刻执行不同的任务，使得程序具有并发性，提高系统的整体性能。

3. 共享内存： 线程间可以共享相同的内存空间，这使得它们能够更方便地共享数据。

4. 独立性： 线程有自己的执行环境，包括程序计数器、寄存器和栈。它们在执行过程中是独立的。

5. 并行性： 在多核处理器上，多个线程可以同时执行，实现真正的并行计算。

在编程中，线程通常用于执行一段独立的代码，比如执行一项任务或者响应用户输入。在 Java 中，线程是通过继承 Thread 类或实现 Runnable 接口来创建的。

public class MyThread extends Thread {
    @Override
    public void run() {
        // 线程要执行的任务
        System.out.println("MyThread is running.");
    }

    public static void main(String[] args) {
        // 创建并启动线程
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

Runnable接口

在 Java 中，要定义线程要执行的任务对象，通常需要实现 Runnable 接口。这是因为 Runnable 接口中定义了一个用于执行线程任务的方法 run()。

接口定义如下：

public interface Runnable {
    void run();
}

如果你的类实现了 Runnable 接口，就必须提供 run() 方法的具体实现。当线程启动时，它会调用 run() 方法执行线程的任务。

例如：

public class MyTask implements Runnable {
    @Override
    public void run() {
        // 在这里定义线程要执行的任务
        System.out.println("Thread task is running.");
    }

    public static void main(String[] args) {
        // 创建线程任务对象
        MyTask myTask = new MyTask();

        // 创建线程，并传入任务对象
        Thread thread = new Thread(myTask);

        // 启动线程
        thread.start();
    }
}

另外，也可以通过继承 Thread 类的方式来定义线程，但推荐使用 Runnable 接口，因为它更灵活，一个类可以实现多个接口，而继承只能单一。

定义同步的方法应该使用关键字 synchronized

在Java中，当一个方法需要确保在同一时间只能被一个线程执行时，可以使用关键字 synchronized 来定义同步方法。synchronized 关键字用于确保在同一时刻只有一个线程可以访问被标记为 synchronized 的方法或代码块。

使用 synchronized 关键字的一般形式是：

public synchronized void mySynchronizedMethod() {
    // 方法体，需要同步的代码
}

在上述代码中，mySynchronizedMethod 方法被标记为 synchronized，这表示只有一个线程能够同时执行该方法。当一个线程进入这个方法时，其他线程将被阻塞，直到当前线程执行完毕释放锁。

比喻： 假设有一扇只能容纳一个人的小门，这扇门通往一个房间，而这个房间里有一份工作，我们希望每次只有一个人能够进去做这份工作。这个小门就相当于一个被 synchronized 修饰的方法，确保一次只有一个线程可以执行这个方法。

• 当一个线程来敲这扇门（调用 doWork 方法）时，它首先检查门是不是开着的。
• 如果门是关着的，这个线程就进去并锁上门，然后独自完成工作。
• 如果另一个线程也来敲门，但看到门是锁着的，它就等在门外，直到第一个线程完成工作、开了门，然后第二个线程进去锁上门，以此类推。

这样，通过 synchronized，我们就确保了每次只有一个线程可以进入方法执行任务，避免了多个线程同时对共享资源进行修改而引发的问题，就像是只允许一个人进入房间做工作，避免了混乱和冲突。

实现多线程一般使用哪两种方法

继承 Thread 类：

• 创建一个新的类，继承自 Thread 类。
• 重写 Thread 类的 run() 方法，该方法包含了线程的执行代码。
• 创建类的实例，然后调用 start() 方法启动线程。
• 注意，直接调用 run() 方法并不会启动新线程，而是在当前线程中执行 run() 方法的内容。要启动新线程，必须调用 start() 方法。
• 这是一种简单的创建线程的方式，但由于Java是单继承的，所以该方法限制了类的扩展性。

  public class MyThread extends Thread {
      public void run() {
          // 线程要执行的任务
          System.out.println("MyThread is running.");
      }
  
      public static void main(String[] args) {
          // 创建并启动线程
          MyThread myThread = new MyThread();
          myThread.start();
      }
  }
  

  实现 Runnable 接口：

• 创建一个新的类，实现 Runnable 接口。
• 实现 Runnable 接口中的 run() 方法，该方法包含了线程的执行代码。
• 创建 Runnable 实例，并将其作为参数传递给 Thread 类的构造方法。
• 创建 Thread 实例，然后调用 start() 方法启动线程。
• 这种方式避免了单继承的限制，因为一个类可以同时实现多个接口。

  public class MyRunnable implements Runnable {
      public void run() {
          // 线程要执行的任务
          System.out.println("MyRunnable is running.");
      }
  
      public static void main(String[] args) {
          // 创建Runnable实例
          MyRunnable myRunnable = new MyRunnable();
  
          // 创建并启动线程
          Thread thread = new Thread(myRunnable);
          thread.start();
      }
  }