java 应用程序里包含其他两个类和主类

Java应用程序通常由多个类组成，其中一个是主类（也称为启动类），它包含了`main()`方法，这是程序执行的起点。在这个例子中，有两个主要的类：

1. `Print` 类：这是一个辅助类，定义了一个名为`output()`的方法，其功能是遍历100到999之间的所有数字，检查每个数字是否为水仙花数（即每个位上的数字立方之和等于该数字自身）。如果找到符合条件的数字，就打印出来。

   public class Print {
       // ...
       void output() {
           // ... (立方和检查逻辑)
       }
   }

2. 主类`E`：在这个类的`main()`方法中，实例化了`Print`类的对象并调用了它的`output()`方法来运行查找水仙花数的算法。这是Java应用程序的基本结构之一，通过这种方式，你可以在一个地方控制整个程序的执行流程。

   public class E {
       public static void main(String[] args) {
           Print p = new Print();
           p.output(); // 调用Print类的方法
       }
   }

运行上述代码[^1]后，你会看到输出的水仙花数。

相关问题

编写一个java应用程序，该应用程序包括两个类:Print类和主类E。Print类里有一个方法output（），其功能是输出100～999之间所有的水仙花数。在主类E的main方法中来测试类Print

在Java中编写这样一个程序，首先我们需要创建两个类：`Print` 类用于处理计算水仙花数的具体逻辑，以及一个 `E` 类（这里我们假设它是`Main` 或者更常规的命名`MainClass`）来作为主入口，运行和测试`Print` 类。

**Print.java** (水仙花数计算类):

public class Print {
    public static void output() {
        for (int i = 100; i < 1000; i++) {
            if (isWaterfallNumber(i)) {
                System.out.println(i);
            }
        }
    }

    // 水仙花数检查方法
    private static boolean isWaterfallNumber(int num) {
        int hundred = num / 100;
        int ten = (num % 100) / 10;
        int unit = num % 10;

        return hundred * hundred * hundred + ten * ten * ten + unit * unit * unit == num;
    }
}

**MainClass.java** (主类，这里简化为主函数放在`E`类中):

public class MainClass {
    public static void main(String[] args) {
        // 测试Print类的方法
        Print.output();
    }
}

在这个程序中，`Print.output()` 方法会遍历100到999之间的所有整数，通过`isWaterfallNumber` 函数检查是否为水仙花数，并打印出来。在`MainClass` 的`main` 方法中，我们直接调用`Print.output()` 进行测试。

用Java1．编写应用程序，该程序包含两个类，一个Cat类和一个包含主类的测试类Test,Cat类里定义一个 Speak 方法，内容为输出"喵喵"，然后通过Test 类调用Cat类的Speak方法，输

在Java中创建一个简单的多态示例，首先我们需要定义一个名为`Cat`的抽象基类或者接口，并声明一个名为`speak`的方法，因为猫有多种叫声，我们在这里可以将它设为抽象方法：

// Cat类（抽象类）
public abstract class Cat {
    public abstract void speak();
}

然后，我们可以为`Cat`类提供具体的子类，比如`SiameseCat`和`PersianCat`，它们分别实现`speak()`方法：

// SiameseCat类
public class SiameseCat extends Cat {
    @Override
    public void speak() {
        System.out.println("喵喵~");
    }
}

// PersianCat类
public class PersianCat extends Cat {
    @Override
    public void speak() {
        System.out.println("喵呜...");
    }
}

现在在测试类`Test`中，我们可以创建`Cat`类型的对象，但实际上持有的是子类的实例，这就是多态的应用：

// Test类
public class Test {
    public static void main(String[] args) {
        Cat siamese = new SiameseCat(); // 创建Siamese猫对象
        Cat persian = new PersianCat(); // 创建Persian猫对象

        siamese.speak(); // 输出 "喵喵~"
        persian.speak(); // 输出 "喵呜..."
    }
}

在这个例子中，`Test`类并不关心实际的对象是什么类型，只需要`Cat`类型的引用。运行`speak()`方法时，会根据不同类型的猫实例显示相应的叫声。