Learn Java Object-Oriented Programming (with actual code)

Introduction

This tutorial will guide you through the fundamentals of Object-Oriented Programming (OOP) in Java, as presented in the video by ForrestKnight. Understanding OOP is essential for modern software development, and this guide will break down core concepts such as encapsulation, inheritance, polymorphism, and abstraction, with practical code examples provided.

Step 1: Understanding Encapsulation with Classes and Objects

Encapsulation is one of the main principles of OOP that involves bundling data (attributes) and methods (functions) that work on the data into a single unit called a class.

• Create a Class: Define a class to represent a concept or entity.

public class Car {
    private String color; // Attribute
    
    public Car(String color) { // Constructor
        this.color = color;
    }
    
    public String getColor() { // Method
        return color;
    }
}

• Instantiate an Object: Create an instance of the class.

Car myCar = new Car("Red");
System.out.println(myCar.getColor()); // Outputs: Red

Practical Tips

• Use access modifiers (like private) to restrict direct access to class members.
• Always provide getter/setter methods to access private attributes.

Step 2: Exploring Inheritance

Inheritance allows a new class to inherit properties and methods from an existing class, promoting code reusability.

• Create a Base Class: Define a base class.

public class Vehicle {
    public void start() {
        System.out.println("Vehicle is starting");
    }
}

• Create a Subclass: Extend the base class.

public class Bike extends Vehicle {
    public void ringBell() {
        System.out.println("Bike bell rings");
    }
}

• Instantiate the Subclass:

Bike myBike = new Bike();
myBike.start(); // Outputs: Vehicle is starting
myBike.ringBell(); // Outputs: Bike bell rings

Common Pitfalls

• Ensure the subclass constructor calls the superclass constructor if needed.

Step 3: Understanding Polymorphism

Polymorphism allows methods to do different things based on the object that it is acting upon.

Runtime Polymorphism

Achieved through method overriding.

• Base Class Method:

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

• Subclass Method Override:

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

• Use Polymorphism:

Animal myDog = new Dog();
myDog.sound(); // Outputs: Dog barks

Compile Time Polymorphism

Achieved through method overloading.

• Overloaded Methods:

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

Practical Tips

• Use polymorphism to write flexible and reusable code.

Step 4: Exploring Abstraction

Abstraction simplifies complex systems by modeling classes based on the essential properties and behaviors an object should have.

Class Abstraction

• Abstract Class:

public abstract class Shape {
    abstract void draw(); // Abstract method
}

Interface Abstraction

• Creating an Interface:

public interface Drawable {
    void draw();
}

• Implementing the Interface:

public class Circle implements Drawable {
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

Practical Tips

• Use abstract classes when you want to provide a common base with shared methods.
• Use interfaces to define a contract for classes without enforcing a class hierarchy.

Step 5: Build Something Yourself

Now that you understand the core OOP concepts, it's time to apply what you've learned. Consider building a simple application that incorporates classes, inheritance, polymorphism, and abstraction.

Suggested Project Ideas

• A small game (e.g., a text-based adventure).
• A library management system.

Conclusion

This tutorial covered the essential concepts of Object-Oriented Programming in Java: encapsulation, inheritance, polymorphism, and abstraction. By understanding these principles, you can write more efficient and organized code. Start practicing by building small projects, and as you gain confidence, explore more complex applications. Happy coding!