OOPs Concept For Automation

The java.util package contains all the classes and interfaces of Collection Framework. 

Two Main root interfaces : Collection & Map 

Parent Interface of Collection is Interable

Iterable Interface  :-The Iterable interface is the root interface for all the collection classes and all the collection class implement the Iterable interface.

Iterator<T> iterator();

Iterator interface provides the facility of iterating the elements in a forward direction only.

// Returns true if the iteration has more elements

public boolean hasNext();

// Returns the next element in the iteration

// It throws NoSuchElementException if no more 

// element present

public Object next();

// Remove the next element in the iteration

// This method can be called only once per call

// to next()

public void remove();

interface Collection<E> extends Iterable<E>

interface Map<K,V>

Collection : Root interface with basic methods like add(), remove(), contains(), isEmpty(), addAll(), ... etc.

Set : Doesn't allow duplicates. Example implementations of Set 

      interface are HashSet (Hashing based) and TreeSet (balanced

      BST based). Note that TreeSet implements SortedSet.

List : Can contain duplicates and elements are ordered. Example

       implementations are LinkedList (linked list based) and

       ArrayList (dynamic array based)

Queue : Typically order elements in FIFO order except exceptions

        like PriorityQueue.  

Deque : Elements can be inserted and removed at both ends. Allows

        both LIFO and FIFO. 

Map : Contains Key value pairs. Doesn't allow duplicates.  Example

      implementation are HashMap and TreeMap. 

      TreeMap implements SortedMap.        

The difference between Set and Map interface is that in Set we 

have only keys, whereas in Map, we have key, value pairs.

Array List :-

The important points about Java ArrayList class are:

• Java ArrayList class can contain duplicate elements.
• Java ArrayList class maintains insertion order.
• Java ArrayList class is non synchronized.
• Java ArrayList allows random access because array works at the index basis.
• In Java ArrayList class, manipulation is slow because a lot of shifting needs to occur if any element is removed from the array list

ArrayList<String> list=new ArrayList<String>();//Cr

1.  Iterator itr=list.iterator();  
2.   while(itr.hasNext()){  
3.    System.out.println(itr.next());  
4.   }
5. Second Way : For Each   
6. for(String obj:al)  
7.     System.out.println(obj);  
8.  }  

Linked List :-

The important points about Java LinkedList are:

• Java LinkedList class can contain duplicate elements.
• Java LinkedList class maintains insertion order.
• Java LinkedList class is non synchronized.
• In Java LinkedList class, manipulation is fast because no shifting needs to occur.
• Java LinkedList class can be used as a list, stack or queue.

ArrayList	LinkedList
1) ArrayList internally uses a dynamic array to store the elements.	LinkedList internally uses a doubly linked list to store the elements.
2) Manipulation with ArrayList is slow because it internally uses an array. If any element is removed from the array, all the bits are shifted in memory.	Manipulation with LinkedList is faster than ArrayList because it uses a doubly linked list, so no bit shifting is required in memory.
3) An ArrayList class can act as a list only because it implements List only.	LinkedList class can act as a list and queue both because it implements List and Deque interfaces.
4) ArrayList is better for storing and accessing data.	LinkedList is better for manipulating data.

Java ListIterator Interface

Set in Java

1. Set is an interface which extends Collection. It is an unordered collection of objects in which duplicate values cannot be stored.
2. Basically, Set is implemented by HashSet, LinkedHashSet or TreeSet (sorted representation).
3. Set has various methods to add, remove clear, size, etc to enhance the usage of this interface

HashSet :-

• HashSet stores the elements by using a mechanism called hashing.
• HashSet contains unique elements only.
• HashSet allows null value.
• HashSet class is non synchronized.
• HashSet doesn't maintain the insertion order. Here, elements are inserted on the basis of their hashcode.
• HashSet is the best approach for search operations.
• The initial default capacity of HashSet is 16, and the load factor is 0.75.

Internal working of a HashSet

All the classes of Set interface internally backed up by Map. HashSet uses HashMap for storing its object internally. You must be wondering that to enter a value in HashMap we need a key-value pair, but in HashSet we are passing only one value.

Storage in HashMap

Actually the value we insert in HashSet acts as key to the map Object and for its value java uses a constant variable. So in key-value pair all the keys will have same value.

Implementation of HashSet in java doc:

   private transient HashMap map;

   // Constructor - 1

