Resume Highlights:
--------------------------
Having 7+ years of experience in Manual and Automation Testing.
Experience in Selenium WebDriver using Core Java.
Experience in designing the Java Frameworks like Testng.
Experience in designing the automation frameworks like Data-driven and Modular
Driven using Page Object Model.
Hands-on-Experience in performing cross browser testing using Testng and Grid.
Good Knowledge in HTML and XML.
Experience in understanding and writing testcases.
Responsbilities:
------------------
Performed regression and sanity testing for the project.
Raised the bugs in Bugzilla/Jira.
Provide the logs and screenshots while raising the bugs which gives
more information to developer to fix the defect on-time.
Design the Framework using ...
Automate the testcases using Selenium Webdriver with Java Framework Testng.
Report the results to the stake holders.
Invovled in the module of the project.
Worked effeciently to make sure the project is released on time with high quality.
Objective: Find out the reusable methods and create a super class for all the browsers like IE,FF,CH.
public abstract class WebDriver
{
public abstract void openBrowser(String url);
public abstract void closeBrowser();
}
Interface Definition:
-----------------------------
If the class contains 100% abstract methods then the class is defined as interface.
public interface WebDriver
{
public void open(String url);
public void close();
}
1. An interface contains 100% abstract methods.
2. In interface methods are by default public and abstract.
public interface WebDriver
{
void open(String url);
public abstract void close();
}
3. In interface, variables are 'public static final' by default.
public ->Accessible everywhere
static->Classname.variable
final->Constant. Once intialized we cannot re-assign the new value;
4. The final variables in interface are intialized at the time of declaration.
int i;//declaration
i=10;//intialization or Assignment
int i =10;//Declaration and intialization.
5.A class uses an interface should use an keyword called 'implements'.
IE,FF,CH
public class IEDriver implements WebDriver
{
void open(String url){}
public void close(){}
}
public class FFDriver implements WebDriver
{
void open(String url){}
public void close(){}
}
public class CHDriver implements WebDriver
{
void open(String url){}
public void close(){}
}
6. A class can implement multiple interfaces, but extends only one class at a time.
A interface extends an another interfaces
7. A class together can use implements and extends keywords together.
public class ThreadEx extends ClassB implements Runnable,InterfaceA
{
}
If a class is implementing an interfaces then we can write as follows:
InterfaceName refV = new ClassName();
WebDriver driver = new FFDriver();
driver.open("http://www.google.com");
driver.close();
final variables are constants
--------------------------------------
public final int i =20;
i=10;// not possible i is final
final classes cannot be extended
----------------------------------------
public final class String
{
}
public class A extends String// cannot extend an final class
{
}
final methods cannot be overriden
--------------------------------------------
public final void equals()
{
}
@Override:
-------------------
Whenever the same method name with same parameters available in the super class and
subclass or interface and subclasses.. those methods are overriden methhods.
@Override is an annotation which is an special instruction to the compiler.
Advantages of re-usability:
1. Save time and effort
2. Maintenance of code is easy means if you want to modify the code. We will change the code in one place.
OOPs Concept Inheritance:
1. The objective of inheritance is re-usability.
2. The process of acquiring the methods and variables from Super-class to Sub-Class is called Inheritance.
Class members are methods and variables.
Two types of class members -> static and nonstatic
Static Members are accessed using Class Name:
public static void display()
{
}
Non-Static Members are accessed using Object:
public void display()
{
}
Only object level class members are inherited to subclass.
3. Inheritance is achieved between two classes using the keyword called 'extends'. From now on-wards 'extends' means inheritance.
4. Single Inheritance is between two classes is achieved using the extends keyword
Class A
{
public int i=20;
public void display()
{
}
}
Class B extends ClassA
{
}
5. Multilevel Inheritance : mean the subclass(child) can access superclass(Father) and Superclass SuperClass (GrandFather) also.
Class A
{
}
Class B extends Class A
{
}
Class C extends Class B
{
}
6. Multiple Inheritance:
In java we cannot extend more than one class at a time.
Multiple classes cannot be inherited at the same time.
So, multiple inheritance is not supported in java.
Class C extends Class B,Class A //Not Valid in java
Diamond Problem in java.
7. By Default a Class extends Object Class. So we can access the object class Members. Object is a class available in the package java.lang.
8. Only non-static variables and methods are inherited to the subclass. Static variables and Methods are at the class level not at the object level. So cannot be inherited to the subclass.
9. Global and Local Variables
public class Variables {
int a = 20; // Global variable
public static void main(String[] args) {
int a =10;
System.out.println(a); // local variable
Variables v = new Variables();
System.out.println(v.a);
}
}
.png)
