Java - Garbage Collection

Java Garbage Collection:

Advantage of Garbage Collection

• It makes java memory efficient because garbage collector removes the unreferenced objects from heap memory.
• It is automatically done by the garbage collector(a part of JVM) so we don't need to make extra efforts.

In java, garbage means unreferenced objects.
Garbage Collection is process of reclaiming the runtime unused memory automatically. In other words, it is a way to destroy the unused objects.
In java it is performed automatically. So, java provides better memory management.

The finalize() method is invoked each time before the object is garbage collected. This method can be used to perform cleanup processing. This method is defined in Object class as:

protected void finalize(){}

Note: The Garbage collector of JVM collects only those objects that are created by new keyword. So if you have created any object without new, you can use finalize method to perform cleanup processing (destroying remaining objects).

Java - Interface

Interface :

An interface is a collection of abstract methods. A class implements an interface, thereby inheriting the abstract methods of the interface.
The interface in java is a blueprint of a class. It has static constants and abstract methods only.
The interface in java is a mechanism to achieve fully abstraction.  There can be only abstract methods in the java interface.

The java compiler adds public and abstract keywords before the interface method and public, static and final keywords before data members.

An interface is different from a class in several ways, including:

• You cannot instantiate an interface.
• An interface does not contain any constructors.
• All of the methods in an interface are abstract.
• An interface cannot contain instance fields. The only fields that can appear in an interface must be declared both static and final.
• An interface is not extended by a class; it is implemented by a class.
• An interface can extend multiple interfaces.

Class and Interface:

• Class can Extend another Class
• Class can Implement Interface
• Interface can Extend another Interface

Multiple inheritance in Java by interface:

If a class implements multiple interfaces, or an interface extends multiple interfaces i.e. known as multiple inheritance.

A Java class can only extend one parent class. Multiple inheritance is not allowed. Interfaces are not classes, however, and an interface can extend more than one parent interface.
The extends keyword is used once, and the parent interfaces are declared in a comma-separated list.

For example, if the Cricket interface extended both Sports and Event, it would be declared as:

public interface Hockey extends Sports, Event

• Class1 implements Interface 1 and Interface 2  or
• Interface1 extends Interface2 and Interface3

Marker or tagged interface:

An interface that have no member is known as marker or tagged interface. For example: Serializable, Cloneable, Remote etc. They are used to provide some essential information to the JVM so that JVM may perform some useful operation.

Java- super Keyword

super keyword in java

The super keyword in java is a reference variable that is used to refer immediate parent class object.
Whenever you create the instance of subclass, an instance of parent class is created implicitly i.e. referred by super reference variable.

Usage of java super Keyword

1. super is used to refer immediate parent class instance variable.
2. super() is used to invoke immediate parent class constructor.
3. super is used to invoke immediate parent class method.

Without super keyword...
class Vehicle{
  int speed=50;
}
class Bike3 extends Vehicle{
    int speed=100;
    void display(){
    System.out.println(speed);//will print speed of Bike
  }
  public static void main(String args[]){
    Bike3 b=new Bike3();
    b.display();
  }
}
Output : 100

With super keyword...

//example of super keyword
class Vehicle{
  int speed=50;
}
class Bike4 extends Vehicle{
  int speed=100;
   
  void display(){
   System.out.println(super.speed);//will print speed of Vehicle now
  }
  public static void main(String args[]){
   Bike4 b=new Bike4();
   b.display();
  
  }
}
Output : 50

 

Java - Inheritance

Inheritance : 

Inheritance in java is a mechanism in which one object acquires all the properties and behaviors of parent object.
The idea behind inheritance in java is that you can create new classes that are built upon existing classes. When you inherit from an existing class, you can reuse methods and fields of parent class, and you can add new methods and fields also.
Inheritance represents the IS-A relationship, also known as parent-child relationship.

A class that is derived from another class is called a subclass (also a derived class, extended class, or child class). The class from which the subclass is derived is called a superclass (also a base class or a parent class).

The idea of inheritance is simple but powerful: When you want to create a new class and there is already a class that includes some of the code that you want, you can derive your new class from the existing class. In doing this, you can reuse the fields and methods of the existing class without having to write (and debug!) them yourself.

