What is Object-Oriented Programming?

Object-Oriented Programming (OOP) is a programming paradigm that revolves around the concept of "objects." These objects are instances of classes, which act as blueprints for creating objects. The key principles of OOP include encapsulation, inheritance, and polymorphism.

Classes and Objects

In Java, everything revolves around classes and objects. A class is like a template or blueprint that defines the properties and behaviors of an object. An object, on the other hand, is an subcategory of a class. Look at the following illustration to see the difference between class and objects:

Another example:

Class 1: Person

// Class representing a Person
          class Person {
              // Properties or attributes
              String name;
              int age;
          
              // Method to display information
              void introduce() {
                  System.out.println("Name: " + name);
                  System.out.println("Age: " + age);
              }
          }

In this code snippet, we have a class called Person that represents a person. It has properties (name, age) and a method (introduce) to display information about the person.

// Main class to run the program
          public class Main {
              public static void main(String[] args) {
                  // Creating an object of the Person class
                  Person myPerson = new Person();
          
                  // Setting object properties
                  myPerson.name = "John Doe";
                  myPerson.age = 25;
          
                  // Calling a method to introduce the person
                  myPerson.introduce();
              }
          }

In this code snippet, we have the Main class, which contains the main method – the entry point for our program. Inside the main method, we create an object of the Person class called myPerson and set its properties. Finally, we call the introduce method to showcase the person's information.

Encapsulation

Encapsulation is the concept of bundling data (attributes) and methods that operate on that data within a single unit, i.e., a class. It helps in hiding the internal details of how an object works. In our Person example, the properties and methods are encapsulated within the class.

Inheritance

Inheritance allows a new class to use the properties and methods of an existing class. It's like a family tree where children inherit features from their parents.

Let's create a new class Student that inherits from Person:

public class Student extends Person {
          
              // Additional attribute for Student
              String studentId;
          
              // Method to display student information
              void displayStudentInfo() {
          
                  System.out.println("Name: " + name);
                  System.out.println("Age: " + age);
                  System.out.println("Student ID: " + studentId);
          
              }
          
          }

public class Main {
                public static void main(String[] args) {
                    Student myStudent = new Student();
                    myStudent.name = "Alice";
                    myStudent.age = 18;
                    myStudent.studentId = "A12345";
            
                    // Calling methods from both Person and Student classes
                    myStudent.displayStudentInfo();
                }
            }

Here, when you create an object of the Student class (myStudent), you pass values for the properties of both the Person (inherited) and Student class. The displayStudentInfo method of the Student class will then display information about the person and the student ID.

This is a simple example to illustrate the concept of inheritance, allowing you to create specialized classes that build upon existing ones. It promotes code reuse and maintains a clear hierarchy in your object-oriented design.

Polymorphism

Polymorphism in Java allows objects of different classes to be treated as objects of a common superclass. This enables you to write more flexible and reusable code. There are two types of polymorphism in Java: compile-time polymorphism (method overloading) and runtime polymorphism (method overriding).

Here's an example of runtime polymorphism, which involves method overriding:

Create Animal Class

class Animal {
              public void makeSound() {
                  System.out.println("Some sound");
              }
          }
          
          // Derived class
          class Dog extends Animal {
              @Override
              public void makeSound() {
                  System.out.println("Woof");
              }
          }
          
          // Another derived class
          class Cat extends Animal {
              @Override
              public void makeSound() {
                  System.out.println("Meow");
              }
          }

Create Main Class

public class Main {
                public static void main(String[] args) {
                    Animal myDog = new Dog();
                    Animal myCat = new Cat();
            
                    myDog.makeSound(); // Output: Woof
                    myCat.makeSound(); // Output: Meow
                }
            }

In this example, both Dog and Cat classes inherit from the makeSound class and override the makeSound method. When you call makeSound on myDog and myCat, the overridden method in each respective subclass is called, demonstrating polymorphic behavior.

Compile-time polymorphism, or method overloading, involves defining multiple methods in the same class with the same name but different parameters. Here's an example:

Create Calculator Class

class Calculator {
                  public int add(int a, int b) {
                      return a + b;
                  }
              
                  public double add(double a, double b) {
                      return a + b;
                  }
              }

Create Main Class

public class Main {
                    public static void main(String[] args) {
                        Calculator calculator = new Calculator();
                
                        System.out.println(calculator.add(1, 2));       // Output: 3
                        System.out.println(calculator.add(1.5, 2.5));   // Output: 4.0
                    }
                }

In this example, the Calculator class has two add methods—one for adding integers and another for adding doubles. The appropriate method is selected based on the arguments provided, showcasing compile-time polymorphism.

These examples illustrate how polymorphism allows you to write more flexible and maintainable code by treating objects of different classes in a uniform way.

Conclusion

Object-Oriented Programming is a powerful paradigm that helps in organizing and structuring code. As you continue your programming journey, these fundamental OOP concepts will become second nature, opening up a world of possibilities for creating efficient and maintainable software.