Analysis of Variable Parameter Type Examples of Java Methods

The variable parameter type in Java methods is a very important concept and has a very wide range of applications. This article analyzes this in the form of examples. The details are as follows:

Generally speaking, when many Java beginners see the following code, they will ask a question: What are the three little dots in the dealArray method?

public class TestVarArgus {
  public static void dealArray(int... intArray){
      
  }
    
  public static void main(String args[]){
      
  }
}

This is the issue this article will discuss: variable parameter types, also known as indefinite parameter types. The English abbreviation is varargus, which means variable argument type. It can be easily seen from its name that when this method receives parameters, the number is variable. Okay, let’s call this method now. Please see the code and output:

public class TestVarArgus {
  public static void dealArray(int... intArray){
    for (int i : intArray)
      System.out.print(i +" ");
      
    System.out.println();
  }
    
  public static void main(String args[]){
    dealArray();
    dealArray(1);
    dealArray(1, 2, 3);
  }
}

Output:

##1

1 2 3

Through the call in the main method, you can see that this variable parameter can be It has no parameters (empty parameters) and can also be of variable length. Everyone who sees this will probably understand that this variable-length parameter is actually quite similar to an array parameter. In fact, this is indeed the case. The compiler will quietly convert this last formal parameter into an array parameter, and put a mark in the compiled class file to indicate that this is a method with a variable number of actual parameters. Please look at the code:

dealArray(); //dealArray(int[] intArray{});
dealArray(1); //dealArray(int[] intArray{1});
dealArray(1, 2, 3); //dealArray(int[] intArray{1, 2, 3});

Having said this, you can verify it to see if this variable parameter is an array class parameter? Look at the code:

public class TestVarArgus {
  public static void dealArray(int... intArray){
    for (int i : intArray)
      System.out.print(i +" ");
      
    System.out.println();
  }
    
  public static void dealArray(int[] intArray){//会有Duplicate method dealArray(int[]) in type TestVarArgus的错误
    for (int i : intArray)
      System.out.print(i +" ");
      
    System.out.println();
  }
    
  public static void main(String args[]){
    dealArray(); 
    dealArray(1);
    dealArray(1, 2, 3);
  }
}

As can be seen from the above code, these two methods conflict and cannot be overloaded. Here, let’s do another interesting experiment:

Code 1:

public class TestVarArgus {
  public static void dealArray(int... intArray){
    for (int i : intArray)
      System.out.print(i +" ");
      
    System.out.println();
  }
    
  public static void main(String args[]){
    int[] intArray = {1, 2, 3};
      
    dealArray(intArray); //通过编译，正常运行
  }
}

Code 2:

public class TestVarArgus {
  public static void dealArray(int[] intArray){
    for (int i : intArray)
      System.out.print(i +" ");
      
    System.out.println();
  }
    
  public static void main(String args[]){
    dealArray(1, 2, 3); //编译错误
  }
}

As can be seen from the above two pieces of code, variable parameters are compatible with array class parameters, but array class parameters are not compatible with variable parameters. In fact, for the second piece of code, the compiler does not know what is mutable and immutable. In its view, it needs to define a method of the dealArray(int, int, int) class. Therefore, it is naturally impossible to match the dealArray method of array class parameters.

Since the Java method receives variable parameters, let’s take a look at the following code:

public class TestVarArgus {
  public static void dealArray(int count, int... intArray){
      
  }
    
  public static void dealArray(int... intArray, int count){//编译报错，可变参数类型应该作为参数列表的最后一项
      
  }
    
  public static void main(String args[]){
       
  }
}

This code illustrates the variable parameters The type must be the last item in the parameter list and cannot be placed before the fixed-length parameter. You probably think of the word "priority". Because there is no exact explanation, it is just such a regulation. You can use the word "priority" to understand it. Please look at the following code:

public class TestVarArgus {
  public static void dealArray(int... intArray){
    System.out.println("1");
  }
    
  public static void dealArray(int count, int count2){
    System.out.println("2");
  }
    
  public static void main(String args[]){
    dealArray(1, 2);
  }
}

The code is posted. I guess everyone knows that the output is 2, not 1. What you need to remember here is that if a fixed-length method can be matched, that method will be matched first. The overloaded method with variable parameters is the last one selected.

Finally, everyone knows that the parameter of the main method is an array type, so it can actually be changed to an indefinite parameter type. Give it a try and see if there are any compilation errors.

I believe that what is described in this article has certain reference value for everyone’s learning of Java programming.

For more related articles on variable parameter type instance analysis of Java methods, please pay attention to the PHP Chinese website!