JAVA代码案例6.11
创建一个抽象类Number，包含一个抽象方法display()，然后创建两个子类Integer和Double，分别实现display()方法来打印整数和浮点数。
以下是一个示例的Java程序，定义了抽象类 `Number`，并从 `Number` 类派生出两个子类 `Integer` 和 `Double`，分别实现了 `display()` 方法来打印整数和浮点数：
```java
abstract class Number {
abstract void display();
}
class IntegerNumber extends Number {
private int value;
public IntegerNumber(int value) {
this.value = value;
}
@Override
void display() {
System.out.println("Integer Number: " + value);
}
}
class DoubleNumber extends Number {
private double value;
public DoubleNumber(double value) {
this.value = value;
}
@Override
void display() {
System.out.println("Double Number: " + value);
}
}
public class Main {
public static void main(String[] args) {
IntegerNumber integerNumber = new IntegerNumber(10);
integerNumber.display();
DoubleNumber doubleNumber = new DoubleNumber(3.14);
doubleNumber.display();
}
}
```
在上述程序中，`Number` 是一个抽象类，包含了一个抽象方法 `display()`。`IntegerNumber` 类和 `DoubleNumber` 类都继承自 `Number` 类，并实现了各自的 `display()` 方法来打印整数和浮点数。
在 `Main` 类中，创建了一个 `IntegerNumber` 对象 `integerNumber`，并调用其 `display()` 方法来打印整数。然后，创建了一个 `DoubleNumber` 对象 `doubleNumber`，并调用其 `display()` 方法来打印浮点数。
运行这个程序将输出以下结果：
```
Integer Number: 10
Double Number: 3.14
```
这些结果是根据对象的类型和属性值打印得到的。
创建一个日期格式化工具类DateFormatter，包含一个静态方法formatDate()，接受一个LocalDateTime对象和一个格式字符串作为参数，并返回格式化后的日期字符串。
以下是一个示例的Java程序，定义了一个日期格式化工具类 `DateFormatter`，其中包含一个静态方法 `formatDate()`，用于接受一个 `LocalDateTime` 对象和一个格式字符串作为参数，并返回格式化后的日期字符串：
```java
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class DateFormatter {
public static String formatDate(LocalDateTime dateTime, String format) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
return dateTime.format(formatter);
}
public static void main(String[] args) {
LocalDateTime now = LocalDateTime.now();
String formattedDate = DateFormatter.formatDate(now, "yyyy-MM-dd HH:mm:ss");
System.out.println("Formatted Date: " + formattedDate);
}
}
```
在上述程序中，`DateFormatter` 类包含了一个静态方法 `formatDate()`。该方法接受一个 `LocalDateTime` 对象和一个格式字符串作为参数，并使用 `DateTimeFormatter` 类来进行日期格式化操作。最后，返回格式化后的日期字符串。
在 `main` 方法中，我们使用 `LocalDateTime.now()` 获取当前日期和时间。然后，调用 `DateFormatter.formatDate()` 方法，将当前日期和时间对象以及所需的日期格式字符串作为参数传递。最后，将格式化后的日期字符串打印到控制台。
运行这个程序将输出类似以下结果：
```
Formatted Date: 2023-06-11 15:30:45
```
这个结果是根据当前的日期和时间以及给定的日期格式字符串进行格式化得到的。请注意，实际的日期和时间将根据运行程序的时间而有所不同。
创建一个类StringUtils，包含一个静态方法reverseWords()，接受一个字符串作为参数，然后将其中的单词进行反转，并返回结果。
以下是一个示例的Java程序，定义了一个字符串工具类 `StringUtils`，其中包含一个静态方法 `reverseWords()`，用于接受一个字符串作为参数，并将其中的单词进行反转，并返回结果：
```java
public class StringUtils {
public static String reverseWords(String input) {
if (input == null || input.isEmpty()) {
return input;
}
String[] words = input.split(" ");
StringBuilder reversed = new StringBuilder();
for (int i = words.length - 1; i >= 0; i--) {
reversed.append(words[i]);
if (i > 0) {
reversed.append(" ");
}
}
return reversed.toString();
}
public static void main(String[] args) {
String input = "Hello World! Welcome to Java";
String reversedWords = StringUtils.reverseWords(input);
System.out.println("Reversed Words: " + reversedWords);
}
}
```
在上述程序中，`StringUtils` 类包含了一个静态方法 `reverseWords()`。该方法接受一个字符串作为参数，并通过使用空格进行分割，将其中的单词存储在一个字符串数组中。然后，使用一个循环从后往前遍历单词数组，并将每个单词追加到一个 `StringBuilder` 对象中，同时在单词之间添加空格。最后，将 `StringBuilder` 对象转换为字符串并返回。
在 `main` 方法中，我们定义了一个输入字符串 `input`，并调用 `StringUtils.reverseWords()` 方法来反转其中的单词。然后，将反转后的结果打印到控制台。
运行这个程序将输出类似以下结果：
```
Reversed Words: Java to Welcome World! Hello
```
这个结果是根据给定的输入字符串中的单词进行反转得到的。
创建一个类MathUtil，包含静态方法getMax()和getMin()，分别接受两个整数参数，并返回它们的最大值和最小值。
以下是一个示例的Java程序，定义了类 `MathUtil`，其中包含静态方法 `getMax()` 和 `getMin()`，用于获取两个整数参数的最大值和最小值：
```java
public class MathUtil {
public static int getMax(int num1, int num2) {
return Math.max(num1, num2);
}
public static int getMin(int num1, int num2) {
return Math.min(num1, num2);
}
public static void main(String[] args) {
int a = 10;
int b = 5;
int max = MathUtil.getMax(a, b);
int min = MathUtil.getMin(a, b);
System.out.println("Max: " + max);
System.out.println("Min: " + min);
}
}
```
在上述程序中，`MathUtil` 类包含了静态方法 `getMax()` 和 `getMin()`。这些方法使用了Java的 `Math` 类中提供的 `max()` 和 `min()` 方法来计算两个整数的最大值和最小值。
在 `main` 方法中，我们定义了两个整数变量 `a` 和 `b`，并使用 `MathUtil` 类的静态方法 `getMax()` 和 `getMin()` 来获取它们的最大值和最小值。然后，我们将这些值打印到控制台。
运行这个程序将输出以下结果：
```
Max: 10
Min: 5
```
这些结果是根据给定的整数变量 `a` 和 `b` 计算得出的最大值和最小值。
编写一个程序，演示Java的垃圾回收机制，创建多个对象并在适当的时候将其设置为null，然后手动调用垃圾回收。
在Java中，垃圾回收是由Java虚拟机（JVM）自动处理的，开发人员无法精确控制垃圾回收的具体时机。但是，我们可以通过将对象设置为null来提示JVM可以回收它们。虽然手动调用垃圾回收不是必需的，但可以通过调用`System.gc()`方法来请求JVM运行垃圾回收。
下面是一个示例程序，演示了创建多个对象，并在适当的时候将其设置为null，然后手动调用垃圾回收：
```java
public class GarbageCollectionDemo {
public static void main(String[] args) {
// 创建多个对象
Object obj1 = new Object();
Object obj2 = new Object();
Object obj3 = new Object();
// 打印对象的哈希码
System.out.println("Object 1: " + obj1);
System.out.println("Object 2: " + obj2);
System.out.println("Object 3: " + obj3);
// 将对象设置为null
obj1 = null;
obj2 = null;
// 手动调用垃圾回收
System.gc();
// 等待一段时间以便垃圾回收完成
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 打印对象的哈希码，如果对象被成功回收，则输出为null
System.out.println("Object 1 after garbage collection: " + obj1);
System.out.println("Object 2 after garbage collection: " + obj2);
System.out.println("Object 3: " + obj3);
}
}
```
在上述程序中，创建了三个对象 `obj1`、`obj2` 和 `obj3`。然后，通过打印对象的哈希码来验证对象的存在。
接下来，将 `obj1` 和 `obj2` 设置为null，表示不再引用这些对象。然后，通过调用 `System.gc()` 来请求JVM运行垃圾回收。注意，实际的垃圾回收时机是由JVM决定的，因此调用 `System.gc()` 并不能保证立即回收对象。
为了确保有足够的时间进行垃圾回收，我们使用 `Thread.sleep()` 方法让程序等待1秒钟。然后，再次打印对象的哈希码。如果对象被成功回收，则输出为null，否则仍然显示对象的哈希码。
运行这个程序可能会得到以下结果：
```
Object 1: java.lang.Object@3cd1a2f1
Object 2: java.lang.Object@2f0e140b
Object 3: java.lang.Object@7440e464
Object 1 after garbage collection: null
Object 2 after garbage collection: null
Object 3: java.lang.Object@7440e464
```
注意，由于垃圾回收的具体时机是由JVM控制的，因此
输出结果可能因JVM的不同实现而有所不同。
