Object-Oriented Programming in Java

2.1 Classes and Objects

Class Definition in Java

In Java, a class is a blueprint or a template for creating objects. Objects are instances of classes, and they encapsulate data and behavior. The class defines the structure and behavior of the objects that will be created based on it. Here's a detailed explanation of class definition in Java:

1. Syntax:

A basic class in Java has the following syntax:

public: Access modifier that specifies the visibility of the class. In this case, it means the class is accessible from any other class.

class: Keyword used to declare a class.

ClassName: The name of the class, following Java naming conventions (start with an uppercase letter).

2. Fields (Variables):

Inside a class, you can declare fields to represent the state or attributes of objects. Fields are also known as instance variables.

Example:

In this example, the Car class has three fields: make, model, and year.

3. Constructors:

Constructors are special methods used for initializing objects when they are created. They have the same name as the class and do not have a return type.

Example:

In this example, the Car class has a constructor that takes three parameters (make, model, and year) to initialize the fields when a Car object is created.

4. Methods:

Methods define the behavior of the objects. They represent actions that objects of the class can perform.

Example:

In this example, the Car class has a method displayInfo() that prints information about the car to the console.

5. Object Creation:

Once a class is defined, you can create objects of that class using the new keyword.

Example:

In this example, an object myCar of the Car class is created, and its displayInfo() method is called.

Introduction to Object Instantiation:

In Java, object instantiation is the process of creating an instance (object) of a class. Once a class is defined, you can create multiple objects based on that class, each having its own set of attributes and behavior. Object instantiation involves allocating memory for the object and invoking its constructor to initialize its state.

Syntax of Object Instantiation:

The general syntax for creating an object in Java is as follows:

ClassName: The name of the class for which you want to create an object.

objectName: The name you give to the specific instance of the class.

new: Keyword used to allocate memory for the object.

ClassName(): The constructor of the class, responsible for initializing the object.

Example of Object Instantiation:

Let's consider a simple Person class:

Now, let's create an object of the Person class:

In this example, person1 is an instance of the Person class created using the new keyword. The constructor Person("John", 25) is called during instantiation, setting the initial values for the name and age attributes.

Key Points on Object Instantiation:

1. Memory Allocation:

The new keyword allocates memory for the object on the heap.

2. Constructor Invocation:

The constructor of the class is invoked during object instantiation.

It initializes the object's state with the provided values.

3. Multiple Object Creation:

You can create multiple objects of the same class, each independent of the others.

Each object has its own set of attributes.

4. Object References:

The variable (person1 in the example) is a reference to the object.

Multiple references can point to the same object.

Benefits of Object Instantiation:

1. Code Reusability: Once a class is defined, you can create as many objects as needed, promoting code reuse.

2. Modularity: Objects encapsulate data and behavior, contributing to a modular and organized code structure.

3. Flexibility: Objects allow you to represent and manipulate real-world entities flexibly and dynamically.

Benefits of Class-Based Programming:

1. Encapsulation: Data and methods are encapsulated within classes, promoting data hiding.

2. Reusability: Classes can be reused in different parts of a program or in different programs.

3. Modularity: Classes provide a modular structure, making it easier to manage and understand code.

4. Abstraction: Classes allow abstraction, where complex details are hidden behind a simple interface.

2.2 Introduction to Constructors:

In Java, a constructor is a special method that is invoked when an object is created. Its primary purpose is to initialize the attributes of the object and perform any necessary setup tasks. Constructors have the same name as the class they belong to and are essential for creating and initializing objects in Java.

Key Characteristics of Constructors:

1. Name: The name of the constructor is identical to the class name.

2. No Return Type: Constructors do not have a return type, not even void.

3. Initialization: Constructors initialize the state of the object, setting initial values for its attributes.

4. Invocation: Constructors are automatically called when an object is created using the new keyword.

Types of Constructors:

1. Default Constructor:

If a class does not explicitly define any constructor, Java provides a default constructor.

It initializes fields to default values (e.g., numeric fields to 0, references to null).

2. Parameterized Constructor:

Allows you to pass values to initialize the object's attributes during object creation.

Enhances flexibility and customization of object initialization.

3. Copy Constructor:

Creates a new object by copying the attributes of an existing object.

Not natively supported in Java, but can be implemented manually.

Example of Constructors in Java:

Let's consider a simple Person class with both default and parameterized constructors:

Now, let's create objects of the Person class using both types of constructors:

In this example, person1 is created using the default constructor, and person2 is created using the parameterized constructor.

Use Cases and Benefits of Constructors:

1. Initialization:

Constructors ensure that objects are initialized properly, avoiding uninitialized or inconsistent states.

2. Encapsulation:

Constructors contribute to encapsulation by allowing controlled access to the internal state of an object.

3. Flexibility:

Parameterized constructors provide flexibility in setting different initial values for objects.

4. Code Reusability:

Constructors enable code reuse by allowing the creation of multiple objects with the same or similar initialization logic.

2.3 Introduction to Inheritance:

