ISB 16003 OOP (Dr Juliana Jaafar) - Module 3: Advanced Class Features

Module Objectives

This module aims to cover several advanced features in object-oriented programming using Java, focusing on:

Static Variables and Methods: Understanding their usage and scope.
Final Classes, Methods, and Variables: Grasping the immutability concepts in Java.
Abstract Methods and Interfaces: Exploring abstraction in classes and the use of interfaces.

Static Variables and Methods

In Java, static variables belong to the class itself rather than to any specific instance. This allows a single copy of the variable to exist in memory, shared among all instances of the class. The scope of static variables spans the entire class, permitting declarations at any point within it. For instance, a static variable can be initialized only once at the start of execution, and it can be accessed directly through the class name without requiring an object reference.

Example: In the Circle class, a static variable numberOfObjects tracks how many circle instances are created. Each time a new Circle instance is initialized, numberOfObjects increments, maintaining a shared count across instances.

Similarly, static methods are methods that belong to the class rather than instances. They can only access static data and can only call other static methods. They cannot reference instance variables or methods, and they do not use the this or super keywords.

Important Guidelines for Static Methods:

Used when the method does not need access to instance data.
Only needs to access static fields of the class.

Final Keyword

The final keyword has three primary uses:

Applied to classes, it prevents extension (no subclassing).
Applied to methods, it prevents overriding.
Applied to variables, it defines constants that cannot change.

Example: In a Bank class, a constant interest rate might be defined using private static final double DEFAULT_INTEREST_RATE = 3.2;.

Abstract Classes and Methods

An abstract class is defined using the abstract modifier. It may contain abstract methods—methods that are declared but lack implementation. An abstract class cannot be instantiated directly, forcing developers to create subclasses that provide implementations for the abstract methods.

When designing a superclass that should not be directly instantiated, like a Student class, it’s practical to declare it as abstract. For instance, you can have subclasses like UndergraduateStudent and GraduateStudent without needing instances of Student itself.

Case Study: Consider a situation where we need to classify students. If a student is required to be either an undergraduate or a graduate, the Student class can be declared abstract. Conversely, if students can belong to more categories, it might be beneficial to define Student as instantiable, facilitating further modifications as needed.

Interfaces in Java

Java interfaces provide a way to define methods that can be implemented by any class, regardless of its position in the hierarchy. Unlike abstract classes, interfaces only declare methods and cannot contain any implementation details.

Key differences between interfaces and abstract classes include:

Interfaces cannot have instance variables; all fields are constants.
Abstract classes can provide concrete methods.
Java supports multiple interface implementations, allowing a class to implement multiple behaviors.

Example of an interface: A Flyer interface may define methods like takeOff(), land(), and fly(). Classes like Aeroplane and Bird can implement this interface to provide their specific functionalities, showcasing polymorphism.

Polymorphism and Implementation

Polymorphism allows a single variable to reference objects from different classes in the same inheritance hierarchy, enabling dynamic method resolution. In our example, both the Aeroplane and Car classes could share a common method for displaying vehicle details, but each would implement the method uniquely.

Summary

In summary, this module emphasized several advanced OOP concepts in Java, including:

Inheritance: Establishing the is-a relationship through subclasses.
Abstract Classes: Enforcing method overriding and design flexibility.
Interfaces: Promoting shared behavior among different, possibly unrelated classes.
Polymorphism: Enhancing flexibility and scalability in object interaction.

By mastering these concepts, Java developers can create more efficient, organized, and scalable applications.

Lab Exercises

To cement understanding, students are tasked with implementing practical applications based on the discussed concepts. This includes:

Understanding and improving class diagrams from the previous lectures.
Implementing a Java application that reflects the refined class diagrams.

Advanced Class Features in Java

Advanced Class Features in Java