Constructor in Java

Constructor in java is a special type of method that is used to initialize the object.
Java constructor is invoked at the time of object creation. It constructs the values i.e. provides data for the object that is why it is known as constructor.

Rules for creating java constructor

There are basically two rules defined for the constructor.

1. Constructor name must be same as its class name
2. Constructor must have no explicit return type

Types of java constructors

There are two types of constructors:

1. Default constructor (no-arg constructor)
2. Parameterized constructor

Example of default constructor

In this example, we are creating the no-arg constructor in the Bike class. It will be invoked at the time of object creation.

1. class Bike1{  
2. Bike1(){System.out.println("Bike is created");}  
3. public static void main(String args[]){  
4. Bike1 b=new Bike1();  
5. }  
6. }  

Test it Now Output:

Bike is created 

Why use parameterized constructor?

Parameterized constructor is used to provide different values to the distinct objects.

Example of parameterized constructor

In this example, we have created the constructor of Student class that have two parameters. We can have any number of parameters in the constructor.

1. class Student4{  
2.     int id;  
3.     String name;  
4.       
5.     Student4(int i,String n){  
6.     id = i;  
7.     name = n;  
8.     }  
9.     void display(){System.out.println(id+" "+name);}  
10.    
11.     public static void main(String args[]){  
12.     Student4 s1 = new Student4(111,"Karan");  
13.     Student4 s2 = new Student4(222,"Aryan");  
14.     s1.display();  
15.     s2.display();  
16.    }  
17. }  

Test it Now Output:

111 Karan
222 Aryan

Static blocks in Java

If a class has static members that require complex initialization, a static block is the tool to use.

Unlike C++, Java supports a special block, called static block (also called static clause) which can be used for static initializations of a class. This code inside static block is executed only once: the first time you make an object of that class or the first time you access a static member of that class (even if you never make an object of that class). For example, check output of following Java program.

// filename: Main.java class Test {     static int i;     int j;           // start of static block     static {         i = 10;         System.out.println("static block called ");     }     // end of static block } class Main {     public static void main(String args[]) {         // Although we don't have an object of Test, static block is         // called because i is being accessed in following statement. //static block code execute 1st , even before constructor and main method         System.out.println(Test.i);     } }

Output:
static block called
10

Static and final keyword in java

The static keyword can be used in 4 scenarios

• static variables
• static methods
• static blocks of code.
• static nested class

Lets look at static variables and static methods first.

static variable

• It is a variable which belongs to the class and not to object(instance)
• Static variables are initialized only once , at the start of the execution . These variables will be initialized first, before the initialization of any instance variables
• A single copy to be shared by all instances of the class
• A static variable can be accessed directly by the class name and doesn’t need any object
• Syntax : Class.variable

static method

• It is a method which belongs to the class and not to the object(instance)
• A static method can access only static data. It can not access non-static data (instance variables) unless it has/creates an instance of the class.
• A static method can call only other static methods and can not call a non-static method from it unless it has/creates an instance of the class.
• A static method can be accessed directly by the class name and doesn’t need any object
• Syntax : Class.methodName()
• A static method cannot refer to this or super keywords in anyway

static class

Java also has "static nested classes",A static nested class is just one which doesn't implicitly have a reference to an instance of the outer class.
Static nested classes can have instance methods and static methods.
There's no such thing as a top-level static class in Java.

Side Note:

main method is static since it must be be accessible for an application to run before any instantiation takes place.

final keyword is used in several different contexts to define an entity which cannot later be changed.

• A final class cannot be subclassed. This is done for reasons of security and efficiency. Accordingly, many of the Java standard library classes are final, for example java.lang.System and java.lang.String. All methods in a final class are implicitly final.
• A final method can't be overridden by subclasses. This is used to prevent unexpected behavior from a subclass altering a method that may be crucial to the function or consistency of the class.
• A final variable can only be initialized once, either via an initializer or an assignment statement. It does not need to be initialized at the point of declaration: this is called a blank final variable. A blank final instance variable of a class must be definitely assigned at the end of every constructor of the class in which it is declared; similarly, a blank final static variable must be definitely assigned in a static initializer of the class in which it is declared; otherwise, a compile-time error occurs in both cases.

Note: If the variable is a reference, this means that the variable cannot be re-bound to reference another object. But the object that it references is still mutable, if it was originally mutable.

When an anonymous inner class is defined within the body of a method, all variables declared final in the scope of that method are accessible from within the inner class. Once it has been assigned, the value of the final variable cannot change.

"A static method can access only static data. It can not access non-static data (instance variables)" - UNLESS it has/creates an instance of the class. "A static method can call only other static methods and can not call a non-static method from it." - UNLESS it has/creates an instance of the class.

Assert in webdriver code

driver.get("http://google.co.in");
WebElement element = driver.findElement(By.xpath("//span[text()='Google Search']"));
String strng = element.getText();
System.out.println(strng);
Assert.assertEquals("Google Search", strng);


assertEquals check for string to match with "Google Search"