Conclusion: Designing Class Hierarchies

Section 9.11 Conclusion: Designing Class Hierarchies

Throughout this chapter, we’ve explored how to thoughtfully integrate inheritance into the design recipe process. By considering inheritance relationships early, during Steps 0, 1, and 2, we create more robust, maintainable, and extensible class hierarchies that directly support the DRY principle and lead to cleaner, more intuitive code.

🔗

Subsection 9.11.1 Key Takeaways

As you move forward with implementing inheritance in your own projects, keep these important principles in mind:

🔗

Start with the problem domain: Effective inheritance hierarchies reflect natural "is-a" relationships in your problem space. During Step 0, look for phrases like "all posts need..." or "every vehicle has..." that suggest common attributes or behaviors suitable for a superclass.

🔗
Document potential hierarchies early: Create simple diagrams or tables that categorize common versus specialized attributes, helping you visualize the inheritance structure before writing any code.

🔗
Be intentional about shared attributes: During Step 1 (data definitions), place fields at the appropriate level in the hierarchy, with common fields in superclasses and specialized fields in subclasses. Consider creating intermediate superclasses when multiple classes share specific attributes.

🔗
Design clear method contracts: In Step 2, create purpose statements that explicitly communicate whether subclasses should, may, or must not override each method. These contracts form the blueprint for how your classes will interact.

🔗
Refine iteratively: As you progress through Steps 0-2, continuously revisit and refine your hierarchy. When you find identical or similar methods across classes, consider moving them up to a common superclass.

🔗
Use interfaces for cross-cutting concerns: When behavior doesn’t fit neatly into the inheritance hierarchy, interfaces provide a powerful complementary mechanism for sharing functionality across unrelated classes.

🔗
Keep the DRY principle central: Good inheritance design naturally supports the Don’t Repeat Yourself principle, reducing duplication and improving maintainability. Look for opportunities to consolidate repeated code without forcing unnatural "is-a" relationships.

🔗

🔗

Subsection 9.11.2 Inheritance Beyond Design

While we’ve focused on integrating inheritance into the early steps of the design recipe, its benefits extend through implementation and maintenance:

🔗

Implementation flows naturally from a well-designed hierarchy, with clear separation of responsibilities between superclasses and subclasses. Common code is written once, specialized behavior is isolated to the appropriate subclasses.

🔗
Testing becomes more structured, allowing you to test common behavior once at the superclass level while focusing subclass tests on specialized behavior. This reduces redundant testing effort and makes your test suite more maintainable.

🔗
Code evolution is simplified when new requirements emerge. Adding features that apply to all classes can be implemented once in the superclass. New subclasses can be introduced with minimal code by leveraging existing functionality.

🔗
Bug fixes propagate automatically when fixed in superclass methods, benefiting all subclasses that inherit that functionality without requiring changes to each individual class.

🔗

Remember that inheritance is just one tool in your design toolbox. For some relationships, composition or interfaces might be more appropriate. The key is to make deliberate choices during the design phase rather than trying to retrofit inheritance later which is a process that’s often more complex and error-prone.

🔗

Subsection 9.11.3 Integrated Inheritance Example: Social Media System

Throughout this chapter, we’ve explored many concepts related to inheritance and class hierarchies. The following example brings these concepts together in a single, runnable program that demonstrates a social media post system—the example we’ve referenced throughout the chapter.

🔗

This example showcases:

🔗

A class hierarchy with an abstract superclass (Post)

🔗
An intermediate class (MediaPost) providing shared functionality

🔗
Concrete subclasses with specialized behavior

🔗
Constructor chaining with super()

🔗
Method overriding with @Override annotation

🔗
The DRY principle in action

🔗

Note: To work within Runestone’s constraints, all classes are combined in a single file. In a real project, each class would typically be in its own file.

🔗

/**
 * Main class that demonstrates our social media post hierarchy in action
 */
