Working with Abstract Classes and Interfaces

1. Defining Abstract Classes

Example: Abstract class

public abstract class Vehicle {
    protected String id;
    public Vehicle(String id) { this.id = id; }
    public abstract double fuelCost();   // no body
    public String summary() { return id + ": $" + fuelCost(); }
}
FeatureDetail
Cannot instantiateUse concrete subclass
Can have stateFields, constructors
MixAbstract + concrete methods

2. Creating Abstract Methods

RuleDetail
No bodyEnd with semicolon
Modifierabstract required
Cannot bestatic, final, private

3. Implementing Abstract Classes

RequirementDetail
SubclassMust implement all abstract methods OR be abstract
ConstructorSubclass calls super constructor

4. Defining Interfaces

Example: Interface

public interface Repository<T, ID> {
    T findById(ID id);
    List<T> findAll();
    void save(T entity);
    default boolean exists(ID id) { return findById(id) != null; }
    static Repository<?, ?> empty() { return new EmptyRepo(); }
}
MemberImplicit Modifiers
Fieldpublic static final
Abstract methodpublic abstract
Default methodpublic (Java 8+)
Static methodpublic (Java 8+)
Private methodprivate (Java 9+)

5. Implementing Interfaces

FormSyntax
Singleclass A implements I { }
Multipleclass A implements I1, I2 { }
With extendsclass A extends B implements I { }
Interface extendsinterface J extends I1, I2 { }

6. Using Multiple Inheritance with Interfaces

Warning: If two interfaces declare same default method, subclass MUST override to resolve.

Example: Diamond resolution

interface A { default String hi() { return "A"; } }
interface B { default String hi() { return "B"; } }
class C implements A, B {
    @Override public String hi() { return A.super.hi() + B.super.hi(); }
}
ConflictResolution
Same default methodOverride and use Interface.super.method()
Class winsConcrete method takes priority over default

7. Defining Default Methods

AspectDetail
PurposeAdd behavior without breaking existing implementors
Syntaxdefault ReturnType method() { ... }
OverrideSubclass may override

8. Defining Static Methods in Interfaces

AspectDetail
AccessInterfaceName.method()
InheritanceNOT inherited by implementors
UseFactory methods, utilities

9. Defining Private Methods in Interfaces

FormUse
privateHelper for default methods
private staticHelper for static methods

10. Understanding Functional Interfaces

Example: Custom @FunctionalInterface

@FunctionalInterface
interface Validator<T> {
    boolean isValid(T value);
}
Validator<String> nonEmpty = s -> s != null && !s.isEmpty();
RuleDetail
Single abstract method (SAM)Exactly one
Default/static methodsAllowed
Object public methodsDon't count
Annotation@FunctionalInterface enforces SAM

11. Working with Marker Interfaces

MarkerPurpose
SerializableMarks class as serializable
CloneableAllows Object.clone()
RandomAccessConstant-time list access
Note: Modern alternative — annotations or sealed interfaces with no methods.

12. Understanding Interface vs Abstract Class

FeatureInterfaceAbstract Class
State (instance fields)NoYes
ConstructorsNoYes
Multiple inheritanceYesNo
Method visibilitypublic/private onlyAny
Use caseCapability/contractPartial impl + state