Introduction to Object-Oriented Programming (OOP)
Object-oriented programming (OOP) is a programming paradigm based on the concept of “objects.” These objects can contain data, in the form of fields (often known as attributes or properties), and code, in the form of procedures (often known as methods). OOP in Java helps in organizing code in a way that is modular, reusable, and easy to maintain.
Core OOP Concepts
- Classes and Objects:
- Class: A blueprint for creating objects. It defines a datatype by bundling data and methods that work on the data.
- Object: An instance of a class. When a class is instantiated, memory is allocated for the object, and the object’s attributes and methods can be accessed.
- Encapsulation
- Encapsulation is the mechanism of wrapping the data (variables) and code acting on the data (methods) together as a single unit. It restricts direct access to some of an object’s components, which can protect the integrity of the data.
- Inheritance
- Inheritance is a mechanism where a new class is derived from an existing class. The new class, called the subclass (or derived class), inherits attributes and methods from the superclass (or base class).
- Polymorphism
- Polymorphism allows objects of different classes to be treated as objects of a common super class. It is often expressed as “one interface, many implementations.”
- Abstraction
- Abstraction is the concept of hiding the complex implementation details and showing only the essential features of the object. It helps in reducing programming complexity and effort.
Defining Classes with Attributes and Methods
Creating a Simple Class
public class Car {
// Attributes
private String make;
private String model;
private int year;
// Constructor
public Car(String make, String model, int year) {
this.make = make;
this.model = model;
this.year = year;
}
// Getter and Setter methods
public String getMake() {
return make;
}
public void setMake(String make) {
this.make = make;
}
public String getModel() {
return model;
}
public void setModel(String model) {
this.model = model;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
// Method to display car details
public void displayDetails() {
System.out.println("Car Make: " + make);
System.out.println("Car Model: " + model);
System.out.println("Car Year: " + year);
}
}
In this example, we define a Car class with three attributes: make, model, and year. We also have a constructor to initialize these attributes, getter and setter methods to access and modify the attributes, and a displayDetails method to print out the car details.
Creating and Using Objects
public class Main {
public static void main(String[] args) {
// Creating objects of the Car class
Car car1 = new Car("Toyota", "Camry", 2020);
Car car2 = new Car("Honda", "Civic", 2019);
// Displaying car details
car1.displayDetails();
car2.displayDetails();
// Modifying car attributes
car1.setYear(2021);
System.out.println("Updated Car Year: " + car1.getYear());
}
}
Demonstrating OOP Principles
Encapsulation
Encapsulation is demonstrated in the Car class by making the attributes private and providing public getter and setter methods to access and update the attributes.
public class Car {
private String make;
private String model;
private int year;
// Constructors, getters, and setters...
}
The attributes make, model, and year are private, meaning they cannot be accessed directly from outside the class. The public getter and setter methods allow controlled access to these attributes.
Inheritance
Inheritance allows one class to inherit the fields and methods of another. Let’s create a subclass ElectricCar that inherits from the Car class.
public class ElectricCar extends Car {
private int batteryCapacity;
public ElectricCar(String make, String model, int year, int batteryCapacity) {
super(make, model, year); // Call the constructor of the superclass
this.batteryCapacity = batteryCapacity;
}
public int getBatteryCapacity() {
return batteryCapacity;
}
public void setBatteryCapacity(int batteryCapacity) {
this.batteryCapacity = batteryCapacity;
}
@Override
public void displayDetails() {
super.displayDetails(); // Call the superclass method
System.out.println("Battery Capacity: " + batteryCapacity + " kWh");
}
}
Polymorphism
Polymorphism allows us to use a superclass reference to refer to a subclass object.
public class Main {
public static void main(String[] args) {
// Using polymorphism
Car car = new ElectricCar("Tesla", "Model S", 2022, 100);
// Calling overridden method
car.displayDetails();
}
}
In this example, car is a reference of type Car but refers to an object of type ElectricCar. The displayDetails method of ElectricCar is called, demonstrating polymorphism.
Abstraction
Abstraction can be demonstrated by defining abstract classes and methods. Abstract classes cannot be instantiated, and they are meant to be subclassed. Abstract methods are methods that are declared without an implementation.
public abstract class Vehicle {
public abstract void start();
public abstract void stop();
}
public class Motorbike extends Vehicle {
@Override
public void start() {
System.out.println("Motorbike is starting");
}
@Override
public void stop() {
System.out.println("Motorbike is stopping");
}
}
Conclusion
Object-oriented programming in Java provides a powerful way to structure and organize your code. By understanding and applying the principles of classes, objects, encapsulation, inheritance, polymorphism, and abstraction, you can create more modular, reusable, and maintainable software. Mastering these OOP concepts is essential for any Java programmer and will pave the way for understanding more advanced topics in Java development. Stay tuned for the next part of this series, where we will explore interfaces, abstract classes, and design patterns in Java!
