Java Week 3: An Ultimate Guide to OOPs

In this Week We’ll cover topics such as Classes and Objects, methods and functions, recursion, and exception handling. So, let’s dive in! we will explore the  fundamental concepts in Java and provide examples and practice codes to help you understand them better.

Contents

Classes and Objects

In Java, a class is a blueprint or template for creating objects. It defines the properties and behavior that an object of that class will have. An object, on the other hand, is an instance of a class. It represents a real-world entity and can have its own unique state and behavior.

Creating a Class in Java

To create a class in Java, you use the class keyword followed by the name of the class. Here’s an example:

In the above example, we have defined a class called Car with three instance variables: brand, color, and year. We also have a class method called start() that prints a message when called.

Creating Objects from a Class

To create objects from a class, you use the new keyword followed by the name of the class and parentheses. Here’s an example:

In the above example, we have created an object of the Car class called myCar. We then set the values of its instance variables using dot notation.

Example Codes

Here are five example codes that demonstrate the use of classes and objects in Java:

Example 1: Calculator

In this example, we have created a Calculator class with methods to perform basic arithmetic operations. We create an object of the class and use its methods to perform calculations.

Example 2: Circle

In this example, we have created a Circle class with methods to calculate its area and perimeter. We create an object of the class and set its radius, then use its methods to calculate the area.

Example 3: Student

In this example, we have created a Student class with instance variables for name and age, and a method to display the student’s information. We create an object of the class, set its name and age, and then call the displayInfo() method to print the information.

Example 4: Bank Account

In this example, we have created a BankAccount class with instance variables for the account number and balance, and methods to deposit, withdraw, and display the balance. We create an object of the class, set its account number, deposit some money, withdraw some money, and then display the balance.

Example 5: Rectangle

In this example, we have created a Rectangle class with instance variables for the length and width, and methods to calculate its area and perimeter. We create an object of the class, set its length and width, and then use its methods to calculate the area.

Practice Problems

Here are some practice problems to further enhance your understanding of classes and objects in Java:

1. Create a class called Person with instance variables for name, age, and address. Add a method to display the person’s information.
2. Create a class called Book with instance variables for title, author, and publication year. Add a method to display the book’s information.
3. Create a class called Bank with instance variables for bank name and branch. Add methods to open an account, deposit money, withdraw money, and display account balance.
4. Create a class called Employee with instance variables for employee name, employee ID, and salary. Add a method to display the employee’s information.
5. Create a class called Triangle with instance variables for the lengths of its three sides. Add methods to calculate its area and perimeter.

Constructors and Instance Variables in Java

In Java, constructors and instance variables play a crucial role in object-oriented programming. Constructors are special methods that are used to initialize objects, while instance variables are variables that belong to each instance of a class. Lets explore constructors and instance variables in Java with examples to help you understand their usage.

Constructors

A constructor is a special method that is used to create an object of a class. It is called when an object is instantiated using the new keyword. Constructors have the same name as the class and do not have a return type, not even void.

Constructors can be used to initialize the instance variables of a class, perform any necessary setup, and ensure that the object is in a valid state. They can also take parameters to allow customization during object creation.

Here are five examples of constructors in Java:

Example 1: Default Constructor

In this example, we have a class called Person with two instance variables: name and age. The default constructor initializes these variables with default values.

Example 2: Parameterized Constructor

In this example, we have a parameterized constructor that takes two parameters: name and age. The constructor assigns the parameter values to the instance variables.

Example 3: Constructor Overloading

In this example, we have a class called Rectangle with three constructors. The first constructor is the default constructor, the second constructor is a parameterized constructor that takes the width and height as parameters, and the third constructor is another parameterized constructor that takes only one parameter for creating a square.

Example 4: Chaining Constructors

In this example, we have a class called Car with two constructors. The default constructor calls the parameterized constructor using the this keyword to initialize the instance variables.

Example 5: Copy Constructor

In this example, we have a class called Book with two constructors. The parameterized constructor initializes the instance variables with the provided values. The copy constructor creates a new object by copying the values from another object of the same class.

Practice Problems

Now that you have learned about constructors in Java, here are some practice problems for you to solve:

1. Create a class called Student with instance variables for name, age, and grade. Write a parameterized constructor to initialize these variables.
2. Create a class called BankAccount with instance variables for account number, balance, and account holder name. Write a default constructor to initialize these variables.
3. Create a class called Employee with instance variables for name, salary, and department. Write a copy constructor to create a new object by copying the values from another object.
4. Create a class called Circle with instance variables for radius and area. Write a constructor to initialize the radius and calculate the area.
5. Create a class called Product with instance variables for name, price, and quantity. Write a constructor to initialize these variables and calculate the total cost.

Inheritance and Polymorphism in Java

Inheritance and polymorphism are two fundamental concepts in object-oriented programming (OOP) that allow for code reuse and flexibility. Lets  explore the concepts of inheritance and polymorphism in Java, along with  example codes to illustrate their usage. Additionally, we will provide some practice problems to help you solidify your understanding.

1. Inheritance

Inheritance is a mechanism in Java that allows a class to inherit properties and methods from another class. The class that is being inherited from is called the parent class or superclass, and the class that inherits from it is called the child class or subclass. The child class can access the public and protected members of the parent class.

Here’s an example code that demonstrates inheritance:

In this example, the `Animal` class is the parent class, and the `Dog` class is the child class. The `Dog` class inherits the `name` property and the `makeSound()` method from the `Animal` class. When we create a `Dog` object and call the `makeSound()` method, it prints “The dog barks” instead of “The animal makes a sound” because the `makeSound()` method in the `Dog` class overrides the one in the `Animal` class.

