56、Java编程知识综合解析

原创 于 2025-07-15 14:08:53 发布 · 80 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#JavaFX # Java文档注释 # 类与对象

Java编程知识综合解析

1. JavaFX基础

JavaFX是Java的一个重要框架，以下是其一些基础概念：
- 顶级包名 ：JavaFX框架的顶级包名是 javafx 。
- 核心概念类 ：JavaFX中有两个核心概念，舞台（Stage）和场景（Scene），分别由 Stage 类和 Scene 类封装。
- 场景图组成 ：场景图由节点（nodes）组成，所有节点的基类是 Node 。
- 应用程序基类 ：所有JavaFX应用程序都要继承 Application 类。
- 生命周期方法 ：JavaFX有三个生命周期方法，分别是 init() 、 start() 和 stop() 。其中，在 start() 方法中可以构建应用程序的舞台。要启动一个独立的JavaFX应用程序，需要调用 launch() 方法。

2. JavaFX组件与事件处理

JavaFX提供了丰富的组件和强大的事件处理机制。
- 标签和按钮类 ：支持标签和按钮的JavaFX类分别是 Label 和 Button 。
- 终止应用程序 ：可以通过调用 Platform.exit() 方法来终止一个独立的JavaFX应用程序。以下是一个示例代码，展示了如何创建一个包含“Run”和“Exit”按钮的JavaFX应用程序： 

import javafx.application.*;
import javafx.scene.*;
import javafx.stage.*;
import javafx.scene.layout.*;
import javafx.scene.control.*;
import javafx.event.*;
import javafx.geometry.*;

public class JavaFXEventDemo extends Application {

  Label response;

  public static void main(String[] args) {
    launch(args);
  }

  public void start(Stage myStage) {
    myStage.setTitle("Use Platform.exit().");
    FlowPane rootNode = new FlowPane(10, 10);
    rootNode.setAlignment(Pos.CENTER);
    Scene myScene = new Scene(rootNode, 300, 100);
    myStage.setScene(myScene);
    response = new Label("Push a Button");
    Button btnRun = new Button("Run");
    Button btnExit = new Button("Exit");
    btnRun.setOnAction((ae) -> response.setText("You pressed Run."));
    btnExit.setOnAction((ae) -> Platform.exit());
    rootNode.getChildren().addAll(btnRun, btnExit, response);
    myStage.show();
  }
}
  • 复选框 ：JavaFX中实现复选框的控件是 CheckBox 。
  • 列表视图 ： ListView 并非用于显示本地文件系统的文件目录列表，而是用于显示一个可供用户选择的项目列表。
3. JavaFX文件比较程序

可以将基于Swing的文件比较程序转换为JavaFX版本，并利用JavaFX的一个特性：通过调用按钮实例的 fire() 方法，可以在程序控制下触发按钮的动作事件。以下是示例代码： 

import javafx.application.*;
import javafx.scene.*;
import javafx.stage.*;
import javafx.scene.layout.*;
import javafx.scene.control.*;
import javafx.event.*;
import javafx.geometry.*;
import java.io.*;

public class JavaFXFileComp extends Application {

  TextField tfFirst;
  TextField tfSecond;
  Button btnComp;
  Label labFirst, labSecond;
  Label labResult;

  public static void main(String[] args) {
    launch(args);
  }

  public void start(Stage myStage) {
    myStage.setTitle("Compare Files");
    FlowPane rootNode = new FlowPane(10, 10);
    rootNode.setAlignment(Pos.CENTER);
    Scene myScene = new Scene(rootNode, 180, 180);
    myStage.setScene(myScene);
    tfFirst = new TextField();
    tfSecond = new TextField();
    tfFirst.setPrefColumnCount(12);
    tfSecond.setPrefColumnCount(12);
    tfFirst.setPromptText("Enter file name.");
    tfSecond.setPromptText("Enter file name.");
    btnComp = new Button("Compare");
    labFirst = new Label("First file: ");
    labSecond = new Label("Second file: ");
    labResult = new Label("");
    tfFirst.setOnAction( (ae) -> btnComp.fire());
    tfSecond.setOnAction( (ae) -> btnComp.fire());
    btnComp.setOnAction(new EventHandler<ActionEvent>() {
      public void handle(ActionEvent ae) {
        int i=0, j=0;
        if(tfFirst.getText().equals("")) {
          labResult.setText("First file name missing.");
          return;
        }
        if(tfSecond.getText().equals("")) {
          labResult.setText("Second file name missing.");
          return;
        }
        try (FileInputStream f1 = new FileInputStream(tfFirst.getText());
             FileInputStream f2 = new FileInputStream(tfSecond.getText()))
        {
          do {
            i = f1.read();
            j = f2.read();
            if(i != j) break;
          } while(i != -1 && j != -1);
          if(i != j)
            labResult.setText("Files are not the same.");
          else
            labResult.setText("Files compare equal.");
        } catch(IOException exc) {
          labResult.setText("File Error Encountered");
        }
      }
    });
    rootNode.getChildren().addAll(labFirst, tfFirst, labSecond, tfSecond,
                                  btnComp, labResult);
    myStage.show();
  }
}
4. JavaFX效果与转换