// All the constructors are internally creating HashMap Object.

   public HashSet()

   {

       // Creating internally backing HashMap object

       map = new HashMap();

   }

   // Constructor - 2

   public HashSet(int initialCapacity)

   {

       // Creating internally backing HashMap object

       map = new HashMap(initialCapacity);

   }

   // Dummy value to associate with an Object in Map

   private static final Object PRESENT = new Object();

 

LinkedHashSet :-

When iterating through a HashSet the order is unpredictable, while a LinkedHashSet lets us iterate through the elements in the order in which they were inserted. When cycling through LinkedHashSet using an iterator, the elements will be returned in the order in which they were inserted.

HashSet : Maintains no order

LinkedHashSet : Maintains insertion order.

TreeSet :-

1. TreeSet implements the SortedSet interface so duplicate values are not allowed.
2. Objects in a TreeSet are stored in a sorted and ascending order.

Two things must be kept in mind while creating and adding elements into a TreeSet:

1. Firstly, insertion of null into a TreeSet throws NullPointerException because while insertion of null, it gets compared to the existing elements and null cannot be compared to any value.
2. Secondly, if we are depending on default natural sorting order, compulsory the object should be homogeneous and comparable otherwise we will get

HashSet Vs TreeSet 

https://www.geeksforgeeks.org/hashset-vs-treeset-in-java/

Java Map Interface :-

A map contains values on the basis of key, i.e. key and value pair. Each key and value pair is known as an entry. A Map contains unique keys. A Map is useful if you have to search, update or delete elements on the basis of a key.

A Map doesn't allow duplicate keys, but you can have duplicate values. HashMap and LinkedHashMap allow null keys and values, but TreeMap doesn't allow any null key or value.

Class	Description
HashMap	HashMap is the implementation of Map, but it doesn't maintain any order.
LinkedHashMap	LinkedHashMap is the implementation of Map. It inherits HashMap class. It maintains insertion order.
TreeMap	TreeMap is the implementation of Map and SortedMap. It maintains ascending order.

Hash Map :-

1. Java HashMap class contains values based on the key.
2. Java HashMap class contains only unique keys.
3. Java HashMap class may have one null key and multiple null values.
4. Java HashMap class is non synchronized.
5. Java HashMap class maintains no order.
6. The initial default capacity of Java HashMap class is 16 with a load factor of 0.75.

Linked Hash Map :-

• Java LinkedHashMap contains values based on the key.
• Java LinkedHashMap contains unique elements.
• Java LinkedHashMap may have one null key and multiple null values.
• Java LinkedHashMap is non synchronized.
• Java LinkedHashMap maintains insertion order.
• The initial default capacity of Java HashMap class is 16 with a load factor of 0.75.

TreeMap :-

The important points about Java TreeMap class are:

• Java TreeMap contains values based on the key. It implements the NavigableMap interface and extends AbstractMap class.
• Java TreeMap contains only unique elements.
• Java TreeMap cannot have a null key but can have multiple null values.
• Java TreeMap is non synchronized.
• Java TreeMap maintains ascending order.

OOPs Concepts :-

Static Block :- Used for memory management 

The static can be:

1. Variable (also known as a class variable)
2. Method (also known as a class method)
3. Block
4. Nested class

The static variable can be used to refer to the common property of all object

Memory : Class Arrea 

Example : In API framework : Base URL is static 

Static Method :- No Need to create object to call method Belongs to class & can change the value of static variable.

Static Block :-

1. Initialize the static variable.
2. It is executed before the main method at the time of classloading
3. static blocks are executed before constructors.

Constructor :-

1. A constructor in Java can not be abstract, final, static and Synchronized.
2. A constructor is invoked at the time of object or instance creation. 
3.  default constructor: A constructor that has no parameter is known as default constructor. If we don’t define a constructor in a class, then compiler creates default constructor(with no arguments) for the class
4. Parameterized Constructor: A constructor that has parameters is known as parameterized constructor. If we want to initialize fields of the class with your own values, then use a parameterized constructor.

Constructor Overloading :-

1. Like methods, we can overload constructors for creating objects in different ways. Compiler differentiates constructors on the basis of numbers of parameters, types of the parameters and order of the parameters.

This keyword : this is a reference variable that refers to the current object

Here is given the 6 usage of java this keyword.

