Discussion

Questions from previous class

---

• MidTerm I ( )
• Project Requirements/Team Update
• Github Code repository
• Github Project Management
• Group

Abstract classes & Interfaces

Abstract Classes: The "Incomplete" Blueprint

// The Template
public abstract class Vehicle {
    
    // Shared behavior (All vehicles do this the same)
    public void honk() {
        System.out.println("Beep!");
    }

    // The Requirement (Every vehicle does this differently!)
    public abstract void move(); 
}

// The Real Version
public class Car extends Vehicle {
    public void move() {
        System.out.println("Driving on four wheels");
    }
}
            

Why can't we create the object of an abstract class?

• Abstract class is incomplete
• It is the process of showing essential details and hiding the implementation
• There would be no actual implementation of the method to invoke

                    
                        public class AbstractClass  {
                            public void main(String[] args) {
                                Student IS247=new Student();
                            }
                            public abstract class  Student{
                            }
                        }
                        
                       

Understanding Abstract Class

• Imagine you are designing a program for different animals.
• All animals make a sound, but the exact sound depends on the animal.

Challenge

• Modify the previous code to add more animals.
• Create a Cat class that extends the Animal class and implements the makeSound() method to print "Meow! Meow!"..

                         // Cat class implementing makeSound()
                            class Cat extends Animal {
                                void makeSound() {
                                    System.out.println("Meow! Meow!");
                                }
                            }

                        

The Interface: A "Social Contract"

interface PowerSwitch {
    void turnOn();  // No body, just a promise
}

// Marketing signs the 'Revenue' contract
class Marketing implements Revenue, PowerSwitch {
    public void turnOn() {
        System.out.println("Lights on in Marketing!");
    }
}
            

Demo Interface

Demo Abstract Class and Interface

Github code sample Abstract/Interface

challenge

                         class Cat implements Animal {
                            public void makeSound() {
                                System.out.println("Meow! Meow!");
                            }
                        }
                       
                    
                        
                       

Example Abstract

Github code sample Abstract

Demo Interface

Github code sample Interface

Abstract VS Interface

source:media.geeksforgeeks.org

                    abstract class Shape{}
                    class Circle extends Shape{} 
                                    
                    

                    interface Shape{} 
                    class Circle implements Shape{}
                                    
                    

Abstract Classes VS Interfaces

Abstraction

• Way to arrange the code
• Suppresses details
• Interface over Abstract Classes
• Both abstract class and interface helps in polymorphism

When to choose an Abstract Class?

// --- THE IDENTITY (Abstract Class) ---
// Use this for "Shared DNA"
abstract class Animal {
    String name;

    Animal(String name) { this.name = name; }

    // All animals breathe the same way (Implemented)
    void breathe() {
        System.out.println(name + " takes a breath...");
    }

    // Every animal makes a different sound (Abstract)
    abstract void makeNoise();
}

// --- THE SKILLSETS (Interfaces) ---
// Use these for "Extra Abilities"
interface Pet {
    void play(); // Only some animals are pets
}

interface Flyable {
    void fly();  // Only some animals fly
}

// --- THE CONCRETE REALITY ---

// A Dog IS-AN Animal and CAN-BE a Pet
class Dog extends Animal implements Pet {
    Dog(String name) { super(name); }

    @Override
    void makeNoise() { System.out.println("Woof!"); }

    @Override
    public void play() { System.out.println(name + " fetches the ball."); }
}

// An Eagle IS-AN Animal and CAN-FLY
class Eagle extends Animal implements Flyable {
    Eagle(String name) { super(name); }

    @Override
    void makeNoise() { System.out.println("Screech!"); }

    @Override
    public void fly() { System.out.println(name + " soars through the clouds."); }
}
            

Consider Using Interface

• You want to specify the behavior of a particular data type, but not concerned about who implements its behavior
• Use an interface when a role needs to be defined for other classes, regardless of the inheritance tree of these classes
• You want to take advantage of multiple inheritance of type

Demo Abstract Class

Github code sample Abstract

Built in Interface

• Interface Comparable
• This interface imposes a total ordering on the objects of each class that implements it. This ordering is referred to as the class's natural ordering, and the class's compareTo method is referred to as its natural comparison method
• Any class can implement Comparable to provide a mechanism for comparing objects of that type
• Java docs Comparable Interface
• Github code CompareableBuiltInInterface.java

Open-Closed Principle (OCP)

• The Open-Closed Principle (OCP)
• Classes should be open for extension but closed for modification.
• Open for Extension: Add new behavior by deriving from a base class and overriding methods.
• Closed for Modification: Keep existing code unchanged to avoid introducing new bugs in the base class.
• Allow clients to interact with your code through interfaces rather than specific implementations.
• GitHub code sample: OCP Example

OCP Problem Challenge

OCP Solution

Liskov Substitution Principle(LSP) Problem

• Objects of a superclass should be replaceable with objects of its subclasses without breaking the application.
• A subclass should be able to substitute its superclass without breaking functionality.
• If you have a class A and a subclass B, you should be able to pass an instance of B into any method that expects an A, and the program should still behave correctly.
• Github code sample LSP

Liskov Substitution Principle(LSP) Solution

Interface Segregation Principle (ISP)

• A class should not be forced to implement interfaces it does not use.
• The interfaces should split into smaller one
• Do not force the client to use the methods that they do not want to use
• Github code sample ISP

Interface Segregation Principle Solution

Interface Segregation Principle Challenge Solution

Thank you