Method references in java are a special type of lambda expressions. because they’re often used to create simple lambda expressions by referencing existing methods.

It is compact and easy form of lambda expression. Each time when you are using lambda expression to just referring a method, you can replace your lambda expression with method reference.

So in this , we are explaining method reference in java concept in detail.

Types of method reference in java.

1. Method Reference to a static method.
2. Reference to a instance method.
3. Reference to a constructor.

1. Method Reference to a static method.

syntax :-

ContainingClass::staticMethodName

Example:-

In the below example, we have defined a functional interface and referring a static method to it’s functional method max().

interface Maxester{  
    void max();  
}  
public class MethodReference {  
    public static void welcome(){  
        System.out.println("Welcome, this is static method.");  
    }  
    public static void main(String[] args) {  
        // Referring static method  
        Maxester maxester = MethodReference::welcome;  
        // Calling interface method  
        maxester.max();  
    }  
}  

Output:-

Welcome, this is static method.

2. Reference to a instance method.

syntax:-

 containingObject::instanceMethodName 

Example:-

In the below example, we are referring non-static methods. we can refer methods by class object and also an anonymous object.

interface Maxester{  
    void max();  
}  
public class InstanceMethodReference {  
    public void welcome(){  
        System.out.println("Welcome, this is instance method.");  
    }  
    public static void main(String[] args) {  
        InstanceMethodReference methodReference = new InstanceMethodReference(); // Creating object  
        // Referring non-static method using reference  
            Maxester maxester = methodReference::welcome;  
        // Calling interface method  
            Maxester.max();  
            // Referring non-static method using anonymous object  
            Maxester maxester_first = new InstanceMethodReference()::welcome; // You can use anonymous object also  
            // Calling interface method  
            maxester_first.max();  
    }  
}  

Output:-

Welcome, this is instance method.

Welcome, this is instance method.

3. Reference to a constructor.

syntax:-

 ClassName::new

Example:-

Interface Maxester{
      NewMaxester max(String value);
}
class NewMaxester{
      NewMaxester(String value){
         System.out.prinln(value);
     }
}
public class ConstrutorRefrenceMethod{
      public static void main(String[] args){
             Maxester maxester = NewMaxester::new;
             maxester.max("Welcome to maxester constructor");
        }
}

output:-

Welcome to maxester constructor.

External Link:-

You can also read much more about Method Reference from below link.

https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html

So i hope, This will be helpful for you.

ThankYou.

The post Method Reference In Java 8. appeared first on MaXEster Technologies | Technical Blog.

So, the answer is Yes, We can overload the main() method in java but JVM only calls the original main method, it will never call our overloaded main method.

Overload Main() Method in Java.

This is just one way, you can create as many versions of main as you want, but you must make sure that the method signature of each main is different. You can change the method signature by changing the type of argument, number of arguments or order of arguments. Best practice to overload a method is by changing the number of arguments, or types of arguments. In Java, it’s not possible to overload the method by just changing return type.

Example:-

public class Maxester { 


// Overloaded main method 1  
    // Should be executed when character is passed 
    public static void main(char value) 
    { 
        System.out.println("Inside main(char value) method"); 
    } 
  
    // Overloaded main method 2 
   // Should be executed when int value is passed 
    public static void main(int value) 
    { 
        System.out.println("Inside main(int value) method"); 
    } 
    // Overloaded main method 3  
    // Should be executed when double value is passed 
    public static void main(Double[] value) 
    { 
        System.out.println("Inside main(Double[] value) method"); 
    } 
  
    // Original main() 
    public static void main(String[] args) 
    { 
        System.out.println("Inside original main(String[] args) method "); 
    } 
} 

Output:-

Inside original main(Strings[] args) method.

As from the above example, it is clear that every time the original main method executes but not the overloaded methods because JVM only executes the original main method by default but not the overloaded one.

we can overload the main() method in java
But, to execute overloaded methods of main, we must call them from the original main method.

I hope this will be helpful to you.

Thank you.

The post Can we Overload the main() method in Java? appeared first on MaXEster Technologies | Technical Blog.

And, Lambda expression in java also provides a clear and concise way to represent one method interface using an expression.

It is also very useful in the collection library. It helps to iterate, filter and extract data from the collection.

Functional Interface

An interface that has only one abstract method is called a functional interface.

But,

Lambda Expressions in Java also provides an annotation @FunctionalInterface, which is used to declare an interface as a functional interface.

Important Characteristics of a lambda expression.

1.Optional type declaration:

No need to declare the type of a parameter.

Also, The compiler can inference the same from the value of the parameter.

2. The optional parenthesis around parameter :

No need to declare a single parameter in parenthesis.

But, For multiple parameters, parentheses are required.

3. Optional curly braces

No need to use curly braces in the expression body if the body contains a single statement. Then, it is optional to return keyword

4. Optional return keyword

The compiler automatically returns the value if the body has a single expression to return the value.

Also, Curly braces are required to indicate that expression returns a value.

Why We Use Lambda Expression?

1. To provide the implementation of a Functional interface.
2. Less coding.

Syntax Of Lambda Expression

• no parameter syntax

() -> {  
//Body of no parameter lambda  
}
//Lambda Expressions in Java.

• one parameter syntax

(s1) -> {  
//Body of one parameter lambda  
}

//Lambda Expressions in Java.

• two-parameter syntax

(s1,s2) -> {  
//Body of two parameter lambda  
}

//Lambda Expressions in Java.

Example:-

Without using Lambda Expression:

//Lambda Expressions in Java.

interface MyLambda{  
    public void lambda();  
}  
public class LambdaExample {  
    public static void main(String[] args) {  
        String name = "XYZ";  
  
        //without lambda, MyLambdaimplementation using anonymous class  
        MyLambda ml=new MyLambda(){  
            public void lambda(){System.out.println("Hello,  "+name);}  
        };  
        ml.lambda();  
    }  
}  

//Lambda Expressions in Java.

Output:  

Hello, XYZ

Using Lambda Expression:

//Lambda Expressions in Java.

@FunctionalInterface  //It is optional 
interface MyLambda{  
    public String lambda(String name);  
}  
  
public class LambdaExample{  
    public static void main(String[] args) {  
      
        // Lambda expression with single parameter.  
        MyLambda my1=(name)->{  
            return "Hello, "+name;  
        };  
        System.out.println(my1.lambda("XYZ"));  
          
        // You can omit function parentheses    
        MyLambda my2= name ->{  
            return "Hello, "+name;  
        };  
        System.out.println(my2.lambda("ABC"));  
    }  
}

//Lambda Expressions in Java. 

Output: 

Hello, XYZ
Hello, ABC

You can also use no parameter and multiple parameters lambda expression as in the above example.

Then, you can see How Lambda Expression is very useful.

Also, I hope, this will be helpful for you.

You can also visit on below link for a brief Introduction about Lambda Expressions in Java.

https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

ThankYou.

The post Lambda Expressions in Java. appeared first on MaXEster Technologies | Technical Blog.