What We Can Do in a Subclass

A subclass inherits all of the public and protected members of its parent, no matter what package the subclass is in. If the subclass is in the same package as its parent, it also inherits the package-private members of the parent. You can use the inherited members as is, replace them, hide them, or supplement them with new members:

• The inherited fields can be used directly, just like any other fields.
• You can declare a field in the subclass with the same name as the one in the superclass, thus hiding it (not recommended).
• You can declare new fields in the subclass that are not in the superclass.
• The inherited methods can be used directly as they are.
• You can write a new instance method in the subclass that has the same signature as the one in the superclass, thus overriding it.
• You can write a new static method in the subclass that has the same signature as the one in the superclass, thus hiding it.
• You can declare new methods in the subclass that are not in the superclass.
• You can write a subclass constructor that invokes the constructor of the superclass, either implicitly or by using the keyword super.

Java- Exceptions

Exception in Java:  An exception is a problem that arises during the execution of a program. Exceptions are caught by handlers positioned along the thread's method invocation stack.

Some of these exceptions are caused by user error, others by programmer error, and others by physical resources that have failed in some manner.
To understand how exception handling works in Java, you need to understand the three categories of exceptions

• Checked exceptions: A checked exception is an exception that is typically a user error or a problem that cannot be foreseen by the programmer. For example, if a file is to be opened, but the file cannot be found, an exception occurs. These exceptions cannot simply be ignored at the time of compilation.
• Runtime exceptions: A runtime exception is an exception that occurs that probably could have been avoided by the programmer. As opposed to checked exceptions, runtime exceptions are ignored at the time of compilation.
• Errors: These are not exceptions at all, but problems that arise beyond the control of the user or the programmer. Errors are typically ignored in your code because you can rarely do anything about an error. For example, if a stack overflow occurs, an error will arise. They are also ignored at the time of compilation.

Checked vs Unchecked Exceptions in Java

In Java, there two types of exceptions:
1) Checked: are the exceptions that are checked at compile time. If some code within a method throws a checked exception, then the method must either handle the exception or it must specify the exception using throws keyword.
For example, consider the following Java program that opens file at locatiobn “C:\test\a.txt” and prints first three lines of it. The program doesn’t compile, because the function main() uses FileReader() and FileReader() throws a checked exception FileNotFoundException. It also uses readLine() and close() methods, and these methods also throw checked exception IOException

