Java / Methods

No. main() method is defined only if the java class is an application and has to execute.

Yes, so that the subclass cannot override main() method.

A parameter is that appears in the definition of the method. An argument is the instance or value passed to the method during runtime when the method is invoked.

void. main() method does not return any value.

JVM need to access the main() method even before the class instantiation so begin the execution. so it is declared static.

There is only one argument that main() method accepts.

main() method accepts a vararg/array of string object as an argument.

Yes.

It is an empty Array with zero elements and not null.

public class MainMethodClass {

	public static void main(String[] args) {

		System.out.println("Size of the Arg Array=" + args.length);
	}
}

Output: 0

Yes. The compiler optimizes the code to invoke the static method using null object reference since object instance is not required to invoke a static method.

public class StaticMethodUsingNull {

	static void printWelcomeMessage() {
		System.out.println("Welcome to javapedia.net!");
	}

	public static void main(String[] args) {
		StaticMethodUsingNull myRef = null;
		myRef.printWelcomeMessage(); /*Message will be printed sucessfully*/

	}

}

In case of calling a non-static (instance) method using null object reference, it will throw NullPointerException.

In Java 8, a new feature "default method implementation for interfaces" is introduced that facilitates backward compatibility for the old interfaces to leverage the lambda expression capability of Java 8 and also existing libraries implementing these interfaces need not have to provide its implementation for the new functionality/method added to the interface.

For example, java.util.List or Collection interface does not have forEach method declaration. Thus, calling such methods will break the collection framework implementations. Java 8 introduces default method so that List/Collection interface can have a default implementation of forEach method, and the class implementing these interfaces need not have to implement the same.

Thus default methods enable you to add new functionality to the interfaces of your libraries and ensure backward compatibility with the codes written using the older versions of those interfaces without having to implement the new functionality.

For creating a default method in Java interface, we need to use default keyword with the method signature.

public interface Fruits {
   default void nature(){
      System.out.println("I am Sweet.");
   }
}

The default methods are non-static and can be accessed from the Implementing class object as shown in the below example.

public class OrangeClass implements Fruits {

	public static void main(String[] args) {
		Fruits fruit = new OrangeClass();
		
		fruit.nature();
	}

}

Java interface default methods are also known as Defender Methods or Virtual extension methods.

A default method cannot override a method from java.lang.Object class as interfaces does not extend Object.

Compilation error occurs when a class tries to implement two or more interfaces having a default method with the same signature.

Other than multiple inheritance, there is no significant difference between an abstract class and an interface in Java 8 by the addition of default method feature.

• Using default methods for interfaces eliminates the need for utility classes, for example, the java.util.Collections utility class is not required when all of its methods are provided in the Collection interface itself as default methods.
• It helps in extending interfaces without the concern of breaking the implementation classes.
• Default methods in interfaces enhances the Collections API in Java 8 to support lambda expressions.
• Java interface default methods has bridged down the differences between interface and abstract class.
• Interface implementing concrete classes can choose which default method to override and can use interface default implementation itself.

The interface static methods are concrete methods implemented in the interface that prevents the implementation classes from overriding to ensure the proper and uniform implementation being used across all the implementation classes.

The static interface method has method body and marked with static keyword in the method signature.

public interface Fruits {
	static void eat() {
		System.out.println("Enjoy!");
	}
}

Java interface static methods are visible to interface methods only and it can be invoked by interface name itself.

public class OrangeClass implements Fruits {

	public static void main(String[] args) {
		
		Fruits.eat();
	}
}

• Java interface static methods are suitable for providing utility function and acts as utility methods, for example sorting a Collection, validations, reversing a collection etc.
• Java interface static method ensures quality and security by preventing the implementation classes to override them.

When an object is passed by value, this means that a copy of the object is passed. Thus, even if changes are made to that object, it doesn't affect the original value. When an object is passed by reference, this means that the actual object is not passed, rather a reference of the object is passed. Thus, any changes made by the external method, are also reflected in all places.

Zero represents that the program ended successfully. Any number greater than zero represents program execution failed. Number less than zero represents program execution error.

In Java, all non-static methods are considered as virtual functions. The Final methods cannot be overridden and the private methods cannot be inherited so it is considered as non-virtual.

