TechieWolf

Prior to JDK 5, variable-length arguments could be handled two ways. One using overloaded method(one for each) and another put the arguments into an array, and then pass this array to the method. Both of them are potentially error-prone and require more code. The varargs feature offers a simpler, better option.

Syntax of varargs :
A variable-length argument is specified by three periods(…). For Example:

public static void fun(int ... a) 
{
   // method body
}

This syntax tells the compiler that fun( ) can be called with zero or more arguments. As a result, here a is implicitly declared as an array of type int[].

// Java program to demonstrate varargs 
class Test1 
{ 
    // A method that takes variable number of intger 
    // arguments. 
    static void fun(int ...a) 
    { 
        System.out.println("Number of arguments: " + a.length); 
  
        // using for each loop to display contents of a 
        for (int i: a) 
            System.out.print(i + " "); 
        System.out.println(); 
    } 
  
    // Driver code 
    public static void main(String args[]) 
    { 
        // Calling the varargs method with different number 
        // of parameters 
        fun(100);         // one parameter 
        fun(1, 2, 3, 4);  // four parameters 
        fun();            // no parameter 
    } 
}

}
Output:

Number of arguments: 1
100 
Number of arguments: 4
1 2 3 4 
Number of arguments: 0
 

Explanation of above program :

• The … syntax tells the compiler that varargs has been used and these arguments should be stored in the array referred to by a.
• The variable a is operated on as an array. In this case, we have defined the data type of a as int. So it can take only integer values. The number of arguments can be found out using a.length, the way we find the length of an array in Java.
  
  Note: A method can have variable length parameters with other parameters too, but one should ensure that there exists only one varargs parameter that should be written last in the parameter list of the method declaration.
  
  int nums(int a, float b, double … c)

Important points:

• Vararg Methods can also be overloaded but overloading may lead to ambiguity.
• Prior to JDK 5, variable length arguments could be handled into two ways : One was using overloading, other was using array argument.
• There can be only one variable argument in a method.
• Variable argument (varargs) must be the last argument.

Source: https://www.geeksforgeeks.org/variable-arguments-varargs-in-java/

JDK
Contains various APIs and libs like
Java.io, javac, java etc
It gives the required packages for java developer to work on JVM and jre

JRE
It is runtime environment, which implements JVM and provides all class libraries and other files that JVM requires at runtime

JVM
It is where the bytecode is executed

• It is a process which keeps all concurrent threads in execution to be in sync while trying to access the same object at the same time.
• It prevents memory consistency errors caused due to inconsistent view of shared memory.
• Ex BookMyShow, multiple users try to book tickets at same time but ticket selected by one user is Locked and prevented for other users.

• A process is a running instance of program over OS
• – A thread is running on top of process
• – OS, there is multi processing on OS level
• – Multiple thread, multi threading in process level
• – Process run on separate memory space
• – Thread runs on shared memory space

– Each of java’s 8 primitive data types has a class dedicated to it. These are known as wrapper class
– They wrap the primitive data type into an object of that class
– Ex- boolean has Boolean, byte has Byte etc
– int is single value container , primitive data type
– Integer iRef = new Integer(i)- it is wrapper class and called and Boxed(constructing object)
– int j=iRef.intValue() – This is Unboxing (Extracting value from object)
– Integer kRef=i; //It is called Autoboxing, no need to write new keyword

• Final is used to apply restrictions on class, method,variable
• Final class can not be inherited, final method can not be over ridden, final variable can not be changed
  
• Finally is used mostly with try catch in exception handling
• it is used to execute the code which needs to be executed irrespective of the exception
• Ex , closing db connection
  
• finalize is used to clean up processing before object is garbage collector