import java.io.*; class Main {   public static void main(String[] args) {      FileReader file = new FileReader("C:\\test\\a.txt");      BufferedReader fileInput = new BufferedReader(file);      // Print first 3 lines of file "C:\test\a.txt"      for (int counter = 0; counter < 3; counter++)        System.out.println(fileInput.readLine());     fileInput.close();   } } To fix the above program, we either need to specify list of exceptions using throws, or we need to use try-catch block. We have used throws in the below program. Since FileNotFoundException is a subclass of IOException, we can just specify IOException in the throws list and make the above program compiler-error-free. import java.io.*;   class Main {      public static void main(String[] args) throws IOException {          FileReader file = new FileReader("C:\\test\\a.txt");          BufferedReader fileInput = new BufferedReader(file);          // Print first 3 lines of file "C:\test\a.txt"         for (int counter = 0; counter < 3; counter++)           System.out.println(fileInput.readLine());         fileInput.close();       }    } 2) Unchecked (Runtime)  : are the exceptions that are not checked at compiled time. In C++, all exceptions are unchecked, so it is not forced by the compiler to either handle or specify the exception. It is up to the programmers to be civilized, and specify or catch the exceptions. In Java exceptions under Error and RuntimeException classes are unchecked exceptions, everything else under throwable is checked.  Consider the following Java program. It compiles fine, but it throws ArithmeticException when run. The compiler allows it to compile, because ArithmeticException is an unchecked exception. class Main {     public static void main(String args[]) {       int x = 0;       int y = 10;      int z = y/x;     } } Exception handling: Exception Handling is a mechanism to handle runtime errors such as ClassNotFound, IO, SQL, Remote etc.

Java- Class and its Variables

Class:

A class is a blue print from which individual objects are created. A class can contain fields and methods to describe the behavior of an object.
A class consist of Local variable, instance variables and class variables.

Local variable:
Variables defined inside methods, constructors or blocks are called local variables. The variable will be declared and initialized within the method and it will be destroyed when the method has completed.

Instance variable:
Instance variables are variables within a class but outside any method. These variables are instantiated when the class is loaded.

Class variables:
These are variables declared with in a class, outside any method, with the static keyword.

Instance Variable	Class Variable
Instance variables are declared in a class, but outside a method, constructor or any block	Class variables also known as static variables are declared with the static keyword in a class, but outside a method, constructor or a block.
Instance variables are created when an object is created with the use of the keyword 'new' and destroyed when the object is destroyed.	Static variables are created when the program starts and destroyed when the program stops.
Instance variables can be accessed directly by calling the variable name inside the class. However, within static methods (when instance variables are given accessibility), they should be called using the fully qualified name. ObjectReference.VariableName.	Static variables can be accessed by calling with the class name ClassName.VariableName.
Instance variables hold values that must be referenced by more than one method, constructor or block, or essential parts of an object's state that must be present throughout the class.	There would only be one copy of each class variable per class, regardless of how many objects are created from it.

Java- Objects

Objects in Java:

Let us now look deep into what are objects. If we consider the real-world we can find many objects around us, Cars, Dogs, Humans, etc. All these objects have a state and behavior.

If we consider a dog, then its state is - name, breed, color, and the behavior is - barking, wagging, running

If you compare the software object with a real world object, they have very similar characteristics.

Software objects also have a state and behavior. A software object's state is stored in fields and behavior is shown via methods.An object is an instance of a class.

So in software development, methods operate on the internal state of an object and the object-to-object communication is done via methods.

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.

Selenium - 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);

Selenium - 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

Java- Static Keyword

Java- Static Keyword

The static keyword can be used in 3 scenarios:

• static variables
• static methods
• static blocks of code

1. Static Variable :

When a variable is declared with the keyword “static”, its called a “class variable”. All instances share the same copy of the variable. A class variable can be accessed directly with the class, without the need to create a instance.

Without the “static” keyword, it’s called instance variable, and each instance of the class has its own copy of the 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-name>.<variable-name>

2. Static Method:

Any method defined as Static can be called without creating an object of class. The best example is main method , as at the start of execution no object created so main method is defined as Static.A
static method belongs to class rather than an object of the class

Calling Static Methods

Invoke static methods using the name of the class followed by dot (.), then the name of the method:
classname.staticMethodName(args,...)

There are two main restrictions for the static method. They are:

The static method can not use non static data member or call non-static method directly. this and super cannot be used in static context.

Java- Encapsulation

Encapsulation :

To define what level of information share with other word in Java is called Encapsulation. Access restriction level is achieved by Access modifiers (Privet, Public, Package, Protected), These are 4 Ps of Object oriented program .Encapsulation in java is a process of wrapping code and data together into a single unit.

Access Modifiers :

Java provides access modifiers to set access levels for classes, variables, methods and constructors. A member has package or default accessibility when no accessibility modifier is specified.

Four access modifier available in Java as Package Privet, Protected, Public.
Package access modifier is default access modifier, that means if we don't use any access modifier then Package level restriction will be applied.
Public Access modifier is the least restrictive where as Privet is most restrictive.
There are many non-access modifiers such as static, abstract, synchronized, native, volatile, transient etc. Here, we will learn access modifiers.

Modifier	Class	Package	Subclass	World
Public	Y	Y	Y	Y
Protected	Y	Y	Y	N
Package	Y	Y	N	N
Private	N	Y	N	N

1. Public Access Modifier:

Public access modifier is least restrictive and class ,method ,interface and variables with this access modifier are accessible from any class in Java.

However if the public class we are trying to access is in a different package, then the public class still need to be imported.
Because of class inheritance, all public methods and variables of a class are inherited by its sub classes.

2. Package Access Modifier (default):

If we don't use any access modifiers than Default access modifier Package is considered by default. In this case class ,method and variable will be access withing same package. we can not use class, method and variable defined as package or no access modifiers outside package.

3. Protected Access Modifier :

The protected access modifier is accessible within package and outside the package but through inheritance only. The protected access modifier can be applied on the data member, method and constructor. It can't be applied on the class.
Variables, methods and constructors which are declared protected in a superclass can be accessed only by the subclasses in other package or any class within the package of the protected members' class.
The protected access modifier cannot be applied to class and interfaces. Methods, fields can be declared protected, however methods and fields in a interface cannot be declared protected.
Protected access gives the subclass a chance to use the helper method or variable, while preventing a nonrelated class from trying to use it.

4. Privet Access Modifier :

Methods, Variables and Constructors that are declared private can only be accessed within the declared class itself.
Private access modifier is the most restrictive access level. Class and interfaces cannot be private.
Variables that are declared private can be accessed outside the class if public getter methods are present in the class.
Using the private modifier is the main way that an object encapsulates itself and hide data from the outside world.

Java- Polymorphism

Polymorphism : 

Polymorphism is the ability of an object to take on many forms.
The most common use of polymorphism in OOP occurs when a parent class reference is used to refer to a child class object (inheritance).

Polymorphism in java is a concept by which we can perform a single action by different ways. Polymorphism is derived from 2 greek words: poly and morphs. The word "poly" means many and "morphs" means forms. So polymorphism means many forms.
There are two types of polymorphism in java: compile time polymorphism (overloading) and runtime polymorphism (overriding). We can perform polymorphism in java by method overloading and method overriding.

public class Animal{} public class Deer extends Animal {}

Overloading Method : 

Overloading is determined at the compile time. It occurs when several methods have same names with:

      a. Different method signature and different number or type of parameters.
      b.Same method signature but different number of parameters.
      c.Same method signature and same number of parameters but of different type

Overriding Method : 

Overriding occurs when a class method has the same name and signature as a method in parent class. When you override methods, JVM determines the proper methods to call at the program’s run time, not at the compile time.

Some Interview Question:

1.What is polymorphism and what are the types of it?

Polymorphism in java is a concept by which we can perform a single action by different ways. 

Method overloading(compile time polymorphism),method overriding(run time polymorphism)

2.What is method overriding?

Specific implementation of a method for child class.

3.What is method overloading?

If a class have multiple methods by same name but different parameters, it is known as Method Overloading

4.What is static and dynamic binding?

static binding type of object is determined at compile time whereas in dynamic binding type of object is determined at run time.

5.can we overload main() method?

Yes,  we can have many main() methods in a class by overloading the main method.

Java- Overloading Method

Overloading Method : 

              If a class have multiple methods by same name but different parameters, it is known as Method Overloading. Method overloading increases the readability of the program. It is also known as Static Polymorphism or compile time Polymorphism. 

Points to considered for overloading when method name is same:

1. The number of parameters is different for the methods.
2. The parameter types are different (like changing a parameter that was a float to an int). 
3. Sequence of Data type of parameters. 
4. Constructor in Java can be overloaded
5. Overloading can take place in the same class or in its sub-class.

Points when overloading not considered :

1. Just changing the return type of the method.  If the return type of the method is the only thing changed, then this will result in a compiler error.  
2. Changing just the name of the method parameters, but not changing the parameter type.If the name of the method parameter is the only thing changed then this will also result in a compiler error

Example of Overloading : 

As explained earlier overloading done at compile time..

Overloading in same class..

----------------------------------------------------------------------------------------------------

Overloading in Sub Class...

Selenium - Web table in Selenium Webdriver

Web table is a different type of web element and we can not directly get all data in one variable.
To access web table data we need to locate web table using findelement method and then identified all the tr tags using findelements method.
Code for the same as below.

WebDriver driver =  new InternetExplorerDriver();
WebElement table = driver.findElement(By.id("tableid));
List<WebElement> tablerows = table.findElements(By.tagName("tr")); // To get all Rows

int rowcount  =  tablerows.size();  \\To get count of total rows

for (WebElement tablerow : tablerows )
{
tablerowindex = 0;
     List <WebElement> tablecolumns = tablerow.findelements(By.tagName("td"));
     int columncount = tablecolumns.size();
     for (WebElement tablecolumn : tablecolumns)
     {




      }

Selenium - Multiple windows in Selenium Webdriver

Selenium can handle multiple windows using inbuilt method getWindowHandles().
Code for the same as below.

WebDriver driver =  new InternetExplorerDriver();
Set<String> allWindows =  driver,getWindowHandles();

for (String allWindow : allWindows ) {

driver.switchTo().window(allWindow);

if (driver.getTitle().equalsIgnoreCase("VIP Database")){

              driver.manage().window().maximize(); 

              driver.findElement(By.cssSelector("button")).click();

          }

}

Selenium - Implicit wait and Explicit wait in Selenium Webdriver

Difference between Implicit wait and Explicit Wait...

Implicit Wait	Explicit Wait
Implicit wait used for all the element search	Explicit wait is specific to the element and is more flexible compare to Implicit wait.
Implicit wait is time based. where we can command selenium WebDriver to wait for specific time. e.g 30 sec or 1 min and if till given time element not found than throws NoSuchElementexception.	Explicit wait is condition based with time. In this we can command selenium WebDriver to wait for any condition and if condition not satisfied till given time then throws exception
By default Implicit wait is 0.	No default value
We need to provide two parameter to define implicit wait, Time to wait and Unit	Explicit wait is programmatic.
driver.manage().timeouts().implicitlyWait(20, TimeUnit.SECONDS);	WebDriverWait wait = new WebDriverWait(driver, 10); WebElement element = wait.until(ExpectedConditions. elementToBeClickable(By.id("txtuser")));
One drawback of implicit wait is it affects performance of the automation execution as it waits for all the element for given time. And we need to give time of the slowest element to load.	alertIsPresent () elementSelectionStateToBe : elementToBeClickable elementToBeSelected envisibilityOfElementLocated  and many more...

Selenium - Alert, Confirmation message or error message in Selenium WebDriver

Handling of Alert, Confirmation Message or error message while execution is very important for smooth execution.

Alerts:

public class alertWindow {


public static void main(String[] args) {

WebDriver driver = new FirefoxDriver();
WebElement button , textarea = null;
String parentWindowHandle = null;
Wait<WebDriver> wait = null;
Alert alert =null;

driver.get(System.getProperty("user.dir")+ "\\Sample\\Prompt.html");
driver.manage().window().maximize();
//driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
wait = new WebDriverWait(driver, 10);
parentWindowHandle = driver.getWindowHandle();
button = wait.until(ExpectedConditions.elementToBeClickable(By.cssSelector("button")));
button.click();

if (alert != null)
System.out.println("Alert Not found");
else
System.out.println("Alert found");

alert = driver.switchTo().alert();
System.out.println("Alert Text " + alert.getText());

alert.sendKeys("Mohit Jain");
alert.accept();

textarea = wait.until(ExpectedConditions.presenceOfElementLocated(By.id("demo")));
System.out.println(textarea.getText());

button.click();
alert.dismiss();
textarea = wait.until(ExpectedConditions.presenceOfElementLocated(By.id("demo")));
System.out.println(textarea.getText());

driver.quit();

}

}

Confirmation :  

public class confirmationMesg {

/**
* @param args
*/
public static void main(String[] args) {

WebDriver driver = new FirefoxDriver();
WebElement button ,firstname, textarea = null;
String parentWindowHandle = null;
Set<String> allWindows;
Wait<WebDriver> wait = null;
Alert alert =null;
String windowtitle =null;

driver.navigate().to("http://www.ranorex.com/web-testing-examples/vip/");
driver.manage().window().maximize();
firstname =driver.findElement(By.id("FirstName"));
//firstname.sendKeys("Mohit");
button = driver.findElement(By.id("Save"));
parentWindowHandle = driver.getWindowHandle();
button.click();

allWindows = driver.getWindowHandles();
/*
for (String allWindow : allWindows ) {

driver.switchTo().window(allWindow);
if (driver.getTitle().equalsIgnoreCase("VIP Database")){

driver.manage().window().maximize();
driver.findElement(By.cssSelector("button")).click();

}



}
driver.switchTo().window(parentWindowHandle);
firstname.sendKeys("Mohit");*/

for (String allWindow : allWindows ) {

driver.switchTo().window(allWindow);
driver.manage().window().maximize();
if (driver.getTitle().equalsIgnoreCase("VIP Database")){
//driver.close();
driver.quit();
}

}
}