Java OOP

Java is an object-oriented programming language that emphasizes the use of objects to represent real-world concepts. In Java, everything is an object, and the basic building blocks of Java programs are classes and objects. In this blog, we will explore Java’s object-oriented programming concepts, including encapsulation, inheritance, and polymorphism, with example code snippets.

Encapsulation:

Encapsulation is the process of hiding the internal details of an object and only exposing the necessary functionality to the outside world. In Java, encapsulation is achieved through the use of access modifiers, such as public, private, and protected, to restrict access to class members.

Example:

public class BankAccount {
   private int balance;
   
   public void deposit(int amount) {
      balance += amount;
   }
   
   public void withdraw(int amount) {
      if (balance >= amount) {
         balance -= amount;
      }
   }
   
   public int getBalance() {
      return balance;
   }
}

In the above example, we create a BankAccount class with a private balance variable and three public methods: deposit, withdraw, and getBalance. The balance variable is only accessible within the BankAccount class, while the methods provide controlled access to the variable.

Inheritance:

Inheritance is the process of creating a new class by inheriting properties and methods from an existing class. In Java, inheritance is achieved through the use of the extends keyword to create a subclass.

Example:

public class Animal {
   public void eat() {
      System.out.println("Eating");
   }
}

public class Dog extends Animal {
   public void bark() {
      System.out.println("Barking");
   }
}

public class Main {
   public static void main(String[] args) {
      Dog dog = new Dog();
      dog.eat(); // output: Eating
      dog.bark(); // output: Barking
   }
}

In the above example, we create an Animal class with an eat method, and a Dog class that extends the Animal class and adds a bark method. We then create a new Dog object in the main method and call both the eat and bark methods.

Polymorphism:

Polymorphism is the process of using a single method or variable to represent different types of objects. In Java, polymorphism is achieved through the use of method overloading and method overriding.

Example:

public class Animal {
   public void makeSound() {
      System.out.println("Animal sound");
   }
}

public class Dog extends Animal {
   public void makeSound() {
      System.out.println("Bark");
   }
}

public class Cat extends Animal {
   public void makeSound() {
      System.out.println("Meow");
   }
}

public class Main {
   public static void main(String[] args) {
      Animal dog = new Dog();
      Animal cat = new Cat();
      dog.makeSound(); // output: Bark
      cat.makeSound(); // output: Meow
   }
}

In the above example, we create an Animal class with a makeSound method, and two subclasses, Dog and Cat, that override the makeSound method. We then create two new Animal objects, one Dog and one Cat, and call the makeSound method on each.

Conclusion:

Java’s object-oriented programming concepts, including encapsulation, inheritance, and polymorphism, are essential to writing effective and efficient Java programs. With the examples provided, you can get started with Java OOP and take your programming skills to the next level.