Inheritance in MATLAB - Deep Dive

Overview - Inheritance

What is it?

Inheritance is a way to create a new class based on an existing class. The new class, called a subclass, gets all the properties and methods of the original class, called the superclass. This helps reuse code and organize related classes in a clear way. It is like building on top of what already exists without starting from scratch.

Why it matters

Without inheritance, programmers would have to write the same code many times for similar objects, which wastes time and causes mistakes. Inheritance lets us share common features easily and change or add new features only where needed. This makes programs simpler, faster to write, and easier to fix or improve.

Where it fits

Before learning inheritance, you should understand basic MATLAB classes and how to define properties and methods. After inheritance, you can learn about polymorphism, method overriding, and design patterns that use inheritance to build flexible software.

Mental Model

Core Idea

Inheritance means a new class automatically gets the features of an existing class, so you can extend or customize without rewriting code.

Think of it like...

Inheritance is like a family recipe passed down from parents to children. The children get the basic recipe but can add their own ingredients or change steps to make it their own.

Superclass (Parent Class)
┌─────────────────────┐
│ Properties & Methods│
└─────────┬───────────┘
          │
          ▼
Subclass (Child Class)
┌─────────────────────────────┐
│ Inherits Parent's features  │
│ Adds or changes some parts   │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding MATLAB Classes Basics

Concept: Learn what a class is and how to define properties and methods in MATLAB.

In MATLAB, a class is a blueprint for creating objects. You define a class in a file with the same name as the class. Inside, you list properties (data) and methods (functions) that belong to the class. For example: classdef Animal properties Name end methods function obj = Animal(name) obj.Name = name; end function speak(obj) disp('Animal sound') end end end

Result

You can create an Animal object with a name and call its speak method to see 'Animal sound'.

Knowing how to create a class is the foundation for inheritance because inheritance builds on existing classes.

2

Foundation

Creating Objects from Classes

Concept: Learn how to make instances (objects) from a class and use their properties and methods.

Using the Animal class, you create an object like this: myPet = Animal('Buddy'); myPet.speak(); This creates an Animal named Buddy and calls the speak method, which prints 'Animal sound'.

Result

Output: Animal sound

Understanding objects lets you see how inheritance affects real instances, not just class definitions.

3

Intermediate

Defining a Subclass with Inheritance

🤔Before reading on: Do you think a subclass can add new properties and still keep the superclass properties? Commit to your answer.

Concept: Learn how to create a subclass that inherits from a superclass using MATLAB syntax.

In MATLAB, you create a subclass by specifying the superclass in the classdef line. For example: classdef Dog < Animal properties Breed end methods function obj = Dog(name, breed) obj = obj@Animal(name); % Call superclass constructor obj.Breed = breed; end function speak(obj) disp('Woof!') end end end Here, Dog inherits Name and speak from Animal but overrides speak and adds Breed.

Result

Creating a Dog object lets you use Name and Breed, and calling speak prints 'Woof!'.

Knowing how to inherit and override methods lets you customize behavior while reusing code.

4

Intermediate

Using Superclass Methods in Subclass

🤔Before reading on: Can a subclass method call the original method from the superclass? Commit to yes or no.

Concept: Learn how to call a superclass method from a subclass method to extend behavior.

Sometimes you want to keep the superclass method's behavior and add more. You can call the superclass method inside the subclass method: methods function speak(obj) speak@Animal(obj); % Call superclass speak disp('and I am a dog!') end end This prints both messages when speak is called on a Dog object.

Result

Output: Animal sound and I am a dog!

Understanding how to combine superclass and subclass methods helps build flexible and layered behaviors.

5

Intermediate

Inheritance and Property Access Control

Concept: Learn how property access levels affect inheritance and object interaction.

MATLAB lets you control who can read or write properties using attributes like SetAccess and GetAccess. For example: properties (SetAccess = protected) SecretCode end A subclass can read but not change protected properties. This controls how much subclasses can modify inherited data.

Result

Subclasses can use protected properties but cannot change them directly if restricted.

Knowing access control prevents accidental changes and enforces good design in inheritance hierarchies.

6

Advanced

Multiple Levels of Inheritance

🤔Before reading on: Do you think a subclass can inherit from another subclass? Commit to yes or no.

Concept: Learn how inheritance can chain through several classes, forming a hierarchy.

Inheritance can be multi-level. For example: classdef Puppy < Dog methods function speak(obj) disp('Yip!') end end end Puppy inherits from Dog, which inherits from Animal. Puppy gets all properties and methods from both ancestors unless overridden.

Result

Creating a Puppy object lets you use Name, Breed, and Puppy-specific methods.

Understanding multi-level inheritance helps organize complex systems with shared features at different levels.

7

Expert

Inheritance Pitfalls and Method Resolution Order

🤔Before reading on: If a method is defined in both subclass and superclass, which one runs? Commit to your answer.

Concept: Learn how MATLAB decides which method to run when multiple classes define the same method.