Inheritance is a fundamental concept in object-oriented programming (OOP) that allows a new class (subclass or derived class) to inherit properties and behaviors from an existing class (superclass or base class). This promotes code reuse and establishes a relationship between classes, creating a hierarchy of classes.

Key Concepts of Inheritance:

1. Superclass (Base Class):

The existing class whose properties and behaviors are inherited. Also called the parent class.

2. Subclass (Derived Class):

The new class, that inherits from the superclass. Also called the child class.

3. "is-a" Relationship:

Inheritance establishes an "is-a" relationship between the subclass and superclass.

For example, if we have a Vehicle superclass and a Car subclass, we can say, "A Car is a Vehicle."

Syntax of Inheritance in Java:

Example of Inheritance in Java:

Consider a Vehicle superclass and a Car subclass:

In this example, the Car class inherits the brand property and start() method from the Vehicle superclass.

Types of Inheritance:

1. Single Inheritance: A subclass inherits from only one superclass.

2. Multiple Inheritance (not supported in Java): A subclass inherits from more than one superclass. Java supports multiple interface implementation but not multiple class inheritance to avoid the "diamond problem."

3. Multilevel Inheritance: A class is derived from a subclass, creating a chain of inheritance.

4. Hierarchical Inheritance: Multiple subclasses inherit from a single superclass.

Use of super Keyword: The super keyword is used to refer to the members of the superclass.

It can be used to call the superclass's method, access its fields, or invoke its constructor.

Example using super Keyword:

Creating Subclasses in Inheritance in Java

Creating subclasses in Java is an essential aspect of inheritance, enabling the extension of existing classes to build more specialized or specific classes. A subclass inherits properties and behaviors from its superclass and can add new members or override existing ones. This promotes code reuse and follows the "is-a" relationship, where a subclass "is a" specialized version of its superclass.

Syntax for Creating Subclasses:

The syntax for creating a subclass in Java is as follows:

Example of Creating Subclasses:

Consider a Vehicle superclass and a Car subclass:

In this example, the Car class is a subclass of the Vehicle superclass. The Car subclass inherits the brand property and start() method from the Vehicle superclass and adds its own property, numberOfDoors, and method, drive().

Overriding Methods in Subclasses:

Subclasses can provide their own implementation for a method inherited from the superclass.

The @Override annotation is used to indicate that a method in the subclass is intended to override a method in the superclass.

Accessing Superclass Members in Subclass:

The super keyword is used to refer to members (fields or methods) of the superclass.

It can be used to differentiate between superclass and subclass members with the same name.

Constructor in Subclass:

The constructor of the superclass is not inherited by the subclass.

The super() keyword is used to explicitly call the superclass constructor.

Benefits of Inheritance:

1. Code Reusability: Inherited properties and methods can be reused in the subclass.

2. Extensibility: Subclasses can extend the functionality of the superclass by adding new methods or properties.

3. Maintenance: Changes made to the superclass automatically affect all subclasses.

2.4 Introduction to Polymorphism:

1. Compile-time Polymorphism (Static Binding):

It is also known as method overloading. The decision about which method to call is made at compile time-based on the method signature. Methods with the same name but different parameters are defined in the same class.

2. Runtime Polymorphism (Dynamic Binding):

It is also known as method overriding. The decision about which method to call is made at runtime based on the actual object type. It involves a subclass providing a specific implementation for a method declared in its superclass.

 

Example of Polymorphism in Java:

In this example, dog and cat are both of type Animal, but they refer to objects of the Dog and Cat classes, respectively. The makeSound() method is called on each object, and the appropriate overridden method is executed.

Method overloading and polymorphism are two important concepts in Java that allow developers to create more flexible and reusable code. Let's delve into each of these concepts in detail.

Method Overloading:

Method overloading in Java refers to the ability to define multiple methods with the same name in the same class but with different parameters. The compiler differentiates these methods based on the number, type, and order of their parameters. Method overloading provides a way to create methods that perform similar tasks but may accept different inputs.

Here's an example of method overloading:

In this example, the Calculator class has multiple add methods with different parameter lists, demonstrating method overloading. The appropriate method is called based on the arguments provided at the invocation.

Method Overriding:

Method overriding is a key concept in Java that enables polymorphism through inheritance. When a subclass provides a specific implementation of a method that is already defined in its superclass, it is said to override the method. Method overriding allows a subclass to provide a specialized version of a method inherited from its superclass.

Here are the key points related to method overriding and polymorphism in Java:

Inheritance: Method overriding is closely tied to the concept of inheritance. In Java, a subclass can inherit attributes and behaviors (methods) from its superclass.

Rules for Method Overriding:

The method in the subclass must have the same method signature (name, return type, and parameters) as the method in the superclass.

The access level of the overriding method in the subclass must be the same or more permissive than the overridden method in the superclass.

The overriding method cannot throw broader checked exceptions than the overridden method. It can throw narrower checked exceptions or unchecked exceptions.

Example of Method Overriding:

In this example, Dog and Cat classes override the makeSound method from the Animal superclass. The main method demonstrates polymorphism by creating instances of Dog and Cat and calling the overridden makeSound method through the common Animal reference.

