Java- Throw, Throws, Throwable

Java- Throw, Throws, Throwable

Throw:

throw is a keyword in java which is used to throw an exception manually. Using throw keyword, you can throw an exception from any method or block. But, that exception must be of type java.lang.Throwable class or it’s sub classes. Below example shows how to throw an exception using throw keyword.

class ThrowAndThrowsExample
{
 void method() throws Exception
 {
  Exception e = new Exception();

  throw e;            //throwing an exception using 'throw'
 }
}

Java- Final , Finally and Finalize

Java- Final , Finally and Finalize

Final:

Final is a keyword. The variable decleared as final should be initialized only once and cannot be changed. Java classes declared as final cannot be extended. Methods declared as final cannot be overridden.Final is a keyword.

final can be used to mark a variable "unchangeable"

private final String name = "foo";  //the reference name can never change


final can also make a method not "overrideable"

public final String toString() {  return "NULL"; }

final can also make a class not "inheritable". i.e. the class can not be subclassed.

public final class finalClass {...}
public class classNotAllowed extends finalClass {...} // Not allowed

Finally:

Finally is a block. The finally block always executes when the try block exits. This ensures that the finally block is executed even if an unexpected exception occurs. But finally is useful for more than just exception handling - it allows the programmer to avoid having cleanup code accidentally bypassed by a return, continue, or break. Putting cleanup code in a finally block is always a good practice, even when no exceptions are anticipated. Finally is a block.

lock.lock();
try {
  //do stuff
} catch (SomeException se) {
  //handle se
} finally {
  lock.unlock(); //always executed, even if Exception or Error or se
}

Finalize:

Finalize is a method. Before an object is garbage collected, the runtime system calls its finalize() method. You can write system resources release code in finalize() method before getting garbage collected. Finalize is a method.

How to play with excel creation using APACHE POI in selenium Webdriver framework?

Code to create Excel sheet at run time using APACHE POI..


String filepath = "D:\\Mohit1.xls";

FileOutputStream fileout = new FileOutputStream(filepath);

Workbook workbook = new HSSFWorkbook();
Sheet sheet = workbook.createSheet();

Row row;
Cell cell;
for (int i=0 ; i< 4 ; i++){

row = sheet.createRow(i);
for (int j =0 ; j<3 ;j++){

cell = row.createCell(j);
cell.setCellValue("data"+ i + j);
}
}

workbook.write(fileout);

How to play with Selenium IDE ?

Selenium IDE is a Firefox plug in , we can record actions on webpage like type, select , click  and we can play back same recorded script again to verify the action.

Java - Overriding method

Overriding Method :

Method in a subclass with the same signature (name,number and the type of its parameters) and return type as method in the super class overrides the super class's method.

If subclass (child class) has the same method as declared in the parent class, it is known as method overriding in java.

In other words, If subclass provides the specific implementation of the method that has been provided by one of its parent class, it is known as method overriding.

The ability of a subclass to override a method allows a class to inherit from a superclass whose behavior is "close enough" and then to modify behavior as needed. The overriding method has the same name, number and type of parameters, and return type as the method that it overrides. An overriding method can also return a subtype of the type returned by the overridden method. This subtype is called a covariant return type.

Super keyword in Overriding

super keyword is used for calling the parent class method/constructor. super.methodname() calling the specified method of base class while super() calls the constructor of base class. Let’s see the use of super in Overriding

Static Methods

If a subclass defines a static method with the same signature as a static method in the superclass, then the method in the subclass hides the one in the superclass.

The distinction between hiding a static method and overriding an instance method has important implications:

1. The version of the overridden instance method that gets invoked is the one in the subclass.
2. The version of the hidden static method that gets invoked depends on whether it is invoked from the superclass or the subclass.

Advantage of method overriding :

The main advantage of method overriding is that the class can give its own specific implementation to a inherited method without even modifying the parent class(base class).

Rules of method overriding in Java:

1. Argument list: The argument list of overriding method must be same as that of the method in parent class. The data types of the arguments and their sequence should be maintained as it is in the overriding method.
2. Access Modifier: The Access Modifier of the overriding method (method of subclass) cannot be more restrictive than the overridden method of parent class. For e.g. if the Access Modifier of base class method is public then the overriding method (child class method ) cannot have private, protected and default Access modifier as all of the three are more restrictive than public.
3. Private, static and final methods cannot be overridden as they are local to the class. However static methods can be re-declared in the sub class, in this case the sub-class method would act differently and will have nothing to do with the same static method of parent class.
4. Overriding method (method of child class) can throw any unchecked exceptions, regardless of whether the overridden method(method of parent class) throws any exception or not. However the overriding method should not throw checked exceptions that are new or broader than the ones declared by the overridden method.
5. If a class is extending an abstract class or implementing an interface then it has to override all the abstract methods unless the class itself is a abstract class

Example of Overriding in Java:

public class OverrideBaseClass {

public int add (int a,int b){

int c= a+b;

return c;

}

}

public class OverridingChildClass extends OverrideBaseClass {

public int add (int a,int b){

System.out.println("Addition is " +super.add(5,6));

int c= a+b+5;

return c;

}

public static void main(String[] args) {

OverrideBaseClass overr = new OverridingChildClass();

System.out.println("Addition is " + overr.add(5,6));

}

}

Output: 

Addition is 11

Addition is 16