MATLAB uses the method in the most derived class (the subclass) first. If the subclass method calls the superclass method explicitly, that runs too. If not, the superclass method is ignored. This is called method overriding. If multiple inheritance existed (MATLAB does not support it), method resolution order would be more complex, but MATLAB uses single inheritance, so the order is clear.

Result

The subclass method runs by default, allowing customization of behavior.

Knowing method resolution order prevents confusion about which code runs and helps avoid bugs in complex class hierarchies.

Under the Hood

MATLAB stores class definitions in files and uses a class metadata system to link subclasses to superclasses. When you create an object, MATLAB allocates memory for all inherited properties. When calling a method, MATLAB looks first in the subclass, then up the inheritance chain if not found. This lookup is dynamic, allowing overridden methods to run correctly.

Why designed this way?

MATLAB uses single inheritance to keep the system simple and avoid ambiguity in method calls. This design balances flexibility with ease of understanding and debugging. Multiple inheritance was avoided to prevent complex conflicts and maintain performance.

Object Creation Flow
┌───────────────┐
│ Create Object │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Allocate Props│
│ from Superclass│
│ and Subclass  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Method Call?  │
└──────┬────────┘
       │Yes
       ▼
┌───────────────┐
│ Look in Subclass│
│ If found run   │
│ Else check     │
│ Superclass     │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does a subclass automatically copy all superclass code into itself? Commit yes or no.

Common Belief: A subclass copies all the code from the superclass into its own code.

Reality: A subclass does not copy code but references the superclass. It only overrides or adds new code. The superclass code stays in one place.

Why it matters: Thinking code is copied leads to confusion about updates. Changing superclass code automatically affects subclasses, which is important for maintenance.

Quick: Can a subclass access private properties of its superclass? Commit yes or no.

Common Belief: Subclasses can access all properties of the superclass, including private ones.

Reality: Subclasses cannot access private properties of the superclass. Only public or protected properties are accessible.

Why it matters: Assuming access to private data can cause errors and security issues in code design.

Quick: Does MATLAB support multiple inheritance? Commit yes or no.

Common Belief: MATLAB allows a class to inherit from multiple superclasses at once.

Reality: MATLAB supports only single inheritance, meaning one superclass per subclass.

Why it matters: Expecting multiple inheritance can lead to design mistakes and confusion about method resolution.

Quick: If a subclass overrides a method, does the superclass method run automatically? Commit yes or no.

Common Belief: When a subclass overrides a method, the superclass method still runs automatically.

Reality: The superclass method runs only if the subclass explicitly calls it using syntax like superclass@method().

Why it matters: Assuming automatic superclass method calls can cause missing important behavior or bugs.

Expert Zone

1

Overriding methods without calling the superclass method can break expected behavior, especially in complex hierarchies.

2

Protected properties allow subclasses to access data safely without exposing it to all code, balancing encapsulation and flexibility.

3

MATLAB's single inheritance simplifies method resolution but requires careful design to avoid deep inheritance chains that are hard to maintain.

When NOT to use

Inheritance is not ideal when classes share behavior but do not fit a strict parent-child relationship. In such cases, composition (having objects as properties) or interfaces (abstract classes) are better alternatives.

Production Patterns

In production MATLAB code, inheritance is used to create base classes for common data processing tasks, then specialized subclasses for specific data types or algorithms. This reduces duplication and eases updates across related classes.

Connections

Composition (Object-Oriented Design)

Alternative approach to code reuse by including objects inside other objects instead of inheriting.

Understanding composition helps decide when to use inheritance or when to build flexible systems by combining simpler parts.

Biological Taxonomy

Inheritance in programming mirrors biological classification where species inherit traits from ancestors.

Seeing inheritance as a natural hierarchy clarifies why some features belong to all subclasses and others are specialized.

Legal Inheritance (Law)

Both involve passing down properties and rights from one generation to another with rules and exceptions.

Recognizing inheritance as a transfer of traits or rights with controlled access helps understand access modifiers and method overriding.

Common Pitfalls

#1 Overriding a method but forgetting to call the superclass method when needed.

Wrong approach:

methods
function speak(obj)
disp('Only dog sound')
end
end

Correct approach:

methods
function speak(obj)
speak@Animal(obj);
disp('Only dog sound')
end
end

Root cause:

Misunderstanding that overriding replaces the superclass method entirely unless explicitly called.

#2 Trying to access private superclass properties directly in subclass.

Wrong approach:

obj.SecretCode = 1234; % inside subclass method

Correct approach:

% Use protected or public properties or methods to access data safely

Root cause:

Confusing private with protected or public access levels.

#3 Creating very deep inheritance chains making code hard to follow.

Wrong approach:

classdef Level5 < Level4; end
classdef Level4 < Level3; end
... (many levels)

Correct approach:

Use composition or flatten hierarchy to keep design simple.

Root cause:

Believing deeper inheritance always means better reuse without considering complexity.

Key Takeaways

