Object Oriented Programming Concepts in a MindMap

 

Understanding Object-Oriented Programming (OOP) is fundamental for modern software development. OOP concepts, such as classes and objects, encapsulation, inheritance, and polymorphism, allow developers to create modular, reusable, and maintainable code. 

MindMap Representation of OOP's Concept

Object-Oriented Programming (OOP) is a programming paradigm that uses "objects" to design applications and computer programs.

Understanding Class

Class in Java is a  blueprint of attributes and behavior (actions) of an object.

Below are the members of a class:

• Class Variables (Static Fields): These are common to all instances of a class and are declared with the `static` modifier. 

• Instance Variables (Non-static Fields): These are unique to each instance of a class. Following the `Bicycle` example, `cadence`, `gear`, and `speed` would be instance variables, with each `Bicycle` object having its own copy.

• Methods: These are functions that define the behavior of the objects created from the class. They can be static (class methods) or non-static (instance methods).

• Constructors: Special methods used to initialize new objects. They have the same name as the class and may take parameters to set initial values for the instance variables.

• Nested Classes: Classes can contain other classes, known as nested classes.

Principle of OOPs concept:

•  Encapsulation: Bundling the data with the code that manipulates it

• Bundling data (variables) and methods (functions) that operate on the data into a class. 
• Access to the data is restricted and controlled through public methods known as getters and setters. 
• Allows for data hiding, where internal workings of a class are hidden from outside  interference and misuse. 
• Promotes modularity and maintainability of code 
• Enhances data security, as only approved methods can modify the internal state of objects.

• Data Types 

• Public: accessible from any other class, not just the class in which it is declared.
• Protected: accessible within its own class and by derived classes.
• Private: accessible within the class in which it is declared, and not from any other class.

• Abstraction: Hiding complex realities while exposing only the necessary parts.
• Achieved through abstract classes and interfaces, allowing for the creation of classes that cannot be instantiated on their own but can be sub classed.
• Abstract classes may contain abstract methods without a body; these methods must be implemented by subclasses.
• An interface is a blueprint for a class
•  Include abstract methods and constants.
• Used to achieve abstraction and multiple inheritance, as a class can implement multiple interfaces.
• Class implementing an interface must override all of its methods.
• Interfaces cannot be instantiated—they can only be implemented by classes or extended by other interfaces.

• Inheritance: Allowing new objects to take on the properties of existing one.

• Inheritance in Java allows one class to inherit the features (fields and methods) of another class.
• Syntax for inheritance uses the `extends` keyword
• Java supports different types of inheritance: single, multilevel, and hierarchical.
• Multiple inheritance is not supported in Java through classes, but it can be achieved using interfaces.

• Polymorphism: Allows objects to take on multiple forms.
• Manifests in two primary forms: compile-time (static) and runtime (dynamic) polymorphism.
• Compile-time polymorphism is achieved through method overloading, where multiple methods have the same name but different parameter lists.
• Runtime polymorphism is realized through method overriding, where a subclass provides a specific implementation of a method that is already defined in its superclass.

Java for Selenium - Mindmap Object, Classes and Inheritance

In the above example. We create a class bicycle which is defined by it's state and behavior.

members and methods are defined in the class. We can defined multiple objects of the class using class methods and members. 

Bicycle itself belongs to two wheeler class. Similarly there can be other class for motor bike which can have its own member and methods defined. 

Both bicycle and two wheeler can have specific methods and members defined in the class. 

Bicycle extends two wheeler which in turn extends vehicle, bicycle can use members and methods defined in two wheeler as well as vehicle class.

Class Declaration

class Bicycle extends TwoWheeler {
    // field, method and constructordeclarations
}

class TwoWheeler extends Vehicle {
    // field, method and constructordeclarations
}

Variables in a class:

Fields - Member variables in class
Local variable - defined inside method or block of scope
Parameters - variables in method declaration

Variable declaration : [Modifier] Type variablename

Adding dependencies to maven for selenium

To add dependencies in maven project for running selenium tests, we can add dependencies under dependencies section as shown below:

1. Go to https://mvnrepository.com

2. Add Below dependencies:

a. TestNG

<dependency>
    <groupId>org.testng</groupId>
    <artifactId>testng</artifactId>
    <version>6.13.1</version>
    <scope>test</scope>
</dependency>

b. Selenium-java

<dependency>
    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <version>3.8.1</version>
</dependency>

c. Selenium chrome driver

<dependency>
    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-chrome-driver</artifactId>
    <version>3.8.1</version>
</dependency>

3. All the other dependencies related to selenium can be found at:
http://www.mvnrepository.com/artifact/org.seleniumhq.selenium

4. The dependencies are associated with the tests and downloaded at m2 folder in users folder