Java 如何将int数组作为参数传递给构造函数？

有人能告诉我是否可以将int数组作为参数传递给构造函数吗

我尝试了以下方法：

public static void main (String args[]){

    Accumulator[] X = new Accumulator[3];     

}

public Accumulator(int[] X) {
    A= new int[X.length];
    for (int i=0; i<X.length; i++)
        A[i] = X[i];
}

public static void main (String args[]){
    int[] someArray = {1,2,3};

    Accumulator accumulator = new Accumulator(someArray);
}

public Accumulator(int[] X) {
    A= new int[X.length];
    for (int i=0; i<X.length; i++)
        A[i] = X[i];
}

publicstaticvoidmain（字符串参数[]）{
累加器[]X=新累加器[3]；
}
公共累加器（int[]X）{
A=新整数[X.长度]；
对于（inti=0；i您正在初始化一个在主方法中大小为3的累加器数组

要将int数组传递给累加器的构造函数，需要执行以下操作：

public static void main (String args[]){

    Accumulator[] X = new Accumulator[3];     

}

public Accumulator(int[] X) {
    A= new int[X.length];
    for (int i=0; i<X.length; i++)
        A[i] = X[i];
}

public static void main (String args[]){
    int[] someArray = {1,2,3};

    Accumulator accumulator = new Accumulator(someArray);
}

public Accumulator(int[] X) {
    A= new int[X.length];
    for (int i=0; i<X.length; i++)
        A[i] = X[i];
}

publicstaticvoidmain（字符串参数[]）{
int[]someArray={1,2,3}；
累加器累加器=新累加器（someArray）；
}
公共累加器（int[]X）{
A=新整数[X.长度]；
对于（inti=0；i您正在初始化一个在主方法中大小为3的累加器数组

要将int数组传递给累加器的构造函数，需要执行以下操作：

public static void main (String args[]){

    Accumulator[] X = new Accumulator[3];     

}

public Accumulator(int[] X) {
    A= new int[X.length];
    for (int i=0; i<X.length; i++)
        A[i] = X[i];
}

public static void main (String args[]){
    int[] someArray = {1,2,3};

    Accumulator accumulator = new Accumulator(someArray);
}

public Accumulator(int[] X) {
    A= new int[X.length];
    for (int i=0; i<X.length; i++)
        A[i] = X[i];
}

publicstaticvoidmain（字符串参数[]）{
int[]someArray={1,2,3}；
累加器累加器=新累加器（someArray）；
}
公共累加器（int[]X）{
A=新整数[X.长度]；
对于（inti=0；i您正在初始化一个在主方法中大小为3的累加器数组

要将int数组传递给累加器的构造函数，需要执行以下操作：

public static void main (String args[]){

    Accumulator[] X = new Accumulator[3];     

}

public Accumulator(int[] X) {
    A= new int[X.length];
    for (int i=0; i<X.length; i++)
        A[i] = X[i];
}

public static void main (String args[]){
    int[] someArray = {1,2,3};

    Accumulator accumulator = new Accumulator(someArray);
}

public Accumulator(int[] X) {
    A= new int[X.length];
    for (int i=0; i<X.length; i++)
        A[i] = X[i];
}

publicstaticvoidmain（字符串参数[]）{
int[]someArray={1,2,3}；
累加器累加器=新累加器（someArray）；
}
公共累加器（int[]X）{
A=新整数[X.长度]；
对于（inti=0；i您正在初始化一个在主方法中大小为3的累加器数组

要将int数组传递给累加器的构造函数，需要执行以下操作：

public static void main (String args[]){

    Accumulator[] X = new Accumulator[3];     

}

public Accumulator(int[] X) {
    A= new int[X.length];
    for (int i=0; i<X.length; i++)
        A[i] = X[i];
}

public static void main (String args[]){
    int[] someArray = {1,2,3};

    Accumulator accumulator = new Accumulator(someArray);
}

public Accumulator(int[] X) {
    A= new int[X.length];
    for (int i=0; i<X.length; i++)
        A[i] = X[i];
}

publicstaticvoidmain（字符串参数[]）{
int[]someArray={1,2,3}；
累加器累加器=新累加器（someArray）；
}
公共累加器（int[]X）{
A=新整数[X.长度]；
对于（int i=0；i请尝试以下操作：

public static void main (String args[]){
    int[] test = new int[3];
    test[0] = 1;
    test[1] = 2;
    test[3] = 3;
    Accumulator X = new Accumulator(test);     

}

public Accumulator(int[] X) {
    A= new int[X.length];
    for (int i=0; i<X.length; i++)
        A[i] = X[i];
}

publicstaticvoidmain（字符串参数[]）{
int[]测试=新的int[3]；
测试[0]=1；
试验[1]=2；
试验[3]=3；
蓄能器X=新蓄能器（试验）；
}
公共累加器（int[]X）{
A=新整数[X.长度]；
对于（int i=0；i请尝试以下操作：

public static void main (String args[]){
    int[] test = new int[3];
    test[0] = 1;
    test[1] = 2;
    test[3] = 3;
    Accumulator X = new Accumulator(test);     

}

public Accumulator(int[] X) {
    A= new int[X.length];
    for (int i=0; i<X.length; i++)
        A[i] = X[i];
}

publicstaticvoidmain（字符串参数[]）{
int[]测试=新的int[3]；
测试[0]=1；
试验[1]=2；
试验[3]=3；
蓄能器X=新蓄能器（试验）；
}
公共累加器（int[]X）{
A=新整数[X.长度]；
对于（int i=0；i请尝试以下操作：

public static void main (String args[]){
    int[] test = new int[3];
    test[0] = 1;
    test[1] = 2;
    test[3] = 3;
    Accumulator X = new Accumulator(test);     

}

public Accumulator(int[] X) {
    A= new int[X.length];
    for (int i=0; i<X.length; i++)
        A[i] = X[i];
}

publicstaticvoidmain（字符串参数[]）{
int[]测试=新的int[3]；
测试[0]=1；
试验[1]=2；
试验[3]=3；
蓄能器X=新蓄能器（试验）；
}
公共累加器（int[]X）{
A=新整数[X.长度]；
对于（int i=0；i请尝试以下操作：

public static void main (String args[]){
    int[] test = new int[3];
    test[0] = 1;
    test[1] = 2;
    test[3] = 3;
    Accumulator X = new Accumulator(test);     

}

public Accumulator(int[] X) {
    A= new int[X.length];
    for (int i=0; i<X.length; i++)
        A[i] = X[i];
}

publicstaticvoidmain（字符串参数[]）{
int[]测试=新的int[3]；
测试[0]=1；
试验[1]=2；
试验[3]=3；
蓄能器X=新蓄能器（试验）；
}
公共累加器（int[]X）{
A=新整数[X.长度]；
对于（int i=0；i当然，数组在java中只是一个对象，因此可以将其作为参数传递

public Accumulator(int[] X){
     A = X;
}

或者，如果需要复制阵列，请使用

public Accumulator(int[] X){
     A = new int[X.length];

     System.arrayCopy(X , 0 , A , 0 , X.length);
}

出于性能原因。
当然，数组在java中只是一个对象，因此您可以将其作为参数传递。尽管您可以简单地使用：

public Accumulator(int[] X){
     A = X;
}

或者，如果需要复制阵列，请使用

public Accumulator(int[] X){
     A = new int[X.length];

     System.arrayCopy(X , 0 , A , 0 , X.length);
}

出于性能原因。
当然，数组在java中只是一个对象，因此您可以将其作为参数传递。尽管您可以简单地使用：

public Accumulator(int[] X){
     A = X;
}

或者，如果需要复制阵列，请使用

public Accumulator(int[] X){
     A = new int[X.length];

     System.arrayCopy(X , 0 , A , 0 , X.length);
}

出于性能原因。
当然，数组在java中只是一个对象，因此您可以将其作为参数传递。尽管您可以简单地使用：

public Accumulator(int[] X){
     A = X;
}

或者，如果需要复制阵列，请使用

public Accumulator(int[] X){
     A = new int[X.length];

     System.arrayCopy(X , 0 , A , 0 , X.length);
}

出于性能方面的原因。
我看到您得到了许多答案，这些答案解释了如何对单个对象执行此操作，而不是对数组执行此操作。下面是如何对数组执行此操作：

public static void main (String args[]){

    int array[] = {1, 2, 3};

    Accumulator[] X = new Accumulator[3];       
    for(Accumulator acc : X) {
        acc = new Accumulator(array);
    }
}

创建数组时，元素被初始化为null，因此可以在循环中创建对象，并且可以使用带有数组参数的构造函数。
我看到有很多答案解释了如何对单个对象执行此操作，而不是对数组执行此操作。下面是如何对数组执行此操作：

public static void main (String args[]){

    int array[] = {1, 2, 3};

    Accumulator[] X = new Accumulator[3];       
    for(Accumulator acc : X) {
        acc = new Accumulator(array);
    }
}

创建数组时，元素被初始化为null，因此可以在循环中创建对象，并且可以使用带有数组参数的构造函数。
我看到有很多答案解释了如何对单个对象执行此操作，而不是对数组执行此操作。下面是如何对数组执行此操作：

public static void main (String args[]){

    int array[] = {1, 2, 3};

    Accumulator[] X = new Accumulator[3];       
    for(Accumulator acc : X) {
        acc = new Accumulator(array);
    }
}

创建数组时，元素被初始化为null，因此可以在循环中创建对象，并且可以使用带有数组参数的构造函数。
我看到有很多答案解释了如何对单个对象执行此操作，而不是对数组执行此操作。下面是如何对数组执行此操作：

public static void main (String args[]){

    int array[] = {1, 2, 3};

    Accumulator[] X = new Accumulator[3];       
    for(Accumulator acc : X) {
        acc = new Accumulator(array);
    }
}

当您创建数组时，元素被初始化为null，因此您在循环中创建对象，并且您可以在那里使用带有数组参数的构造函数。
您的意思是
int[]test=new int[3]
您的意思是
int[]test=new int[3]
您的意思是
int[]test=new int[3]
您的意思是
int[]test=new int[3]
通过查看代码，您似乎想创建累加器阵列（3个待精确化）。但是对累加器构造函数的调用在哪里？嗨，我想创建一个数组大小为3，其中包含3个数字，然后作为参数传递给我的构造函数。我认为这是对构造函数的调用。通过查看代码，您似乎想创建累加器数组（精确为3）.但是对累加器构造函数的调用在哪里？嗨，我想创建一个数组大小为3，包含3个数字，然后得到