1. this can be used to refer current class instance variable.
2. this can be used to invoke current class method (implicitly)
3. this() can be used to invoke current class constructor.
4. this can be passed as an argument in the method call.
5. this can be passed as argument in the constructor call.
6. this can be used to return the current class instance from the method.

Encapsulation :-

Abstraction 

Hide internal implementation and just highlight the set of services, is called abstraction.

Example : ATM Machine & get() DriverManager API. 

Two ways to achieve abstraction in java

1. Abstract class (0 to 100%)
2. Interface (100%)

Abstract Class :-A class which is declared as abstract is known as an abstract class

1. An abstract class must be declared with an abstract keyword.
2. It can have abstract and non-abstract methods.
3. It cannot be instantiated.
4. It can have constructors and static methods also.
5. It can have final methods which will force the subclass not to change the body of the method.
6. A method defined abstract must always be redefined in the subclass,thus making overriding compulsory OR either make subclass itself abstract.
7. Avoids code duplication and increases reusability.
8. Helps to increase security of an application or program as only important details are provided to the user.
9. No. its not possible to declare abstract method with private .
10. No. its not possible to declare abstract method with final keyword.
11. No. its not possible to declare abstract method with static keyword.
12. Yes we can declare abstract methods as protected.
13. public,  protected and default are valid.
14. static,  final and private are invalid.

Live Example :- Common functions class hold -> like scroll ,click,wait and extend Pages class

InterFace 

Interfaces specify what a class must do and not how.

1. it is used to achieve total abstraction.
2. Since java does not support multiple inheritance in case of class, but by using interface it can achieve multiple inheritance .
3. It is also used to achieve loose coupling.
4. Interfaces are used to implement abstraction. So the question arises why use interfaces when we have abstract classes?
   The reason is, abstract classes may contain non-final variables, whereas variables in interface are final, public and static.

New Feature Added in JDK 8 :-

1. Default Method
2. Static methods

OverLoading & OverRiding :-

OverLoading (Compile time Polymorphism)-> Happen within class & increases the readability of the program.

There are two ways to overload the method in java

1. By changing number of arguments
2. By changing the data type

Example :- Expectedcondition -> Class in Selenium

OverLoaded Functions :

1.  elementToBeClickable(By locator)
2. An expectation for checking an element is visible and enabled such that you can click it.
3. elementToBeClickable(WebElement element)
4. An expectation for checking an element is visible and enabled such that you can click it.

Overriding :- Happen in case of Inheritance 

1. Method overriding is used to provide the specific implementation of a method which is already provided by its superclass.
2. Method overriding is used for runtime polymorphism

Example : Click function present in helper class need to change body in page class

 

Super :-

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

Final Keyword :-

Final Variable :- If you make any variable as final, you cannot change the value of final variable(It will be constant).

Final Method : (To Stop overriding )If you make any method as final, you cannot override it.

Final Class : (To Stop Inheritance) If you make any class as final, you cannot extend it.

Is final method inherited? : Yes, final method is inherited but you cannot override it.

Can we initialize blank final variable: Only in constructor

Access Modifiers in Java

1. Private: The access level of a private modifier is only within the class. It cannot be accessed from outside the class.
2. Default: The access level of a default modifier is only within the package. It cannot be accessed from outside the package. If you do not specify any access level, it will be the default.
3. Protected: The access level of a protected modifier is within the package and outside the package through child class. If you do not make the child class, it cannot be accessed from outside the package.
4. Public: The access level of a public modifier is everywhere. It can be accessed from within the class, outside the class, within the package and outside the package.

If you make any class constructor private, you cannot create the instance of that class from outside the class.

Exception 

Exception : Parent class : Throwable 

Throwable - > Error & Exception 

Checked Exception : Checked at compile time.The classes which directly inherit Throwable class except RuntimeException and Error are known as checked exceptions e.g. IOException, SQLException etc

Unchecked Exception : Classes which extends RuntimeException are known as unchecked exceptions

Eg. ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException etc.

Java throw keyword is used to explicitly throw an exception.

Java throws keyword is used to declare an exception.

1. void m()throws ArithmeticException{  
2. throw new ArithmeticException("sorry");  
3. }  

)	Final is used to apply restrictions on class, method and variable. Final class can't be inherited, final method can't be overridden and final variable value can't be changed.	Finally is used to place important code, it will be executed whether exception is handled or not.	Finalize is used to perform clean up processing just before object is garbage collected.
2)	Final is a keyword.	Finally is a block.	Finalize is a method.