1. Introduction
This article lays the foundations of object-oriented programming (OOP). You will learn what object-oriented programming is and what differentiates it from other programming models. You will also learn some key OOP concepts like inheritance, polymorphism, encapsulation, and abstraction.
2. Prerequisites
To complete the following tutorial, you will need :
- The Java SE Development Kit 17 (JDK 17): If you don’t have it already refer to this tutorial for the installation procedure.
- IntelliJ IDEA: If you don’t have it already refer to this tutorial for the installation procedure.
3. Object-Oriented Programming
Object-oriented programming (OOP) is a programming paradigm inspired by real life. In this paradigm, a program is designed as a set of objects that interact with each other. An object is characterized by its properties (attributes) and its behaviors (methods). OOP is opposed to other programming paradigms including procedural programming, functional programming
Object-oriented programming (OOP) is popular because it promotes code modularity, reusability, encapsulation, and abstraction. It simplifies complex systems, supports code organization, and models real-world scenarios effectively.
4. Encapsulation
Encapsulation is the ability of an object to hide its internal structure from other objects. The object thus only exposes public interfaces through which others can interact with it. All this allows the object to be able to modify its internal structure without impacting other objects. The use of access modifiers is a means of implementing encapsulation.
The most common way to implement encapsulation is through the use of accessors. The best practice is to keep the attributes of a class private and make them accessible only via accessors.
class Circle{
//private field, not accessible from outside
private double radius;
//Changing the field is only possible via this public setter method : Encapsulation!
public void setRadius(double radius){
if(radius > 0){
this.radius = radius;
}else{
System.out.println("Invalid radius value : Must be positive!");
}
}
public double getRadius(){
return this.radius;
}
}
5. Polymorphism
Polymorphism is the ability for the same object to take several different forms. In Java, You can implement polymorphism through 2 mechanisms: method overloading and method overriding.
5.1. Method Overloading
Method overloading is a mechanism that allows a class to have multiple methods with the same name but different parameters. The Java compiler then determines which of the methods to invoke based on the number, types, and order of the method’s parameters. Method overloading is a form of compile-time polymorphism or static polymorphism.
In the example below the “add” method of the “Calculator” class is overloaded 4 times.
class Calculator{
public int add(int a, int b){
return a + b;
}
public double add(double a, double b){
return a + b;
}
public float add(float a, float b){
return a + b;
}
public double add(double a, double b, double c){
return a + b + c;
}
public static void main(String[] args) {
Calculator calculator = new Calculator();
System.out.println(calculator.add(1,2));//Calling the method: int add(int a, int b)
System.out.println(calculator.add(1.3,2.3)); //Calling the method: double add(double a, double b)
System.out.println(calculator.add(1f,2f)); //Calling the method: float add(float a, float b)
System.out.println(calculator.add(1.4,2.6,3.8)); //Calling the method: double add(double a, double b, double c)
}
}
5.2. Method Overriding
Method overriding is a feature of the Java language that allows a child class (subclass) to provide a specific implementation to a method already defined in the parent class (superclass). When a subclass provides a specific implementation for a method that is already present in its parent class, it is said to override the method. Method overloading is a form of run-time polymorphism or dynamic binding.
class Animal{
void makeSound(){
System.out.println("I don't know");
}
}
class Dog extends Animal{
void makeSound(){
System.out.println("Wouf Wouf");
}
}
class Cat extends Animal{
void makeSound(){
System.out.println("Meow Meow");
}
}
class TestOverride{
public static void main(String[] args){
Animal dog = new Dog();//Runtime polymorphism
Animal cat = new Cat();//Runtime polymorphism
dog.makeSound();//Calling the overridden method in Dog class
cat.makeSound();//Calling the overridden method in Cat class
}
}
6. Inheritance
Inheritance is an object-oriented programming mechanism that allows a class called a child class to inherit the attributes and methods of another class called a parent class. This concept makes code factorization possible, promoting code reuse, modularity, and the creation of a hierarchy between classes.
class Animal{
void eat(){
System.out.println("Animal is eating");
}
}
class Cat extends Animal{
void makeSound(){
System.out.println("Meow Meow");
}
}
class TestInheritance{
public static void main(String[] args){
Cat cat = new Cat();
cat.eat();//The eat() method is inherited from the parent class Animal
cat.makeSound();//The makeSound() is specific to the child class Cat
}
}
7. Abstraction
In software engineering and computer science, abstraction is the process of generalizing concrete details, such as attributes, away from the study of objects and systems to focus attention on details of greater importance. The goal of abstraction is to focus on the relevant aspects of an object while ignoring unnecessary details.
Some of the ways of achieving abstraction are :
- Usage of abstract data types: Abstract classes and interfaces
- Reorganizing common behavior from groups of non-abstract classes into abstract classes using inheritance and sub-classes,
// Abstract class representing an abstract shape
abstract class Shape {
// Abstract method for calculating area
abstract double calculateArea();
// Concrete method for displaying a message
void displayMessage() {
System.out.println("This is a shape.");
}
}
// Concrete class representing a specific shape (Circle)
class Circle extends Shape {
private double radius;
Circle(double radius) {
this.radius = radius;
}
@Override
double calculateArea() {
return Math.PI * radius * radius;
}
}
public class TestAbstraction {
public static void main(String[] args) {
// Creating an object of the Circle class
Circle circle = new Circle(5.0);
// Using abstraction to calculate the area
double area = circle.calculateArea();
System.out.println("Area of the circle: " + area);
// Using abstraction to display a message
circle.displayMessage();
}
}
7. Conclusion
In this article, you learned what object-oriented programming is and what makes it different from other programming paradigms. You also learned some important concepts of OOP i.e. inheritance, encapsulation, polymorphism, and abstraction.
8. References
1) OCP Oracle Certified Professional Java SE 17 by Khalil A. Mughal and Vasily A. Strelnikov
2) Oracle Java Documentation
Pingback: Inheritance in Java: Building on Basics for Powerful Programming
Pingback: How to Fix UnsupportedOperationException In Java