Java 分班

所以我需要从第二个类运行这个类。我该怎么做？下面是我想从单独的类运行的代码：

import java.util.*;

public class Numbers {

    int min(int a, int b, int c, int d, int e) {
        int min1 = Math.min(a, b);
        int min2 = Math.min(c, d);
        int min3 = Math.min(min1, min2);
        int min4 = Math.min(min3, e);

        return min4;
    }
    int max(int a, int b, int c, int d, int e) {
        int max1 = Math.max(a, b);
        int max2 = Math.max(c, d);
        int max3 = Math.max(max1, max2);
        int max4 = Math.max(max3, e);

        return max4;
    }
    double avg(int a, int b, int c, int d, int e) {
        double average = (a+b+c+d+e)/5;

        return average;
    }
    double stddev(int a, int b, int c, int d, int e) {
        double average = (a+b+c+d+e)/5;
        double a1 = Math.pow((a-average),2);
        double b1 = Math.pow((b-average),2);
        double c1 = Math.pow((c-average),2);
        double d1 = Math.pow((d-average),2);
        double e1 = Math.pow((e-average),2);
        double average2 = (a1+b1+c1+d1+e1)/5;
        double x;
        x = Math.sqrt(average2);
        return x;

    }

}

---

在另一个类的某个地方，实例化该类并调用适当的方法：

Numbers instance = new Numbers();
int maxValue = instance.max(1, 2, 3, 4, 5);

---

在另一个类中创建该类的对象注意：在同一个包中

像这样,

Numbers n = new Numbers();
int minimum = n.min(10,20,30,40,50);
System.out.println(minimum);          // Prints 10
int maximum = n.max(10,20,30,40,50);
System.out.println(maximum);          // Prints 50
double average = n.avg(10,20,30,40,50);
System.out.println(average);          // Prints 30
double dev = n.devstd(10,20,30,40,50);

---

如果您的类在同一个包中，例如，如果您在Eclipse中使用默认设置，那么它将是，然后在您的新类中，您可以像调用Math.pow一样调用这些函数

double l_stddev = Numbers.stddev(1,2,3,4,5);

比如说

编辑：Oops-忽略了这些不是静态方法。你可以让它们在你的数字类中是静态的，那么你就不需要像数学类一样创建一个对象来调用它们了

---

因此，正如另一个答案所说，如果您的类是这样的，那么您需要创建一个Number对象。

您的意思是调用Numbers类中的方法？您可以按如下方式执行此操作：

public Main{
    public static void main( String[] args ){
            Numbers numbers = new Numbers(); // Instance

            int minimum = numbers.min( 1, 2, 3, 4, 5 );
            System.out.println( "minimum:" + minimum );

            int maximum = numbers.max( 1, 2, 3, 4, 5);
            System.out.println("maximum:" + maximum );

            double average = numbers.avg( 1, 2, 3, 4, 5 );
            System.out.println("average:" + average );

            double standardDev = numbers.devstd( 1, 2, 3, 4, 5 );
            System.out.println("standard deviation:" + standardDev );
    }   
}

更好的是，使这些方法保持静态，因为它们不依赖于任何属性：

public static int min(int a, int b, int c, int d, int e) {
    int min1 = Math.min(a, b);
    int min2 = Math.min(c, d);
    int min3 = Math.min(min1, min2);
    int min4 = Math.min(min3, e);

    return min4;
}

通过更通用的方法增加奖金：

public static int min(int[] intArray ) {
    // If empty/null array throws Exception. Caller/supplier should handle this.
    int min = intArray[0]; 

    for( int i = 1; i < intArray.length; i++ ){
            min = Math.min(min, intArray[i]);
    }

    return min;
}

---

在另一个类中，在main方法中创建一个数字对象类并调用所需的方法

    Numbers obj=new Numbers();
     obj.max( a,  b,  c,d ,e);

---

我不知道从一个单独的类运行是什么意思，但如果您想从另一个类调用这些函数，应该将它们设置为静态：

public static int min(...

那么你叫它：

int m = Numbers.min(...

---

无论您想从哪里开始。

看起来这些都是实用程序方法，类本身没有状态，也没有实例字段。这对我来说意味着上述方法应该是静态方法。我同意气垫船。

int m = Numbers.min(...