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 :

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

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.

How to play with 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)
     {




      }