With Java 8, interfaces can have static methods. They can also have concrete instance methods, but not instance fields.

The fluent interface enables to apply multiple properties/setters on an object just by using dots(.) without having to use the actual object reference.

Fluent interface is also known as fluent API.

new Employee().setName("Jacob")
                          .setAge(46)
                          .setActive(true);

Method chaining is a mean by which fluent API could be used so that multiple setters on a method be invoked continuously by just using dot(.) that improves readability and less code.

To achieve method chaining update the setters to return the object instance or by using this keyword.

Synthetic method is a compiler created method after the type erasure on the generic methods.

Java compiler creates a synthetic method known as bridge method when compiling a class or interface that extends a parameterized class or interface as part of type erassure.

A method reference is a Java 8 construct that can be used for referencing a method without invoking it. It is used for treating methods as Lambda Expressions.

They can only be used to replace a single-method lambda expression.

The general syntax of a method reference: Object :: methodName

In method reference, you place the object (or class) that contains the method before the :: operator and the name of the method after it without arguments.

• A method reference to a static method.
• A method reference to an instance method of an object of a particular type.
• A method reference to an instance method of an existing object.
• A method reference to a constructor.

Static methods are usually faster (comparatively) as we don't need 'this' object reference for static calls. However, the performance is negligible when compared to the non-static method calls and no decision should be made based on performance when choosing static methods vs non-static methods.

A lambda expression is an anonymous function that you can use to create delegates or expression tree types. By using lambda expressions, you can write local functions that can be passed as arguments or returned as the value of function calls. A lambda expression is the most convenient way to create that delegate.

The data type that the methods expect is called the target type. To determine the type of a lambda expression, the Java compiler uses the target type of the context or situation in which the lambda expression was found.

Yes. You can serialize a lambda expression if its target type and its captured arguments are serializable. However the serialization of lambda expressions is strongly discouraged.

System.out::println method in Java 8 is a static method reference to println method of out object of System class.

Default method is also known as defender method or virtual extension method.

No, we encounter compile time error. default modifier is used for methods with implementation.

All the method declarations in an interface, including default methods, are implicitly public, so you can omit the public modifier.

When you extend an interface that contains a default method, you may do one of the following:

• Not mention the default method at all, which lets your extended interface inherit the default method.
• Redeclare the default method to make it abstract.
• Redefine the default method to override it.

Java class can implement multiple interfaces and each interface can define default method with same method signature, therefore, the inherited methods can conflict with each other.

public interface Interface1 { 
    default void myDefaultMethod(){ 
        System.out.println("Interface One default method"); 
    } 
}
public interface Interface2 {
    default void myDefaultMethod(){
        System.out.println("Interface Two default method");
    }
}
public class ImplClass implements Interface1, Interface2  {
}

The above code will fail to compile with the error. To fix this class, we need to provide default method implementation.

public class ImplClass implements Interface1, Interface2  {
    public void myDefaultMethod() {
     }
}

Additionally, we may invoke default implementation provided by any of super interface by using super keyword as shown below.

public class ImplClass implements Interface1, Interface2  {
    public void myDefaultMethod() {
        Interface2.super.myDefaultMethod();
     }
}

Overriding depends on having an instance of an class and static method is not associated to instance of the class.

public access modifier specify who can access this method. Public will be accessible by any Class from any package.

static keyword identifies it is class based and it can be invoked without creating a class instance.

void is the return type of the method. Void indicates that the method does not return any value.

main is the name of the method which is invoked by JVM as a starting point of execution for an application.

String args[] holds the command line parameters passed to the main method.

Use super keyword along with interface name to invoke a default method.

public interface Animal {
    default void feed() {
        System.out.println("Feed some food to animals");
    }
}

public class Dog  implements Animal{
    public void feed() {
        Animal.super.feed();
    }
}

Invoke the static method using the name of the interface.

public interface Animal {
    static void doSwim() {
        System.out.println("Animal can swim");
    }
}
public class Dog implements Animal {
    public void canSwim() {
        Animal.doSwim();
    }
}

System.out.println() is used to print the message on the console. System is a class present in java.lang package. The "out" is the static variable of type PrintStream class present in the System class. println() is the method present in the PrintStream class.