Inheritance lets a new class reuse and extend an existing class's properties and methods.

MATLAB uses single inheritance, so each class has only one direct parent class.

Subclasses can override methods to change behavior but must call superclass methods explicitly if needed.

Access control (public, protected, private) controls what subclasses can see or change.

Good inheritance design balances reuse with simplicity to avoid complex, hard-to-maintain code.

Practice

1. What does inheritance allow a subclass to do in MATLAB?

easy

A. Change MATLAB's built-in functions

B. Use properties and methods from a parent class

C. Run code without a main function

D. Create variables without declaring them

Solution

1. Step 1: Understand inheritance concept

   Inheritance means a subclass can use code from a parent class.

2. Step 2: Identify what subclass gains

   The subclass gets properties and methods from the parent class automatically.

3. Final Answer:

   Use properties and methods from a parent class -> Option B

4. Quick Check:

   Inheritance = reuse parent code [OK]

Hint: Inheritance means reuse parent class code [OK]

Common Mistakes:

• Thinking inheritance creates variables automatically
• Confusing inheritance with running code without main
• Believing inheritance changes built-in MATLAB functions

2. Which of the following is the correct way to declare a subclass Dog that inherits from superclass Animal in MATLAB?

easy

A. classdef Dog inherits Animal

B. classdef Dog : Animal

C. classdef Dog extends Animal

D. classdef Dog < Animal

Solution

1. Step 1: Recall MATLAB inheritance syntax

   MATLAB uses < symbol to indicate inheritance in classdef.

2. Step 2: Match correct syntax

   The correct syntax is classdef Dog < Animal.

3. Final Answer:

   classdef Dog < Animal -> Option D

4. Quick Check:

   Inheritance uses < in MATLAB [OK]

Hint: Use < to inherit in MATLAB classdef [OK]

Common Mistakes:

• Using 'inherits' keyword instead of <
• Using ':' or 'extends' which are not MATLAB syntax
• Confusing MATLAB syntax with other languages

3. Consider the following MATLAB code:

classdef Animal
    methods
        function sound(obj)
            disp('Some sound')
        end
    end
end

classdef Dog < Animal
    methods
        function sound(obj)
            disp('Bark')
        end
    end
end

myPet = Dog();
myPet.sound();

What will be the output when running myPet.sound()?

medium

A. Error: Method not found

B. Some sound

C. Bark

D. No output

Solution

1. Step 1: Understand method overriding in subclass

   The subclass Dog defines its own sound method, which replaces the superclass method.

2. Step 2: Determine which method runs

   Calling myPet.sound() runs the Dog version, printing 'Bark'.

3. Final Answer:

   Bark -> Option C

4. Quick Check:

   Subclass method overrides superclass method [OK]

Hint: Subclass method overrides superclass method [OK]

Common Mistakes:

• Expecting superclass method output
• Thinking both methods run
• Assuming error due to overriding

4. What is wrong with this MATLAB subclass definition?

classdef Cat <
    methods
        function meow(obj)
            disp('Meow')
        end
    end
end

medium

A. Missing superclass name after <

B. Method name cannot be 'meow'

C. Classdef keyword is misspelled

D. No constructor defined

Solution

1. Step 1: Check inheritance syntax

   The symbol < must be followed by the superclass name.

2. Step 2: Identify missing superclass

   Here, no superclass name is given after <, causing syntax error.

3. Final Answer:

   Missing superclass name after < -> Option A

4. Quick Check:

   Inheritance requires superclass name after < [OK]

Hint: Always specify superclass name after < [OK]

Common Mistakes:

• Leaving out superclass name after <
• Thinking method names cause error
• Assuming constructor is mandatory

5. You have a superclass Vehicle with a method move() that prints 'Moving'. You want to create a subclass Car that inherits Vehicle but adds a new method honk() that prints 'Beep!'. Which of the following is the correct MATLAB code for the subclass Car?

hard

A. classdef Car < Vehicle
methods
function honk(obj)
disp('Beep!')
end
end
end

B. classdef Car inherits Vehicle
methods
function honk(obj)
disp('Beep!')
end
end
end

C. classdef Car : Vehicle
methods
function honk(obj)
disp('Beep!')
end
end
end

D. classdef Car extends Vehicle
methods
function honk(obj)
disp('Beep!')
end
end
end

Solution

1. Step 1: Use correct inheritance syntax

   MATLAB uses < to inherit, so classdef Car < Vehicle is correct.

2. Step 2: Add new method in subclass

   The method honk is added inside methods block correctly.

3. Final Answer:

   classdef Car < Vehicle with honk method -> Option A

4. Quick Check:

   Subclass syntax + new method = classdef Car < Vehicle methods function honk(obj) disp('Beep!') end end end [OK]

Hint: Use < and add methods block for new methods [OK]

Common Mistakes:

• Using 'inherits', ':', or 'extends' instead of <
• Forgetting to add methods block
• Trying to override without correct syntax