notebooks/OverridingMethods.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "hungry-louisville",
   "metadata": {},
   "source": [
    "# Overriding Methods in Ruby\n",
    "\n",
    "**Method overriding**, in object oriented programming, is a language feature that allows a subclass to provide a specific implementation of a method that is already provided by one of its super-class. The implementation in the subclass _overrides_ (replaces) the implementation in the super-class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "stable-majority",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In class B\n"
     ]
    }
   ],
   "source": [
    "class A\n",
    "  def a\n",
    "    puts 'In class A'\n",
    "  end\n",
    "end\n",
    "\n",
    "class B < A\n",
    "  def a\n",
    "    puts 'In class B'\n",
    "  end\n",
    "end\n",
    "\n",
    "b = B.new\n",
    "b.a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "industrial-positive",
   "metadata": {},
   "source": [
    "The method `a` in class `B` overrides the method `a` in class `A`.\n",
    "\n",
    "## Usage of `super`\n",
    "\n",
    "The way `super` handles arguments is as follows:\n",
    "\n",
    "- When you invoke `super` with no arguments, Ruby sends a message to the parent of the current object, asking it to invoke a method of the same name as the method invoking `super`. It automatically forwards the arguments that were passed to the method from which it's called.\n",
    "- Called with an empty argument list - `super()` - it sends no arguments to the higher-up method, even if arguments where passed to the current method.\n",
    "- Called with specific arguments - `super(a, b, c)` - it sends exactly those arguments.\n",
    "\n",
    "An example from Ruby for Rails book highlights this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "sharing-emerald",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n",
      "2\n",
      "1\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "class Bicycle\n",
    "  attr_reader :gears, :wheels, :seats\n",
    "  def initialize(gears=1)\n",
    "    @wheels = 2\n",
    "    @seats = 1\n",
    "    @gears = gears\n",
    "  end\n",
    "end\n",
    "\n",
    "class Tandem < Bicycle\n",
    "  def initialize(gears)\n",
    "    super\n",
    "    @seats = 2\n",
    "  end\n",
    "end\n",
    "\n",
    "t = Tandem.new(2)\n",
    "puts t.gears\n",
    "puts t.wheels\n",
    "puts t.seats\n",
    "\n",
    "b = Bicycle.new\n",
    "puts b.gears\n",
    "puts b.wheels\n",
    "puts b.seats"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "drawn-customs",
   "metadata": {},
   "source": [
    "We shall be talking in depth about [`attr_reader`](AccessControl.ipynb) later.\n",
    "\n",
    "## Redefining Methods\n",
    "\n",
    "(Adapted from David Black's book, Ruby For Rails)\n",
    "\n",
    "Nothing stops you from defining a method twice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "amended-tribune",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Second definition of method mtd\n"
     ]
    }
   ],
   "source": [
    "class OR\n",
    "  def mtd\n",
    "    puts 'First definition of method mtd'\n",
    "  end\n",
    "  def mtd\n",
    "    puts 'Second definition of method mtd'\n",
    "  end\n",
    "end\n",
    "\n",
    "OR.new.mtd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hawaiian-evanescence",
   "metadata": {},
   "source": [
    "The printed result is the _Second definition of the method `mtd`_. The second definition has prevailed: We see the output from that definition, not from the first one. _Nothing stops you from defining a method twice, however the new version takes precedence_."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "decimal-waste",
   "metadata": {},
   "source": [
    "## Abstract class\n",
    "\n",
    "In Ruby, we can define an _abstract_ class that invokes certain undefined \"abstract\" methods, which are left for subclasses to define. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "better-milan",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Ruby students\n"
     ]
    }
   ],
   "source": [
    "=begin\n",
    "This class is abstract; it doesn't define hello or name\n",
    "No special syntax is required: any class that invokes methods\n",
    "that are intended for a subclass to implement is abstract\n",
    "=end\n",
    "class AbstractClass\n",
    "  def welcome\n",
    "    puts \"#{hello} #{name}\"\n",
    "  end\n",
    "end\n",
    "\n",
    "# A concrete class\n",
    "class ConcreteClass < AbstractClass\n",
    "  def hello; \"Hello\"; end\n",
    "  def name; \"Ruby students\"; end\n",
    "end\n",
    "\n",
    "ConcreteClass.new.welcome"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ruby 3.0.0",
   "language": "ruby",
   "name": "ruby"
  },
  "language_info": {
   "file_extension": ".rb",
   "mimetype": "application/x-ruby",
   "name": "ruby",
   "version": "3.0.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}