2. Polymorphism

Polymorphism is the ability of an object to take on many forms. In Java, polymorphism is achieved through method overriding and method overloading. Method overriding occurs when a child class provides its own implementation of a method that is already defined in the parent class. Method overloading, on the other hand, occurs when multiple methods with the same name but different parameters are defined in a class.

Let’s see an example of polymorphism through method overriding:

In this example, we have a `Shape` class and two subclasses, `Circle` and `Rectangle`. Each subclass overrides the `draw()` method defined in the `Shape` class. When we create a `Circle` object and assign it to a `Shape` reference, and a `Rectangle` object and assign it to another `Shape` reference, we can call the `draw()` method on both objects. The output will be:

Drawing a circle
Drawing a rectangle

Practice Problems

Now that we have covered the basics of inheritance and polymorphism in Java, here are some practice problems for you to try:

1. Create a class hierarchy for different types of vehicles, such as cars, motorcycles, and bicycles. Implement a method in each class to display the type of vehicle.
2. Create a class hierarchy for different types of employees, such as managers, developers, and salespeople. Implement a method in each class to calculate the salary based on different parameters.
3. Create a class hierarchy for different types of shapes, such as squares, triangles, and circles. Implement a method in each class to calculate the area of the shape.
4. Create a class hierarchy for different types of animals, such as mammals, birds, and reptiles. Implement a method in each class to display the sound the animal makes.
5. Create a class hierarchy for different types of food, such as fruits, vegetables, and grains. Implement a method in each class to display the nutritional information of the food.

These practice problems will help you further explore the concepts of inheritance and polymorphism in Java and enhance your OOP skills.

Remember, understanding inheritance and polymorphism is crucial for writing clean and efficient code in Java. By leveraging these concepts, you can create reusable and flexible code that can be easily extended and maintained.

Extending Classes in Java

In Java, classes can be extended to create new classes that inherit the properties and behaviors of the parent class. This is achieved through the use of the extends keyword. When a class extends another class, it inherits all the non-private fields and methods of the parent class.

Here’s an example:

In this example, the Dog class extends the Animal class. The Dog class inherits the eat() method from the Animal class and also has its own bark() method.

Method Overriding in Java

Method overriding is a feature in Java that allows a subclass to provide a different implementation of a method that is already defined in its superclass. This is done by using the @Override annotation and providing a new implementation for the method.

Here’s an example:

In this example, the Dog class overrides the makeSound() method of the Animal class and provides its own implementation. When the makeSound() method is called on a Dog object, it will print “The dog barks.”

Dynamic Method Dispatch in Java

Dynamic method dispatch is a mechanism in Java that allows a method to be called on an object based on the type of the object at runtime. This is achieved through the use of inheritance and method overriding.

Here’s an example:

In this example, the Animal class has a makeSound() method. The Dog and Cat classes override this method with their own implementations. When the makeSound() method is called on an Animal object, the specific implementation of the method in the subclass is executed based on the type of the object at runtime.

Practice Problems

Here are some practice problems to further enhance your understanding of extending classes, method overriding, and dynamic method dispatch:

1. Create a class called Shape with a method called calculateArea(). Create two subclasses, Rectangle and Circle, that override the calculateArea() method to calculate the area of a rectangle and circle respectively.
2. Create a class called Vehicle with a method called startEngine(). Create two subclasses, Car and Motorcycle, that override the startEngine() method to start the engine of a car and motorcycle respectively.
3. Create a class called Employee with a method called calculateSalary(). Create two subclasses, Manager and Developer, that override the calculateSalary() method to calculate the salary of a manager and developer respectively.

These practice problems will help you solidify your understanding of extending classes, method overriding, and dynamic method dispatch in Java.

public abstract class Shape {
    public abstract double calculateArea();
    public abstract double calculatePerimeter();
}

// Concrete Subclasses
public class Rectangle extends Shape {
    // Implement abstract methods
}

public class Triangle extends Shape {
    // Implement abstract methods
}

public class Circle extends Shape {
    // Implement abstract methods
}

public interface Playable {
    void play();
}

// Implementing Classes
public class Guitar implements Playable {
    // Implement play() method
}

public class Piano implements Playable {
    // Implement play() method
}

public class Drums implements Playable {
    // Implement play() method
}

public interface Animal {
    void eat();
    void sleep();
}

// Implementing Classes
public class Dog implements Animal {
    // Implement eat() and sleep() methods
}

public class Cat implements Animal {
    // Implement eat() and sleep() methods
}

public class Bird implements Animal {
    // Implement eat() and sleep() methods
}

public abstract class Vehicle {
    public void start() {
        // Default implementation
    }
    
    public abstract void stop();
}

// Concrete Subclasses
public class Car extends Vehicle {
    // Implement stop() method
}

public class Motorcycle extends Vehicle {
    // Implement stop() method
}

public class Truck extends Vehicle {
    // Implement stop() method
}

public interface Logger {
    default void log(String message) {
        // Default logging implementation
    }
}

// Implementing Classes
public class ConsoleLogger implements Logger {
    // Implement log() method if necessary
}

public class FileLogger implements Logger {
    // Implement log() method if necessary
}

And Finally 😄!!

Why did the programmer go broke?

Because he spent all his inheritance on polymorphic objects that extended classes to override methods, but he didn’t have a dynamic method dispatch to manage his finances!

And Don’t Forget to attempt this Quiz once.

FAQs