可以对JavaFX的按钮添加效果，例如对“Rotate”按钮添加模糊效果。具体步骤如下：
1. 创建 BoxBlur 实例： 

BoxBlur rotateBlur = new BoxBlur(5.0, 5.0, 2);
  1. 将模糊效果应用到按钮上： 
btnRotate.setEffect(rotateBlur);
5. Java文档注释

Java支持三种类型的注释，其中文档注释以 /** 开头，以 */ 结尾。可以使用 javadoc 工具将文档注释中的信息提取出来并生成HTML文件。以下是 javadoc 工具识别的一些标签：
| 标签 | 含义 |
| ---- | ---- |
| @author | 标识作者 |
| {@code} | 以代码字体原样显示信息，不处理HTML样式 |
| @deprecated | 指定程序元素已过时 |
| {@docRoot} | 指定当前文档根目录的路径 |
| @exception | 标识方法或构造函数抛出的异常 |
| {@inheritDoc} | 从直接超类继承注释 |
| {@link} | 插入到另一个主题的内联链接 |
| {@linkplain} | 插入到另一个主题的内联链接，但链接以纯文本字体显示 |
| {@literal} | 原样显示信息，不处理HTML样式 |
| @param | 记录参数 |
| @return | 记录方法的返回值 |
| @see | 指定到另一个主题的引用 |
| @serial | 记录默认可序列化字段 |
| @serialData | 记录 writeObject() 或 writeExternal() 方法写入的数据 |
| @serialField | 记录 ObjectStreamField 组件 |
| @since | 说明特定更改引入的版本 |
| @throws | 与 @exception 相同 |
| {@value} | 显示常量的值，该常量必须是静态字段 |
| @version | 指定类的版本 |

文档注释的一般形式如下：在 /** 之后，第一行或多行成为类、接口、字段、构造函数或方法的主要描述。之后可以包含一个或多个 @ 标签，每个 @ 标签必须从新行的开头开始或跟在一行开头的一个或多个星号 * 之后。相同类型的多个标签应分组在一起。内联标签（以花括号开头的标签）可以在任何描述中使用。以下是一个类的文档注释示例： 

/**
 * This class draws a bar chart.
 * @author Herbert Schildt
 * @version 3.2
*/
6. 示例程序

以下是一个使用文档注释的示例程序： 

import java.io.*;

/**
 * This class demonstrates documentation comments.
 * @author Herbert Schildt
 * @version 1.2
*/
public class SquareNum {
  /**
   * This method returns the square of num.
   * This is a multiline description. You can use
   * as many lines as you like.
   * @param num The value to be squared.
   * @return num squared.
  */
  public double square(double num) {
    return num * num;
  }

  /**
   * This method inputs a number from the user.
   * @return The value input as a double.
   * @exception IOException On input error.
   * @see IOException
  */
  public double getNumber() throws IOException {
    InputStreamReader isr = new InputStreamReader(System.in);
    BufferedReader inData = new BufferedReader(isr);
    String str;
    str = inData.readLine();
    return (new Double(str)).doubleValue();
  }

  /**
   * This method demonstrates square().
   * @param args Unused.
   * @exception IOException On input error.
   * @see IOException
  */
  public static void main(String args[])
    throws IOException
  {
    SquareNum ob = new SquareNum();
    double val;
    System.out.println("Enter value to be squared: ");
    val = ob.getNumber();
    val = ob.square(val);
    System.out.println("Squared value is " + val);
  }
}
7. 代码执行流程

以下是上述 SquareNum 类程序的执行流程： 

graph TD;
    A[开始] --> B[提示用户输入要平方的值];
    B --> C[调用getNumber()方法获取用户输入];
    C --> D[调用square()方法计算平方值];
    D --> E[输出平方值];
    E --> F[结束];

通过以上内容，我们对JavaFX的基础概念、组件使用、事件处理、效果添加以及Java文档注释等方面有了较为全面的了解。这些知识对于开发Java应用程序，尤其是具有图形用户界面的应用程序非常有帮助。同时，合理使用文档注释可以提高代码的可读性和可维护性。

8. Java运算符与关键字

Java中有丰富的运算符和关键字，以下是一些重要的运算符和关键字介绍：
- 运算符 ：
| 运算符 | 说明 |
| ---- | ---- |
| & | 位与、布尔逻辑与 |
| && | 短路与 |
| * | 乘法运算符，也用于 import 语句 |
| @ | 注解语法 |
| \| | 位或、布尔逻辑或 |
| \|\| | 短路或 |
| ^ | 位异或、布尔逻辑异或 |
| : | 用于 for-each 循环等 |
| :: | 构造函数引用语法、方法引用语法 |
| = | 赋值运算符 |
| == | 关系运算符，与 equals() 方法有区别 |
| ! | 布尔逻辑非 |
| != | 不等关系运算符 |
| / | 除法运算符 |
| << 、 >> 、 >>> | 位左移、右移、无符号右移 |
| < 、 <= 、 > 、 >= | 关系运算符 |
| - | 减法运算符 |
| -- | 自减运算符 |
| % | 取模运算符 |
| + | 加法运算符、字符串连接运算符 |
| ++ | 自增运算符 |
| ? | 三元运算符 |
| ~ | 位非运算符 |
| _ | 用于整数或浮点型字面量 |
- 关键字 ：Java有一系列关键字，如 abstract 、 class 、 interface 等，这些关键字在Java编程中有特定的用途。