Dynamic Method Dispatch: The process by which the correct version of the overridden method is called at runtime is known as dynamic method dispatch. The decision on which method to call is based on the actual type of the object rather than the reference type.

Super Keyword: In the overriding method, the super keyword can be used to call the overridden method in the superclass. This is useful when you want to extend the functionality of the overridden method rather than replace it entirely.

Method overriding and polymorphism allows for code reusability and flexibility. They enable the creation of generalized classes and the ability to use common interfaces while still allowing subclasses to provide their specific implementations. This contributes to the extensibility and maintainability of Java code.

Method overloading vs Method overriding

A comparison between method overloading and method overriding in Java, including examples:

Feature	Method Overloading	Method Overriding
Definition	Allows a class to have multiple methods with the same name but different parameters.	Occurs when a subclass provides a specific implementation for a method already defined in its superclass.
Criteria	Methods must have the same name but a different number or type of parameters. Return types can be the same or different.	The method in the subclass must have the same method signature (name, return type, and parameters) as the method in the superclass.
Example	java class Calculator { int add(int a, int b) { return a + b; } double add(double a, double b) { return a + b; } }	java class Animal { void makeSound() { System.out.println("Some generic sound"); } } class Dog extends Animal { @Override void makeSound() { System.out.println("Bark"); } }
Determination Time	Decided at compile time (static binding).	Decided at runtime (dynamic binding).
Inheritance Requirement	Does not require inheritance; can be within the same class.	Requires inheritance, with the overridden method in the superclass and the overriding method in the subclass.
Usage	Provides flexibility in handling different parameter types or counts within the same class.	Enables polymorphism, allowing different classes to be treated as instances of the same type.
Access Modifier	Can have the same or more permissive access modifier.	Must have the same or more permissive access modifier.
Return Type	Can have the same or different return types.	Must have the same return type or a covariant (subtype) return type.
Use of super Keyword	Not applicable.	Can be used to call the overridden method in the superclass.

These examples illustrate the key differences between method overloading and method overriding in Java. Method overloading is used for providing multiple methods within a class with the same name but different parameters, while method overriding is used for providing a specific implementation in a subclass for a method defined in its superclass.

2.5 Introduction to Encapsulation:

Encapsulation is one of the four fundamental Object-Oriented Programming (OOP) concepts and refers to the bundling of data (fields) and methods that operate on the data within a single unit known as a class. It is aimed at restricting access to the internal details of an object and protecting its integrity.

Access Modifiers: public, private, protected

1. Public: Access: Accessible from any class.

Example:

2. Private: Access: Accessible only within the same class.

Example:

3. Protected: Access: Accessible within the same class, subclasses, and the same package.

Example:

Getters and Setters:

Getters and setters are methods used to access (getters) and modify (setters)the values of private fields in a class, providing controlled access to the encapsulated data.

In this example, the Person class encapsulates the name and age fields, declaring them as private. Public getter and setter methods (getName(), setName(), getAge(), setAge()) provide controlled access to these private fields.

Benefits of Encapsulation:

1. Information Hiding: Internal details of an object are hidden from the outside world, reducing complexity.

2. Access Control: Control over the access to the internal state of an object, preventing unauthorized modifications.

3. Code Organization: Grouping related data and methods within a class improves code organization and readability.

4. Flexibility and Maintainability: Easy to change the internal implementation without affecting other parts of the code.

5. Security: Protects sensitive data by restricting direct access.

2.6 Introduction to Abstraction:

Abstraction is a key concept in object-oriented programming (OOP) that involves simplifying complex systems by modeling classes based on essential characteristics and behaviors while hiding unnecessary details. In Java, abstraction is implemented using abstract classes and interfaces, allowing developers to define the structure and behavior of a class without specifying the implementation details.

Key Concepts of Abstraction:

1. Abstract Class: An abstract class in Java is a class that cannot be instantiated on its own and may contain abstract methods. Abstract methods are declared without providing an implementation.

2. Abstract Method: An abstract method is a method declared in an abstract class without a body. It is meant to be implemented by concrete subclasses.

3. Interface:

An interface is a collection of abstract methods. Unlike abstract classes, interfaces can be implemented by multiple classes, promoting multiple inheritances of behavior.

4. Abstract Classes vs. Interfaces:

Abstract classes can have both abstract and concrete methods, while interfaces can only have abstract methods. A class can extend only one abstract class, but it can implement multiple interfaces.

In this example, the Animal abstract class declares an abstract method makeSound(). The concrete subclasses Dog and Cat provide their own implementations of the makeSound() method. The Main class demonstrates polymorphism, where objects of the Dog and Cat classes are treated as objects of the common type Animal.

Benefits of Abstraction:

1. Simplification: Complex systems can be modeled with simplified, high-level structures.

2. Reusability: Abstract classes and interfaces promote code reuse by providing a common structure for multiple classes.

3. Flexibility: Allows for easy modifications and extensions without affecting the entire codebase.

4. Modularity: Encourages modularity and separation of concerns by focusing on essential characteristics.