SE 109 - Lecture 2: OOP Features, Relationships, and Inheritance

Previous Lecture (Lec 1) | Course Index | Next Lecture (Lec 3)

Outline of Lecture 2

Features of OOP (Detailed)
Relationships between Classes
Types of Inheritance

Features of Object-Oriented Programming

The core features that define OOP are:

Encapsulation
Abstraction
Inheritance
Polymorphism

(Slide 4 showed a diagram with these four features branching from "Object Oriented Programming Features").

1. Encapsulation

Definition: Encapsulation is the bundling of data (attributes) and methods (behavior) that operate on the data within a single unit (a class). It also involves restricting direct access to some of an object's components (data hiding).

It's the process of hiding the internal state (data/secrets) and implementation details of an object from the outside world.
Provides security to data and methods.
Keeps data and code safe from external interference.
Objects act like "black boxes": they expose *what* they can do (public methods), but hide *how* they do it (private data and method implementation).
Typically implemented by making instance variables private and providing public methods (getters and setters) to access or modify the data in a controlled way.

(Slide 5 showed an ATM as an analogy for encapsulation. Slide 7 showed a diagram of a capsule containing data (attributes) protected by an outer layer of methods).

Benefits:

Data Hiding: Protects internal state.
Increased Flexibility: The internal implementation can change without affecting outside classes that use the public methods.
Reusability: Encapsulated classes are easier to reuse.
Maintainability: Changes are localized.
Control over data: Setters can include validation logic. Fields can be made read-only (no setter) or write-only (no getter).

How to implement encapsulation in Java:

Make instance variables private.
Provide public getter and setter methods for controlled access.
Getters retrieve the value, setters update the value.

Encapsulation Example:

File: EncapTest.java

/* File name : EncapTest.java */
public class EncapTest {
   private String name;
   private String idNum;
   private int age;

   public int getAge() {
      return age;
   }

   public String getName() {
      return name;
   }

   public String getIdNum() {
      return idNum;
   }

   public void setAge( int newAge) {
      age = newAge;
   }

   public void setName(String newName) {
      name = newName;
   }

   public void setIdNum( String newId) {
      idNum = newId;
   }
}

File: RunEncap.java (Using EncapTest)

/* File name : RunEncap.java */
public class RunEncap {

   public static void main(String args[]) {
      EncapTest encap = new EncapTest();
      encap.setName("James");
      encap.setAge(20);
      encap.setIdNum("12343ms");

      System.out.print("Name : " + encap.getName() + " Age : " + encap.getAge());
      // Output: Name : James Age : 20
   }
}

In this example, name, idNum, and age are private. Access is only possible through the public get...() and set...() methods.

2. Abstraction

Definition: Abstraction means hiding the complex implementation details and showing only the essential features (interfaces) of the object to the user. It focuses on *what* an object does, rather than *how* it does it.

It denotes the essential characteristics that distinguish an object from others.
Helps in managing complexity by breaking down systems into manageable conceptual chunks.
Often achieved in Java using abstract classes and interfaces.
Relationship with Encapsulation: Encapsulation *implements* abstraction. Encapsulation hides the internal details, while abstraction provides a simplified view (the public interface).

Example: Using a mobile phone. You know which buttons to press (interface/abstraction) but don't need to know the complex internal circuitry and software logic (implementation/encapsulation).

Abstraction vs. Encapsulation Summary:

(Slide 19 presented a table comparing Abstraction and Encapsulation):

Abstraction	Encapsulation
Solves the problem in the design level.	Solves the problem in the implementation level.
Used for hiding unwanted data and giving relevant data.	Means hiding the code and data into a single unit to protect the data from outside world.
Lets you focus on what the object does instead of how it does it.	Means hiding the internal details or mechanics of how an object does something.
Outer layout, used in terms of design. (Example: Outer look of a Mobile Phone, display screen and keypad buttons)	Inner layout, used in terms of implementation. (Example: Inner implementation detail of a Mobile Phone, how keypad buttons and Display Screen are connected using circuits)

