Inheritance Directory - An Exploration of Inheritance with Sushi as a MetaphorThe Inheritance directory provides an engaging introduction to the principles of inheritance in object-oriented programming, all through the familiar (and delicious) lens of sushi ingredients and dishes. The directory is organized to reflect a sushi restaurant experience, where each class and interface plays a role in constructing sushi pieces, plates, and portions. This approach is designed to make the abstract concept of inheritance concrete by connecting it to recognizable elements of Japanese cuisine, specifically focusing on the sushi-making process and its components.
In object-oriented programming, inheritance allows us to define shared characteristics in a parent class and extend or specialize them in child classes. In the Inheritance directory, the sushi metaphor simplifies this concept. Each ingredient—like avocado, tuna, and shrimp—becomes a child class that inherits from a general ingredient parent class. This setup mirrors real-world objects where items share common traits but also retain unique attributes, making inheritance a perfect fit for creating a structured hierarchy of sushi ingredients and recipes.
The foundation of the sushi hierarchy begins with ingredients, each represented by a class inheriting from a base ingredient class. In this base class, shared characteristics of sushi ingredients are captured, such as:
These shared characteristics form the basis for a parent ingredient class, which the following subclasses expand on:
Each of these ingredients inherits basic properties from the parent class but is configured in its subclass with its specific attributes (e.g., unique price, calorie count, dietary properties).
The Avocado class, for instance, will have a parameterless constructor that initializes its characteristics by calling the parent class’s constructor with avocado-specific values (like its price per ounce, calorie count, and whether it’s vegetarian). This approach reduces redundancy and ensures all ingredients share a consistent structure, managed by the parent class.
With the ingredients in place, we delve into portions—representing quantities of each ingredient in ounces, which is essential for making sushi pieces like sashimi, nigiri, and rolls. Each portion class encapsulates an instance of the ingredient it represents, allowing it to retain specific characteristics while adding functionality:
IngredientPortion interface provide a combine method, which lets two portions of the same ingredient be combined into a larger portion.This setup models real-world sushi preparation, where ingredient quantities are adjusted based on the type of sushi being made. Additionally, the inheritance structure here allows for elegant reuse of ingredient properties within portions, avoiding duplication and keeping the code streamlined.
With ingredients and portions established, we can now create full sushi pieces: sashimi, nigiri, and rolls, each represented by a class implementing a Sushi interface.
A Sashimi class models the simplest type of sushi, consisting of a 0.75-ounce portion of seafood. Different types of sashimi—like tuna, yellowtail, and shrimp—are handled by a public enumeration, SashimiType, allowing the Sashimi class to represent a variety of sashimi dishes. The constructor initializes the correct seafood portion based on the chosen type, making each instance reflect the unique name and properties of the selected seafood, such as “tuna sashimi” or “crab sashimi.”
The Nigiri class extends the sashimi concept by adding a 0.5-ounce portion of rice. Similar to sashimi, nigiri offers variations based on its seafood component, which is managed by a NigiriType enumeration. Each type of nigiri is a blend of rice and seafood, with a constructor that initializes both ingredients, naming the dish accordingly (e.g., “eel nigiri”). The combination of ingredients shows the power of composition within the inheritance framework, combining different ingredient objects to form a complete dish.
The Roll class takes sushi creation to the next level, supporting a customizable array of ingredient portions, allowing for unique and intricate sushi rolls. When creating a Roll, the user provides a name and an array of ingredient portions:
Roll constructor automatically adds a minimum 0.1-ounce portion of seaweed to represent the wrapper, unless the roll already contains sufficient seaweed.Additionally, rolls are equipped to handle repeated ingredient types, combining portions to maintain a single ingredient type for simplicity and consistency. This feature demonstrates a flexible approach to sushi design, accommodating diverse ingredients while adhering to specific constraints.
The Inheritance directory is a carefully structured simulation of inheritance, composition, and object-oriented organization, making abstract design principles tangible through the assembly of sushi. By following this directory, you will explore how a parent class can encapsulate shared traits, while subclasses can refine and extend these characteristics in specialized ways. Sushi creation provides a rich analogy for these principles:
The sushi-inspired organization of this directory provides an engaging, memorable introduction to inheritance, leaving you with both a better understanding of object-oriented design and perhaps a craving for your favorite sushi roll!