9. 类与对象

在Java中，类和对象是重要的概念：
- 类的定义 ：类是对象的抽象描述，使用 class 关键字定义。例如： 

public class MyClass {
    // 类的成员变量
    private int num;

    // 构造函数
    public MyClass(int num) {
        this.num = num;
    }

    // 成员方法
    public int getNum() {
        return num;
    }
}
  • 对象的创建与使用 ：使用 new 关键字创建对象，通过对象调用类的成员方法和成员变量。 
MyClass obj = new MyClass(10);
int value = obj.getNum();
10. 继承与多态

继承和多态是Java面向对象编程的重要特性：
- 继承 ：一个类可以继承另一个类的属性和方法，使用 extends 关键字。例如： 

class Parent {
    public void print() {
        System.out.println("Parent method");
    }
}

class Child extends Parent {
    @Override
    public void print() {
        System.out.println("Child method");
    }
}
  • 多态 ：多态允许不同类的对象对同一消息作出不同的响应。通过父类引用指向子类对象实现多态。 
Parent p = new Child();
p.print(); // 调用子类的print方法
11. 接口与抽象类

接口和抽象类在Java中也有重要作用：
- 接口 ：接口是一种抽象类型，使用 interface 关键字定义，接口中的方法默认是抽象方法。例如： 

interface MyInterface {
    void method();
}

class MyClass implements MyInterface {
    @Override
    public void method() {
        System.out.println("Implementing interface method");
    }
}
  • 抽象类 ：抽象类使用 abstract 关键字定义，抽象类中可以有抽象方法和非抽象方法。 
abstract class AbstractClass {
    abstract void abstractMethod();
    void normalMethod() {
        System.out.println("Normal method in abstract class");
    }
}

class ConcreteClass extends AbstractClass {
    @Override
    void abstractMethod() {
        System.out.println("Implementing abstract method");
    }
}
12. 异常处理

Java的异常处理机制可以帮助我们处理程序运行时的错误：
- 异常类 ：Java中有许多异常类，如 ArithmeticException 、 ArrayIndexOutOfBoundsException 等。
- 异常处理语句 ：使用 try-catch-finally 语句处理异常。例如： 

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("ArithmeticException caught: " + e.getMessage());
} finally {
    System.out.println("Finally block executed");
}
  • 抛出异常 ：使用 throw 关键字抛出异常，使用 throws 关键字声明方法可能抛出的异常。 
public void myMethod() throws Exception {
    throw new Exception("Custom exception");
}
13. 多线程编程

多线程编程可以提高程序的性能和响应性：
- 线程的创建 ：可以通过继承 Thread 类或实现 Runnable 接口创建线程。 

// 继承Thread类
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }
}

// 实现Runnable接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable is running");
    }
}

// 使用示例
MyThread thread = new MyThread();
thread.start();

Thread runnableThread = new Thread(new MyRunnable());
runnableThread.start();
  • 线程同步 ：使用 synchronized 关键字实现线程同步，避免多个线程同时访问共享资源。 
class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }
}
14. 集合框架

Java的集合框架提供了一系列用于存储和操作数据的类和接口：
- 常用集合类 ：如 ArrayList 、 LinkedList 、 HashMap 等。 

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// ArrayList示例
List<String> list = new ArrayList<>();
list.add("item1");
list.add("item2");

// HashMap示例
Map<String, Integer> map = new HashMap<>();
map.put("key1", 1);
map.put("key2", 2);
  • 集合的遍历 ：可以使用 for-each 循环或迭代器遍历集合。 
// 遍历List
for (String item : list) {
    System.out.println(item);
}

// 遍历Map
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}
15. 程序执行流程总结

以下是一个包含类、对象、异常处理、多线程等操作的程序执行流程： 

graph TD;
    A[开始] --> B[定义类和对象];
    B --> C[调用方法，可能抛出异常];
    C --> D{是否捕获到异常};
    D -- 是 --> E[处理异常];
    D -- 否 --> F[继续执行正常流程];
    F --> G{是否需要多线程操作};
    G -- 是 --> H[创建并启动线程];
    G -- 否 --> I[结束单线程操作];
    H --> J[线程执行任务];
    J --> K[线程结束];
    E --> L[继续后续操作];
    I --> L;
    K --> L;
    L --> M[结束程序];

通过对Java运算符、类与对象、继承与多态、接口与抽象类、异常处理、多线程编程和集合框架等知识的学习，我们可以更全面地掌握Java编程，开发出功能强大、性能优良的Java应用程序。同时，合理运用这些知识可以提高代码的质量和可维护性。

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值