3. Inheritance

Definition: Inheritance is a mechanism where a new class (subclass/child class) derives properties (attributes) and behaviors (methods) from an existing class (superclass/parent class).

Promotes code reusability (write common code once in the superclass).
Establishes an "IS-A" relationship (a subclass IS-A type of its superclass).
Allows extending the functionality of existing classes without modifying them.
Enables sharing data and methods among related classes.

Terminology:

Superclass: Parent / Base / Super type class (the class being inherited from).
Subclass: Child / Derived / Sub type class (the class that inherits).

(Slides 20, 23, 25, 26, 27, 28, 29 showed various diagrams illustrating inheritance: Animal groups, Lion/Cub, Vehicle hierarchy, Ticket hierarchy, Animal/Herbivore/Carnivore etc., Animals/Amphibians/Reptiles/Mammals/Birds).

Advantage of Inheritance:

Code present in a base class need not be rewritten in its child class. Data members and methods of the parent class can be used (unless private) in the child class.

(Slide 25 showed an example where `Confirmed Ticket` and `Requested Ticket` inherit common attributes like Flight Number, Date, Time, Destination from `Air Ticket` and add their own specific attributes like Seat Number or Status).

4. Polymorphism

Definition: Polymorphism (from Greek meaning "many forms") is the ability of an object (or method or operator) to take on many forms. In OOP, it primarily refers to the ability of different objects to respond to the same message (method call) in different ways, specific to their type.

Enables an entity (like a method call) to have more than one form depending on the context (often, the type of the object invoking it).
Often achieved through method overriding (subclass provides a specific implementation for a method inherited from its superclass) and method overloading (multiple methods with the same name but different parameters within the same class - less related to the core OOP definition of polymorphism).

(Slide 32 showed a person taking on different roles: shopper, superhero, presenter, mother, office worker - illustrating the "many forms" concept).

Polymorphism Example (Method Overriding):

(Slide 33 showed a hierarchy: Shape -> Rectangle, Triangle, Circle).

File: Shape.java (Superclass)

public class Shape {
    double dim1;
    double dim2;

    // These methods might be inherited or used by subclasses
    public void SetDim1(double a) {
        dim1 = a;
    }
    public void SetDim2(double b) {
        dim2 = b;
    }

    // Generic area method (to be overridden)
    public double area() {
        System.out.println("Area for Figure is undefined.");
        return 0;
    }
}

File: Rectangle.java (Subclass)

public class Rectangle extends Shape {
    // Override area for rectangle
    @Override // Optional annotation, good practice
    public double area() {
        System.out.println("Inside Area for Rectangle.");
        return dim1 * dim2; // Uses inherited dim1, dim2
    }
}

File: Triangle.java (Subclass)

public class Triangle extends Shape {
    // Constructor (assuming one was needed, added based on slide 36 usage)
    public Triangle(double d1, double d2) {
        SetDim1(d1);
        SetDim2(d2);
    }

    // Override area for right triangle
    @Override // Optional annotation, good practice
    public double area() {
        System.out.println("Inside Area for Triangle.");
        return dim1 * dim2 / 2; // Uses inherited dim1, dim2
    }
}

File: FindAreas.java (Demonstrating Polymorphism)

public class FindAreas {
    public static void main(String args[]) {
        Shape f = new Shape(); // Generic Shape object
        f.SetDim1(10);
        f.SetDim2(10);

        Rectangle r = new Rectangle(); // Rectangle object
        r.SetDim1(9);
        r.SetDim2(5);

        Triangle t = new Triangle(10, 8); // Triangle object
        // Dimensions set via constructor in this version
        // t.SetDim1(10); // These would override constructor values if called
        // t.SetDim2(8);

        System.out.println("Area is " + r.area()); // Calls Rectangle's area()
        // Output: Inside Area for Rectangle.
        // Output: Area is 45.0

        System.out.println("Area is " + t.area()); // Calls Triangle's area()
        // Output: Inside Area for Triangle.
        // Output: Area is 40.0

        // Note: Calling f.area() would print "Area for Figure is undefined." and return 0.

        // Polymorphism example: Using a Shape reference for different objects
        Shape shapeRef; // Can refer to Shape, Rectangle, or Triangle

        shapeRef = r; // Point to Rectangle
        System.out.println("Area via shapeRef (Rectangle): " + shapeRef.area());
        // Output: Inside Area for Rectangle.
        // Output: Area via shapeRef (Rectangle): 45.0

        shapeRef = t; // Point to Triangle
        System.out.println("Area via shapeRef (Triangle): " + shapeRef.area());
        // Output: Inside Area for Triangle.
        // Output: Area via shapeRef (Triangle): 40.0
    }
}

