**Course Title:** Ruby Programming: From Basics to Advanced Techniques **Section Title:** Object-Oriented Programming (OOP) in Ruby **Topic:** Inheritance and mixin modules In this topic, you will learn about inheritance and mixin modules, two fundamental concepts in Ruby's object-oriented programming model. Inheritance allows one class to inherit the attributes and methods of another class, promoting code reuse and facilitating the creation of a hierarchy of related classes. Mixin modules provide a way to share behavior among multiple classes without creating a rigid class hierarchy. ### Inheritance Inheritance is a mechanism where one class, known as the child or subclass, can inherit the properties and behavior of another class, known as the parent or superclass. The child class inherits all the attributes and methods of the parent class and can also add new attributes and methods or override the ones inherited from the parent class. Here is an example of inheritance in Ruby: ```ruby # animal.rb class Animal attr_accessor :name def initialize(name) @name = name end def speak puts "Animal makes a sound" end end # dog.rb class Dog < Animal def initialize(name, breed) super(name) # call the Animal class's initialize method @breed = breed end def speak puts "Dog barks" end def display_breed puts "Breed: #{@breed}" end end my_dog = Dog.new("Rex", "Golden Retriever") my_dog.speak # outputs: Dog barks my_dog.display_breed # outputs: Breed: Golden Retriever ``` In the code above, `Animal` is the parent class and `Dog` is the child class. The `Dog` class inherits the `name` attribute and the `speak` method from the `Animal` class and adds a new attribute `breed` and methods `display_breed`. The `speak` method in the `Dog` class overrides the one inherited from the `Animal` class. ### Mixin Modules Mixin modules provide a way to share behavior among multiple classes without creating a rigid class hierarchy. A mixin module is a module that defines methods that can be used by multiple classes. Here is an example of mixin modules in Ruby: ```ruby # printable.rb module Printable def print puts "Printing..." end end # book.rb class Book include Printable attr_accessor :title, :author def initialize(title, author) @title = title @author = author end end # document.rb class Document include Printable attr_accessor :content def initialize(content) @content = content end end my_book = Book.new("Ruby Programming", "Author Name") my_book.print # outputs: Printing... my_document = Document.new("Document content") my_document.print # outputs: Printing... ``` In the code above, `Printable` is a mixin module that defines the `print` method. Both `Book` and `Document` classes include the `Printable` module and thus inherit the `print` method. ### Key Concepts * **Inheritance**: a mechanism where one class inherits the properties and behavior of another class. * **Mixin modules**: modules that define methods that can be used by multiple classes. * **Superclass**: the parent class in an inheritance hierarchy. * **Subclass**: the child class in an inheritance hierarchy. * **Override**: when a subclass provides a different implementation of a method inherited from its superclass. ### Practical Takeaways * Use inheritance when there is a clear "is-a" relationship between classes. * Use mixin modules to share behavior among multiple classes without creating a rigid class hierarchy. ### Additional Resources * [Ruby Documentation on Modules](https://ruby-doc.org/core-3.1.2/Module.html) * [Ruby Documentation on Classes and Objects](https://ruby-doc.org/core-3.1.2/Class.html) ### What's Next? In the next topic, we will explore the concept of self and class methods in Ruby. We will learn how to define and use self and class methods, including how to use them to create class variables and instance variables. Do you have any questions or need clarification on any of the concepts covered in this topic? Please leave a comment below.