Object-Oriented Programming is one of the most important programming concepts in Java. It mainly focuses on implementing real-world entities. It is based on the concept of data (variables) and logic (methods). Here the data is encapsulated within objects so that no other part of the code can access the data except methods.
Object and Class
Object : It is an instance of a class that has properties and functions. They are real-world entities.
Class: It is a blueprint of objects. They define the properties and functionalities of the objects.
Advantages of OOPS
1. Modularity: We can compartment the large program into smaller parts for easy understanding. It is similar to having many partitions like a kitchen, study room, etc. in a house, which provides security and reusability.
2. Reusability: Reusing the same function again and again in order to avoid duplication and reusing objects in different programs.
3. Maintainability: It is easy and simple to maintain and update the objects if there is any change in the future.
4. Flexibility: We can add new features to an existing code without modifying it.
Inheritance means a class acquires the properties of another class. A class whose properties are inherited is known as the parent class and a class that inherits the properties of the parent class is known as the child class. Extends keyword is used to inherit a class.
Based on a parent class, a child class is defined. The child class extends from the parent class in order to inherit its properties.
In this example, my father extends my grandfather. He inherits the properties of my grandfather, so he has 2 houses. I extend my father, and I inherited the properties of my father and my grandfather as well. So I have 3 houses.
Types of Inheritance
1. Single Inheritance
In Single Inheritance, a child class extends a single-parent class.
2. Multi-level Inheritance
In Multi-level inheritance, a child class extends a parent class and the parent class extends another parent class.
3. Hierarchical Inheritance
In Hierarchical inheritance, multiple child classes extend a single-parent class.
4. Hybrid Inheritance
In Hybrid inheritance, two or more types of inheritance are combined.
· Java does not support multiple inheritances, but can be achieved by Interfaces concept.
· Object is the super most class. It is automatically inherited for every class. We don’t need to write it extensively.
Honda and BMW extend Car. Car extends Vehicle. FordTruck extends Truck and Truck extends Vehicle.
When I create an object for Honda, I can inherit the properties from Honda as well as Car. But I cannot inherit the properties from Truck.
Abstraction is showing only the relevant information to the user and hiding unnecessary information. The car driver is only concerned about features like start the car, stop the car, accelerator, brake and etc. He/she is not much interested in the internal mechanism.
Any development starts with the design. Similarly, our test script should have a design before implementation. Here design is similar to Interface. Partial implementation is similar to the Abstract class. Full implementation is similar to the Concrete class.
We can achieve Abstraction through Interface. The interface has abstract methods and constants, but not the method body.
There are 2 ways to achieve abstraction. One is Interface, another is Abstract Class.
We can declare an interface using the keyword interface. All the methods in an interface should have an empty body. By default, all the fields are public, static, and final. These methods should be implemented by a class that implements the interface.
2.2 Abstract Class
We can declare an abstract class using the abstract keyword. It can have both abstract (not implemented) and non-abstract methods (already implemented).
Points to remember
1. It is not mandatory to implement an abstract class.
2. An Abstract class has both implemented and unimplemented methods.
3. Multiple inheritances can be achieved by using interfaces.
4. We cannot create an object for an interface, because the interface is a design.
5. A class extends another class. An interface extends another interface. A class implements an interface.
6. We cannot create an object for an abstract class, this is solved by creating an object for a concrete class.
7. An interface can have static and default methods since Java 8. It allows private methods since Java 9.
Interface Name : Mobile.interface
Abstract class name : Android.java
Concrete class name : OnePlus.java which extends Android
Class to call the concrete class: MyMobile.java
Polymorphism means many forms of implementation, and it occurs when we have many classes that are related to each other by inheritance.
There are 2 types of Polymorphism. One is Overloading, another is Overriding.
3.1 Method Overloading
Method Overloading means that a class has multiple methods having the same name, same return type, and same modifier but different arguments (number of arguments, and data type).
3.2 Method Overriding
Method Overriding means that a child class method overrides the parent class method when a child class has the same method as declared in the parent class. Parent method signature should be the same as the child class. It works only with Inheritance. Using method overriding, we can override the old features with new features in a class.
Encapsulation means wrapping up data under a single unit. This data-hiding concept prevents the data from being accessed by the code outside. This helps the data in a class hide from other classes which is achieved by making the members or methods of a class private. These private data can be set and get by public methods in the class.
When the variables are public, anyone can use or modify them. In the below example, anyone can change the creditCardNumber.
When the variables are private, it is hidden from other classes. It can be accessed by using getter and setter methods.
Getter – is used to providing read access.
Setter – is used to providing write access.
In the below example, the creditCardNumber is private. Anyone can read it, but cannot write it.
In this blog, we have covered the 4 pillars of Object Oriented Programming concepts. These concepts aim to implement real-world entities in programs.