The same method call `shapeRef.area()` behaves differently depending on the actual object type (`Rectangle` or `Triangle`) that `shapeRef` points to. This is polymorphism in action.

Relationships Between Classes

Besides inheritance (IS-A), other relationships exist:

Kind-of Relationship: Describes the relationship between a superclass and a subclass at the class level. A subclass is a 'kind-of' its superclass. (e.g., `Confirmed Ticket` is a Kind-of `Ticket`).
Is-A Relationship: Describes the relationship between an instance (object) and its class, or through inheritance, its superclass. (e.g., An object `ticket1` (which is a `ConfirmedTicket`) IS-A `ConfirmedTicket` and also IS-A `Ticket`).
Part-of Relationship (Composition/Aggregation): When a class contains an instance of another class as one of its members. (e.g., An `Employee` might be considered Part-of a `Department`).
Has-A Relationship (Composition/Aggregation): The reverse of Part-of. When a class consists of another class. (e.g., A `Department` Has-A collection of `Employee` objects). This is often used to model aggregation ( looser relationship) or composition (stronger ownership).

(Slides 38, 39, 41, 42 showed diagrams illustrating these relationships).

Types of Inheritance

Inheritance can be categorized in different ways:

Single Inheritance: A subclass inherits from only one superclass. (Java classes directly support only single inheritance).
(Slide 44 showed a diagram like Parent -> Child).
Multiple Inheritance: A subclass inherits from more than one superclass. (Java does *not* directly support multiple inheritance for classes due to the "diamond problem", but achieves a similar effect using Interfaces).
(Slide 45 showed a diagram like Parent1, Parent2 -> Child).
Multilevel Inheritance: A class is derived from a class that is also derived from another class (e.g., Class C inherits from B, and B inherits from A).
(Slide 47 showed A -> B -> C).
Hierarchical Inheritance: Multiple subclasses inherit from a single superclass (e.g., B, C, and D all inherit from A).
(Slides 30, 49, 50 showed examples: A -> B, A -> C, A -> D; Vehicle -> Land, Water, Air; Land -> Car, Bus, etc.).
Hybrid Inheritance: A combination of two or more types of inheritance (e.g., combining hierarchical and multiple - possible in languages supporting multiple inheritance or via interfaces in Java).
(Slide 48 showed A -> B, A -> C, and D inheriting from both B and C).
Multipath Inheritance: A subclass inherits from a superclass via multiple paths (leads to the diamond problem if not handled carefully, often involving multiple and hierarchical inheritance).
(Slide 52 showed A -> B, A -> C, and D inheriting from both B and C, creating two paths from A to D).

(Slide 53 showed a general classification diagram).

Generalization & Specialization

Inheritance hierarchies represent:

Generalization: Moving *up* the hierarchy from subclass to superclass (e.g., Car is generalized to Land Vehicle, which is generalized to Vehicle). Combining common features into a more general class.
Specialization: Moving *down* the hierarchy from superclass to subclass (e.g., Vehicle is specialized into Land, Water, Air; Land Vehicle is specialized into Car, Bus). Adding specific features to create more specialized classes.

(Slide 51 showed the Vehicle hierarchy with arrows indicating Generalization upwards and Specialization downwards).

Previous Lecture (Lec 1) | Course Index | Next Lecture (Lec 3)