4.10. Object-Oriented Programming Concepts

class Student {
String name;
int age;
void display() {
System.out.println(name + " is " + age + " years old.");
}
}
Student s = new Student();
s.name = "Ravi";
s.age = 18;
s.display();

In this chunk, we learn about classes and objects in Java. A class is like a blueprint for creating objects. In the example, we define a class named Student that has two attributes: name (a string) and age (an integer). It also has a method display() that prints out the student's name and age. To interact with this class, we create an object s of the Student class. We then set the name to 'Ravi' and age to 18, and finally call the display() method, which outputs: 'Ravi is 18 years old.' This shows how classes serve as templates for creating objects encapsulating data and behavior.

Think of a class as a recipe for making a cake. Just as the recipe outlines the ingredients (like flour and sugar) and steps (mixing the ingredients, baking, etc.), a class defines attributes and methods. Each cake you bake using that recipe is an object. For example, when you bake a chocolate cake, that specific cake is an object of the cake recipe class. Here, 'Ravi' is like a particular cake made using the 'Student' recipe.

Wrapping data and methods in a class.

Encapsulation is an important concept in object-oriented programming that involves bundling the data (attributes) and methods (functions) that operate on that data within one unit, usually a class. It helps in hiding the internal state of an object from the outside world, only exposing what is necessary via methods. This promotes modularity and increases the security of the data by restricting outside access.

Imagine a television set. The internal components and wiring are hidden inside the TV casing and not visible to the user. Instead, users interact with the TV through buttons or a remote control. This is similar to encapsulation, where the workings of the class (like the internal state of the TV) are hidden from the outside, only letting us control it through set methods (the remote control).

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

Inheritance is a mechanism in object-oriented programming that allows one class to inherit properties and methods from another class. In our example, the Animal class has a method sound() that prints 'Animal sound'. The Dog class extends the Animal class, thus inheriting the sound() method while also introducing its own method, bark(), which prints 'Dog barks'. This allows for a hierarchical classification of classes and code reusability, meaning the Dog class doesn't have to reimplement the sound method but can still utilize it.

Consider family traits being passed down from parents to children. For example, if a parent (class) has the trait of being an athlete (method), then the child (subclass) can inherit those traits and can also develop traits specific to themselves, like being a swimmer. So, in this analogy, the Animal class is the parent, and Dog is the child that inherits the characteristics of being an Animal while also having its own specific traits.

Method overloading and overriding.

Polymorphism allows for methods to be used in different ways depending on the context. There are two types of polymorphism in Java: method overloading and method overriding. Method overloading occurs when multiple methods have the same name but different parameters within the same class. Method overriding happens when a subclass provides a specific implementation of a method that is already defined in its superclass. This allows methods to act in different ways based on the object that is invoking them, thereby enhancing flexibility.

Think of polymorphism like a person with multiple roles. For instance, a person can be a teacher, a parent, and a friend all at once. Depending on who they are interacting with (students, children, or friends), they respond and behave differently, although they are the same person. Similarly, in Java, a method can behave differently based on the object or context in which it is being called.

--