public class PostDemo {
    public static void main(String[] args) {
        // Create different post types
        TextPost textPost = new TextPost("Alice", "Just learned about inheritance in Java!");
        PhotoPost photoPost = new PhotoPost("Bob", "Vacation sunset", "sunset.jpg", "1920x1080");
        VideoPost videoPost = new VideoPost("Charlie", "My Java tutorial", "tutorial.mp4", "1280x720", 300);
        
        System.out.println("\n***** Basic Post Information *****");
        displayPostInfo(textPost);
        displayPostInfo(photoPost);
        displayPostInfo(videoPost);
        
        System.out.println("\n***** User Interaction *****");
        // Like various posts
        textPost.like();
        photoPost.like();
        photoPost.like(); // Liked twice
        videoPost.like();
        videoPost.like();
        videoPost.like(); // Liked three times
        
        // Add comments
        textPost.addComment("Great insight!");
        photoPost.addComment("Beautiful shot!");
        photoPost.addComment("Where was this taken?");
        videoPost.addComment("Very helpful tutorial!");
        
        System.out.println("\n***** Updated Post Information *****");
        displayPostInfo(textPost);
        displayPostInfo(photoPost);
        displayPostInfo(videoPost);
        
        System.out.println("\n***** Media-Specific Features *****");
        // Demonstrate media-specific methods
        System.out.println("Time to consume " + photoPost.getTitle() + ": " + 
                           photoPost.getTimeToConsume() + " seconds");
        System.out.println("Time to consume " + videoPost.getTitle() + ": " + 
                           videoPost.getTimeToConsume() + " seconds");
                           
        System.out.println("\n***** Text Post-Specific Features *****");
        System.out.println(textPost.getTitle() + " - Word count: " + textPost.getWordCount());
        System.out.println("Summary: " + textPost.getSummary(3));
    }
    
    // This method demonstrates polymorphism - it works with any Post object
    private static void displayPostInfo(Post post) {
        System.out.println("\n" + post.getTitle());
        System.out.println("By: " + post.getAuthor() + " | Likes: " + post.getLikeCount());
        System.out.println("Comments: " + post.getCommentCount());
        
        if (post.getCommentCount() > 0) {
            System.out.println("--- Latest Comments ---");
            for (String comment : post.getComments()) {
                System.out.println("* " + comment);
            }
        }
    }
}

/**
 * Abstract base class for all post types
 * - Demonstrates abstract classes
 * - Contains shared fields and methods (DRY principle)
 */
abstract class Post {
    // Common fields (shared by all post types)
    private String author;
    private String timestamp;
    private int likeCount;
    private java.util.ArrayList<String> comments;
    
    // Constructor
    public Post(String author) {
        this.author = author;
        this.timestamp = new java.util.Date().toString();
        this.likeCount = 0;
        this.comments = new java.util.ArrayList<>();
    }
    
    // Common methods for all posts
    public void like() {
        likeCount++;
        System.out.println(getTitle() + " received a like! Total likes: " + likeCount);
    }
    
    public void addComment(String comment) {
        comments.add(comment);
        System.out.println("Comment added to " + getTitle() + ": " + comment);
    }
    
    // Getters
    public String getAuthor() {
        return author;
    }
    
    public String getTimestamp() {
        return timestamp;
    }
    
    public int getLikeCount() {
        return likeCount;
    }
    
    public int getCommentCount() {
        return comments.size();
    }
    
    public java.util.ArrayList<String> getComments() {
        return new java.util.ArrayList<>(comments); // Return a copy for safety
    }
    
    // Abstract method that all subclasses must implement
    public abstract String getTitle();
    
    // Abstract method for time to consume content
    public abstract int getTimeToConsume();
}

/**
 * TextPost class - a concrete subclass of Post
 * - Demonstrates extending a class
 * - Adds specialized fields and methods
 */
class TextPost extends Post {
    private String content;
    
    public TextPost(String author, String content) {
        super(author); // Call parent constructor
        this.content = content;
    }
    
    // Implement abstract method
    @Override
    public String getTitle() {
        // Create a title from the first few words
        return getFirstWords(content, 5) + "...";
    }
    
    // Text-specific methods
    public int getWordCount() {
        if (content == null || content.isEmpty()) {
            return 0;
        }
        return content.split("\\s+").length;
    }
    
