Java Object-Oriented Programming (OOP) Tutorial

A class is a blueprint for creating objects, while an object is an instance of a class. Classes define properties (attributes) and behaviors (methods) that objects can have.

• Defining a Class:
  Edit Copy

  public class Car {
      // Attributes (fields)
      String brand;
      String color;
      int year;
  
      // Constructor
      public Car(String brand, String color, int year) {
          this.brand = brand;
          this.color = color;
          this.year = year;
      }
  
      // Method
      public void displayInfo() {
          System.out.println("Brand: " + brand + ", Color: " + color + ", Year: " + year);
      }
  }

• Creating Objects:
  Edit Copy

  public class Main {
      public static void main(String[] args) {
          // Create an object of the Car class
          Car myCar = new Car("Toyota", "Red", 2020);
  
          // Call a method on the object
          myCar.displayInfo(); // Output: Brand: Toyota, Color: Red, Year: 2020
      }
  }

Inheritance allows a class (subclass) to inherit attributes and methods from another class (superclass). This promotes code reuse and establishes a relationship between classes.

• Example:
  Edit Copy

  // Superclass
  public class Vehicle {
      String type;
  
      public Vehicle(String type) {
          this.type = type;
      }
  
      public void start() {
          System.out.println(type + " is starting.");
      }
  }
  
  // Subclass
  public class Car extends Vehicle {
      String brand;
  
      public Car(String type, String brand) {
          super(type); // Call the superclass constructor
          this.brand = brand;
      }
  
      public void displayBrand() {
          System.out.println("Brand: " + brand);
      }
  }
  
  // Main class
  public class Main {
      public static void main(String[] args) {
          Car myCar = new Car("Car", "Toyota");
          myCar.start(); // Output: Car is starting.
          myCar.displayBrand(); // Output: Brand: Toyota
      }
  }

Polymorphism allows objects of different classes to be treated as objects of a common superclass. It enables methods to behave differently based on the object that invokes them.

• Method Overriding:
  Edit Copy

  public class Animal {
      public void sound() {
          System.out.println("Animal makes a sound");
      }
  }
  
  public class Dog extends Animal {
      @Override
      public void sound() {
          System.out.println("Dog barks");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Animal myAnimal = new Dog(); // Polymorphism
          myAnimal.sound(); // Output: Dog barks
      }
  }

Encapsulation is the practice of bundling data (attributes) and methods that operate on the data into a single unit (class) and restricting access to the internal details. This is achieved using access modifiers like private, protected, and public.

• Example:
  Edit Copy

  public class Person {
      private String name; // Private attribute
  
      // Public getter and setter methods
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Person person = new Person();
          person.setName("John");
          System.out.println("Name: " + person.getName()); // Output: Name: John
      }
  }

Abstraction is the concept of hiding complex implementation details and showing only the necessary features of an object. In Java, abstraction is achieved using abstract classes and interfaces.

• Abstract Class Example:
  Edit Copy

  abstract class Shape {
      abstract void draw(); // Abstract method
  }
  
  class Circle extends Shape {
      @Override
      void draw() {
          System.out.println("Drawing a circle");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Shape myShape = new Circle();
          myShape.draw(); // Output: Drawing a circle
      }
  }

• Interface Example:
  Edit Copy

  interface Animal {
      void sound(); // Interface method
  }
  
  class Dog implements Animal {
      @Override
      public void sound() {
          System.out.println("Dog barks");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Animal myAnimal = new Dog();
          myAnimal.sound(); // Output: Dog barks
      }
  }