    public String getSummary(int sentenceCount) {
        if (content == null || content.isEmpty()) {
            return "";
        }
        
        String[] sentences = content.split("[.!?]\\s*");
        StringBuilder summary = new StringBuilder();
        
        for (int i = 0; i < Math.min(sentenceCount, sentences.length); i++) {
            summary.append(sentences[i]).append(". ");
        }
        
        return summary.toString().trim();
    }
    
    private String getFirstWords(String text, int wordCount) {
        if (text == null || text.isEmpty()) {
            return "";
        }
        
        String[] words = text.split("\\s+");
        StringBuilder result = new StringBuilder();
        
        for (int i = 0; i < Math.min(wordCount, words.length); i++) {
            result.append(words[i]).append(" ");
        }
        
        return result.toString().trim();
    }
    
    @Override
    public int getTimeToConsume() {
        // Estimate 2 seconds per word
        return getWordCount() * 2;
    }
}

/**
 * MediaPost class - an intermediate abstract class
 * - Demonstrates multi-level inheritance
 * - Shows how to create intermediate classes for shared functionality
 */
abstract class MediaPost extends Post {
    private String title;
    private String filePath;
    private String resolution;
    
    public MediaPost(String author, String title, String filePath, String resolution) {
        super(author);
        this.title = title;
        this.filePath = filePath;
        this.resolution = resolution;
    }
    
    @Override
    public String getTitle() {
        return title;
    }
    
    public String getFilePath() {
        return filePath;
    }
    
    public String getResolution() {
        return resolution;
    }
    
    // Shared method for validating resolutions
    protected boolean isValidResolution(String resolution) {
        if (resolution == null) {
            return false;
        }
        
        // Simple validation: must be in format "WidthxHeight"
        String[] parts = resolution.split("x");
        if (parts.length != 2) {
            return false;
        }
        
        try {
            int width = Integer.parseInt(parts[0]);
            int height = Integer.parseInt(parts[1]);
            return width > 0 && height > 0;
        } catch (NumberFormatException e) {
            return false;
        }
    }
}

/**
 * PhotoPost class - concrete subclass of MediaPost
 * - Demonstrates a leaf class in the hierarchy
 */
class PhotoPost extends MediaPost {
    public PhotoPost(String author, String title, String filePath, String resolution) {
        super(author, title, filePath, resolution);
    }
    
    @Override
    public int getTimeToConsume() {
        // Photos take about 10 seconds to view
        return 10;
    }
}

/**
 * VideoPost class - concrete subclass of MediaPost
 * - Demonstrates another leaf class with different behavior
 */
class VideoPost extends MediaPost {
    private int durationInSeconds;
    
    public VideoPost(String author, String title, String filePath, String resolution, int durationInSeconds) {
        super(author, title, filePath, resolution);
        this.durationInSeconds = durationInSeconds;
    }
    
    public int getDurationInSeconds() {
        return durationInSeconds;
    }
    
    @Override
    public int getTimeToConsume() {
        // Videos take their full duration to watch
        return durationInSeconds;
    }
}

Try experimenting with this code! Here are some things you might modify:

🔗

Create a new type of post (like PollPost or EventPost) by extending Post

🔗
Add new fields to the existing classes

🔗
Override like() in one of the subclasses to provide special behavior

🔗
Add a method to count hashtags in TextPost

🔗
Implement a share() method in the Post class and customize it in subclasses

🔗

This example illustrates how a well-designed inheritance hierarchy can:

🔗

Reduce code duplication by centralizing common fields and methods in the superclass

🔗
Use abstract classes for conceptual entities that shouldn’t be instantiated directly

🔗
Create intermediate classes when a subset of subclasses shares specialized behavior

🔗
Allow for polymorphism through method overriding

🔗
Establish a clear "is-a" relationship that mirrors real-world concepts

🔗

By understanding these inheritance principles and applying them with the design recipe, you can create cleaner, more maintainable, and more extensible code in your own projects.

🔗

You have attempted of activities on this page.

🔗

Prev Top Next