2023-10-06-lessonStudent.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "toc: true\n",
    "comments: true\n",
    "layout: post\n",
    "title: U9 Inheritance P1 Student\n",
    "description: Lesson on Java class hierarchy.\n",
    "type: ccc\n",
    "courses: { csa: {week: 11} }\n",
    "authors: David, Alex, Drew, Derrick, Jishnu\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.1 Superclasses and Subclasses\n",
    "> A hierarchy of classes is created, extending attributes into subclasses of information (ie. Automobile --> Trucks and Sedans --> Ford, BMW, Nissan, Toyota). \n",
    "\n",
    "### Pre-Requisites\n",
    "\n",
    "Before we start you need to remember what classes and methods are. Scopes of variables are also important to this section because you need to know which classes can access which variables before extending a variable across classes.\n",
    "\n",
    "#### Scope of Variables:\n",
    "\n",
    "Variables can be declared as private or public.\n",
    "\n",
    "> **Popcorn Hack:** What are scope do private and public variables allow?\n",
    "\n",
    "| Private | Public |\n",
    "|-|-|\n",
    "| only directly accessible within the class they are declared | accessible anywhere inside and outside their class |\n",
    "\n",
    "These are different types of variables. Only `INSTANCE` and `STATIC` variables can be declared as ____ or ____.\n",
    "\n",
    "| Variable Type | Definition | Scope within Class | Scope to Subclasses |\n",
    "|-|-|-|-|\n",
    "|  | variables within methods | cannot be accessed outside method | cannot be accessed outside class |\n",
    "|  | variables within a class but not inside a method | can be accessed in entire class | can be accessed in subclasses |\n",
    "|  | variables that belong to a class, not instance | can be accessed in entire class | can be accessed in subclasses |\n",
    "|  | variables specific in passing values to the method | cannot be accessed outside method | do not affect inheritance |\n",
    "\n",
    "Now we can go into class hierarchies."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Hierarchy\n",
    "\n",
    "**Definitions**\n",
    "- Superclasses - a class that contains all the common ____ and ____ that could be shared among other classes (a blueprint for subclasses)\n",
    "- Subclasses - extends the ____ to is specified by a superclass; can also have additional specific attributes\n",
    "- \"Is-A\" Relationship - the relationship when a subclass ____ a superclass (ie. Automobile --> Sedan; a Sedan \"is-a\" automobile)\n",
    "\n",
    "#### `extends` Keyword\n",
    "> extends the ____ from the ____"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Toyota\n",
      "Car is starting\n",
      "Ford\n",
      "1000\n",
      "Loading cargo into the truck\n",
      "BMW\n",
      "true\n",
      "Sedan is accelerating\n"
     ]
    }
   ],
   "source": [
    "class Automobile {\n",
    "  public String brand; // public instance var\n",
    "  private String model; // private instance var\n",
    "\n",
    "  public Automobile(String brand, String model) {\n",
    "    this.brand = brand;\n",
    "    this.model = model;\n",
    "  }\n",
    "\n",
    "  public void start() {\n",
    "    System.out.println(\"Car is starting\");\n",
    "  }\n",
    "}\n",
    "\n",
    "class Truck extends Automobile {\n",
    "  public int cargoCapacity; // subclass specific var\n",
    "\n",
    "  // instance that is specific to the Truck subclass, with vars from Automobile class\n",
    "  public Truck(String brand, String model, int cargoCapacity) {\n",
    "    super(brand, model); // inherited vars\n",
    "    this.cargoCapacity = cargoCapacity;\n",
    "  }\n",
    "\n",
    "  // specific method to Truck\n",
    "  public void loadCargo() {\n",
    "    System.out.println(\"Loading cargo into the truck\");\n",
    "  }\n",
    "}\n",
    "\n",
    "class Sedan extends Automobile {\n",
    "  public boolean isLuxury; // subclass specific var\n",
    "\n",
    "  // instance that is specific to the Sedan subclass, with vars from Automobile class\n",
    "  public Sedan(String brand, String model, boolean isLuxury) {\n",
    "    super(brand, model); // inherited vars\n",
    "    this.isLuxury = isLuxury;\n",
    "  }\n",
    "\n",
    "  // specific method to Sedan\n",
    "  public void accelerate() {\n",
    "    System.out.println(\"Sedan is accelerating\");\n",
    "  }\n",
    "}\n",
    "\n",
    "public class Main {\n",
    "    public static void main(String[] args) {\n",
    "        Automobile car = new Automobile(\"Toyota\", \"Camry\");\n",
    "        Truck truck = new Truck(\"Ford\", \"F-150\", 1000);\n",
    "        Sedan sedan = new Sedan(\"BMW\", \"328i\", true);\n",
    "\n",
    "        // automobile methods and variables\n",
    "        System.out.println(car.brand); // Accessing public variable\n",
    "        // System.out.println(car.model); // compilation error because of the private var\n",
    "        car.start();\n",
    "\n",
    "\n",
    "        // truck methods and variables\n",
    "        System.out.println(truck.brand); // inherited public var\n",
    "        System.out.println(truck.cargoCapacity); // public var specific to truck\n",
    "        truck.loadCargo();\n",
    "\n",
    "\n",
    "        // sedan methods and variables\n",
    "        System.out.println(sedan.brand); // inherited public var\n",
    "        System.out.println(sedan.isLuxury); // public var specific to sedan\n",
    "        sedan.accelerate();\n",
    "    }\n",
    "}\n",
    "\n",
    "Main.main(null);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example shows how the `Automobile` class is extended twice, with the `Truck` and `Sedan` subclasses.\n",
    "\n",
    "> **Popcorn Hack:** If I were to declare a variable `color` that is `private` in the class Automobile, would I be able to extend and directly access that variable to the subclass `Truck` or `Sedan`?\n",
    "\n",
    "A: No, you would need to encapsulate the private variable as shown above, through a method in the superclass and then inherit that var with `super()`, which will be explained later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.2 Writing Constructors for Subclasses\n",
    "\n",
    "### Learning Objectives\n",
    "\n",
    "- Constructors are not inherited\n",
    "- When a subclass's constructor doesn't explicitly call a superclass's constructor using `super`, Java inserts a call to the superclass's no-argument constructor.\n",
    "- The actual parameters passed in the call to the superclass constructor provide values that the constructor can use to initialize the object's instance variables.\n",
    "- Regardless of whether the superclass constructor is called implicitly or explicitly, the process of calling superclass constructors continues until the Object constructor is called. At this point, all of the constructors within the hierarchy execute beginning with the Object constructor.\n",
    "\n",
    "**Important note:** Constructors are NOT inherited by the subclass. See this in action below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "// TO BE INCLUDED EARLIER IN THE LESSON. IT IS NECESSARY FOR THE FUNCTIONALITY OF THIS SECTION.\n",
    "\n",
    "class Vehicle {\n",
    "    public int year;\n",
    "    public String manufacturer;\n",
    "\n",
    "    public Vehicle(int year, String manufacturer) { // constructor for parent class\n",
    "        this.year = year;\n",
    "        this.manufacturer = manufacturer;\n",
    "    }\n",
    "\n",
    "    public Vehicle() {\n",
    "        this.year = 2000;\n",
    "        this.manufacturer = \"Unknown\";\n",
    "    }\n",
    "\n",
    "    // method to be used later\n",
    "    public void drive() {\n",
    "        System.out.println(\"The driver is driving the car.\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Year: 2000\n",
      "Manufacturer: Unknown\n",
      "Model: Altima\n"
     ]
    }
   ],
   "source": [
    "class Car extends Vehicle {\n",
    "    public String model;\n",
    "\n",
    "    public Car(String model) {\n",
    "        this.model = model;\n",
    "    }\n",
    "}\n",
    "\n",
    "public class VehicleDemonstration {\n",
    "    public static void main(String[] args) {\n",
    "        Car myCar = new Car(\"Altima\");\n",
    "        System.out.println(\"Year: \" + myCar.year);\n",
    "        System.out.println(\"Manufacturer: \" + myCar.manufacturer);\n",
    "        System.out.println(\"Model: \" + myCar.model);\n",
    "    }\n",
    "}\n",
    "\n",
    "VehicleDemonstration.main(null);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the output uses the no-argument construction info from the base `Vehicle` constructor.\n",
    "\n",
    "The `super` keyword can be used to change parent constructor values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Year: 2016\n",
      "Manufacturer: Nissan\n",
      "Model: Altima\n"
     ]
    }
   ],
   "source": [
    "class NewCar extends Vehicle {\n",
    "    public String model;\n",
    "\n",
    "    public NewCar(int year, String manufacturer, String model) {\n",
    "        super(year, manufacturer); // see the use of super here\n",
    "        // what happens if you use no arguments with super()? see reminders below\n",
    "        this.model = model;\n",
    "    }\n",
    "}\n",
    "\n",
    "public class VehicleDemonstration2 {\n",
    "    public static void main(String[] args) {\n",
    "        NewCar myCar = new NewCar(2016, \"Nissan\", \"Altima\");\n",
    "        System.out.println(\"Year: \" + myCar.year);\n",
    "        System.out.println(\"Manufacturer: \" + myCar.manufacturer);\n",
    "        System.out.println(\"Model: \" + myCar.model);\n",
    "    }\n",
    "}\n",
    "\n",
    "VehicleDemonstration2.main(null);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Key Reminders:\n",
    "\n",
    "1. If you do call `super()` in your constructor, it <mark>has to be the first line of the constructor</mark>.\n",
    "2. You <mark>cannot</mark> assign values to parent attributes/variables without using `super()`.\n",
    "3. If you call `super()` with no arguments, <mark>it will use the no-argument parent constructor</mark>. This also happens automatically if you don't include any `super()` call.\n",
    "\n",
    "## 9.3 Overriding Methods\n",
    "\n",
    "### Learning Objectives\n",
    "\n",
    "- Method overriding occurs when a public method in a subclass has the same method signature as a public method in the superclass.\n",
    "- Any method that is called must be defined within its own class or its superclass.\n",
    "- A subclass is usually designed to have modified (overwritten) or additional methods or instance variables.\n",
    "- A subclass will inherit all public methods from the superclass; these methods remain public in the subclass.\n",
    "\n",
    "There are three options for methods to be used by subclasses:\n",
    "\n",
    "1. Methods inherited from the parent class\n",
    "2. Unique methods written for the subclass\n",
    "3. Override parent methods to modify its implementation\n",
    "\n",
    "The first two should make sense. Let's see an example of overriding parent methods below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This car is driving itself!\n"
     ]
    }
   ],
   "source": [
    "public class NuroCar extends Vehicle {\n",
    "    private String deliveryItem;\n",
    "\n",
    "    // unique constructor\n",
    "    public NuroCar(int year, String manufacturer, String deliveryItem) {\n",
    "        super(year, manufacturer); // another use of super\n",
    "        this.deliveryItem = deliveryItem;\n",
    "    }\n",
    "\n",
    "    // HERE is the overridden function\n",
    "    public void drive() {\n",
    "        System.out.println(\"This car is driving itself!\");\n",
    "    }\n",
    "}\n",
    "\n",
    "public class VehicleDemonstration3 {\n",
    "    public static void main(String[] args) {\n",
    "        NuroCar pizzaCar = new NuroCar(2023, \"Nuro\", \"Pizza\");\n",
    "        // here's the call to the overridden function\n",
    "        pizzaCar.drive();\n",
    "    }\n",
    "}\n",
    "\n",
    "VehicleDemonstration3.main(null);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be very helpful if you want a certain parent method to function slightly differently for a certain subclass.\n",
    "\n",
    "#### Popcorn Hack\n",
    "\n",
    "A parent class `Animal` is often used to show how subclasses can differ from their parent classes. An `Animal` parent class is provided in the cell below. Create a subclass of a certain species that <mark>overrides a parent method</mark> and <mark>uses `super` to call to the parent's constructor while adding its own unique attributes</mark>.\n",
    "\n",
    "Hint: <button id=\"but1\" onclick=\"hint(1)\">See Hint</button>\n",
    "<div id=\"hint1\" style=\"display:none;\">Not all animals \"run\" like the `move()` function says...</div>\n",
    "<script>\n",
    "    function hint(number) {\n",
    "        document.getElementById(\"but\" + String(number)).style.display = \"none\";\n",
    "        document.getElementById(\"hint\" + String(number)).style.display = \"block\";\n",
    "    }\n",
    "</script>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "// parent class\n",
    "public class Animal {\n",
    "    private String species;\n",
    "    private int milesPerHour;\n",
    "\n",
    "    // no argument constructor\n",
    "    public Animal() {\n",
    "        this.species = \"Unknown\";\n",
    "        this.milesPerHour = 10;\n",
    "    }\n",
    "\n",
    "    // constructor with arguments\n",
    "    public Animal(String species, int milesPerHour) {\n",
    "        this.species = species;\n",
    "        this.milesPerHour = milesPerHour;\n",
    "    }\n",
    "\n",
    "    // parent method\n",
    "    public void move() {\n",
    "        System.out.println(\"The \" + this.species.toLowerCase() + \" runs at \" + this.milesPerHour + \" miles per hour.\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// your subclass goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.4 Super Keyword"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using the super keyword to call a superclass's method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BalletDancer class: \n",
      "Honing my craft!\n",
      "Leaping...\n",
      "Spinning...\n"
     ]
    }
   ],
   "source": [
    "public class Performer { //superclass\n",
    "    public void practice(){\n",
    "        System.out.println(\"Honing my craft!\");\n",
    "    }\n",
    "    public void perform(){\n",
    "        System.out.println(\"Performing for an audience!\");\n",
    "    }\n",
    "}\n",
    "\n",
    "public class Dancer extends Performer { //subclass\n",
    "    public void perform(){\n",
    "        System.out.println(\"Dancing on the stage!\");\n",
    "    }\n",
    "}\n",
    "\n",
    "public class BalletDancer extends Dancer { //subclass\n",
    "    public void jete(){\n",
    "        System.out.println(\"Leaping...\");\n",
    "    }\n",
    "    public void pirouette(){\n",
    "        System.out.println(\"Spinning...\");\n",
    "    }\n",
    "    public void perform(){\n",
    "        jete();\n",
    "        pirouette();\n",
    "    }\n",
    "        public static void main(String[] args){\n",
    "            BalletDancer derrick = new BalletDancer();\n",
    "            derrick.practice();\n",
    "            derrick.perform();\n",
    "        }\n",
    "}\n",
    "\n",
    "System.out.println(\"BalletDancer class: \");\n",
    "BalletDancer.main(null);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "public class Performer { //superclass of Dancer class\n",
    "    public void practice(){\n",
    "        System.out.println(\"Honing my craft!\");\n",
    "    }\n",
    "    public void perform(){\n",
    "        System.out.println(\"Performing for an audience!\");\n",
    "    }\n",
    "}\n",
    "\n",
    "public class Dancer extends Performer { //superclass of BalletDancer class\n",
    "    public void perform(){\n",
    "        System.out.println(\"Dancing on the stage!\");\n",
    "    }\n",
    "}\n",
    "\n",
    "public class BalletDancer extends Dancer {\n",
    "    public void jete(){\n",
    "        System.out.println(\"Leaping...\");\n",
    "    }\n",
    "    public void pirouette(){\n",
    "        System.out.println(\"Spinning...\");\n",
    "    }\n",
    "    public void perform(){ \n",
    "        perform();//Why is this wrong?\n",
    "        jete();\n",
    "        pirouette();\n",
    "    }\n",
    "        public static void main(String[] args){\n",
    "            BalletDancer derrick = new BalletDancer();\n",
    "            derrick.practice();\n",
    "            derrick.perform();\n",
    "        }\n",
    "}\n",
    "\n",
    "System.out.println(\"BalletDancer class: \");\n",
    "BalletDancer.main(null);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note:\n",
    "Super keyword can be placed in any order as it prints out chronologically. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "public void perform(){ \n",
    "    super.perform();\n",
    "    jete();\n",
    "    pirouette();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "\"Honing my craft!\n",
    "Dancing on the stage!\n",
    "Leaping...\n",
    "Spinning...\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### However, if we were to write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "public void perform(){ \n",
    "    jete();\n",
    "    pirouette();\n",
    "    super.perform();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "\"Honing my craft!\n",
    "Leaping...\n",
    "Spinning...\n",
    "Dancing on the stage!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What if we use 2 super keywords?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BalletDancer class: \n",
      "Honing my craft!\n",
      "Performing for an audience!\n",
      "Dancing on the stage!\n",
      "Leaping...\n",
      "Spinning...\n"
     ]
    }
   ],
   "source": [
    "public class Performer { //superclass\n",
    "    public void practice(){\n",
    "        System.out.println(\"Honing my craft!\");\n",
    "    }\n",
    "    public void perform(){\n",
    "        System.out.println(\"Performing for an audience!\");\n",
    "    }\n",
    "}\n",
    "\n",
    "public class Dancer extends Performer { //subclass\n",
    "    public void perform(){\n",
    "        super.perform();\n",
    "        System.out.println(\"Dancing on the stage!\");\n",
    "    }\n",
    "}\n",
    "\n",
    "public class BalletDancer extends Dancer { //subclass\n",
    "    public void jete(){\n",
    "        System.out.println(\"Leaping...\");\n",
    "    }\n",
    "    public void pirouette(){\n",
    "        System.out.println(\"Spinning...\");\n",
    "    }\n",
    "    public void perform(){\n",
    "        super.perform();\n",
    "        jete();\n",
    "        pirouette();\n",
    "    }\n",
    "        public static void main(String[] args){\n",
    "            BalletDancer derrick = new BalletDancer();\n",
    "            derrick.practice();\n",
    "            derrick.perform();\n",
    "        }\n",
    "}\n",
    "\n",
    "System.out.println(\"BalletDancer class: \");\n",
    "BalletDancer.main(null);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Popcorn Hack\n",
    "Create a subclass and a superclass by calling the methods from the superclass from the subclass using the keyword super.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "// place code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9.5 Creating References Using Inheritance Hierarchies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inheritance Hierarchies is the idea that:\n",
    "\n",
    "- If we have a public superclass (A) that then has a public subclass (B) and that public subclass then has another public subclass (C), then the subclass C is also a subclass of the superclass A and so subclass C is extending superclass A\n",
    "\n",
    "Here is an example of this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "// Class Declarations:\n",
    "\n",
    "// Superclass (A)\n",
    "public class Vehicles{}\n",
    "// Subclass (B)\n",
    "public class Car extends Vehicles{}\n",
    "// Subclass (C)\n",
    "public class Sedan extends Car{}\n",
    "// Subclass (D)\n",
    "public class Truck extends Vehicles{}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a diagram displaying this relationship:\n",
    "\n",
    "![Inheritance Hierarchy Example](https://raw.githubusercontent.com/JishnuS420/BlogCSA/main/images/inheritance-hierarchy-example.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- This diagram shows the the vehicle superclass which then has two subclasses: Car and Truck, however, Car has another subclass called Sedan\n",
    "\n",
    "- Based on this diagram, we know that Truck has a \"is-a\" relationship with Vehicle, Car also has a \"is-a\" relationship with Vehicle, and since Car has an \"is-a\" relationship with Vehicle, so does Sedan\n",
    "\n",
    "- So Sedan also has a \"is-a\" relationship with Vehicle\n",
    "\n",
    "If we assume that all of the class contain a constructor with no arguments, this then allows for us to declare a superclass reference variable to hold a subclass object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "Vehicles v1 = new Truck();\n",
    "Vehicles v2 = new Car();\n",
    "\n",
    "// instead of doing\n",
    "Car v3 = new Sedan();\n",
    "// We have the option to do this instead\n",
    "Vehicles v4 = new Sedan();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, it is important to remember that you can't declare a Subclass variable and put in a Superclass object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "// don't do this\n",
    "Sedan v5 = new Vehicle();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Popcorn Hack: Using a superclass and subclasses of your choice, assuming that the classes contain a constructor with no arguments, create Class Declarations and Superclass References"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "// show here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why would we want to do this?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- When doing object oriented programming, we are able to create a superclass with common attributes and then have subclasses with more specific traits \n",
    "\n",
    "- By doing this, we get rid of code redundancy and it also makes the easier to reuse common aspects without needing to write them out every time while still presenting the option to override any attribute from the superclass to better represent the subclass\n",
    "\n",
    "- All the subclasses adhere to one superclass so this makes updates to code much easier and allows you to take advantage of **polymorphism** to unify the code and allow for more flexible and manageable code (more about this in 9.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Here is a Complete Example of the Inheritance Hierarchy from above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Truck Information:\n",
      "Brand: Ford\n",
      "Year: 2023\n",
      "Max Load Capacity: 10.5 tons\n",
      "\n",
      "Car Information:\n",
      "Brand: Toyota\n",
      "Year: 2023\n",
      "Number of Doors: 4\n",
      "\n",
      "Sedan Information:\n",
      "Brand: Honda\n",
      "Year: 2023\n",
      "Number of Doors: 4\n",
      "Leather Seats: true\n"
     ]
    }
   ],
   "source": [
    "class Vehicle {\n",
    "    private String brand; // private instance variable\n",
    "    private int year; // private instance variable\n",
    "\n",
    "    public Vehicle(String brand, int year) {\n",
    "        this.brand = brand;\n",
    "        this.year = year;\n",
    "    }\n",
    "\n",
    "    public void displayInfo() { // common variables for each vehicle\n",
    "        System.out.println(\"Brand: \" + brand);\n",
    "        System.out.println(\"Year: \" + year);\n",
    "    }\n",
    "}\n",
    "\n",
    "class Truck extends Vehicle {\n",
    "    // feature that only a truck can have\n",
    "    private double maxLoadCapacity;\n",
    "\n",
    "    public Truck(String brand, int year, double maxLoadCapacity) {\n",
    "        super(brand, year); // Inherits the variables from superclass\n",
    "        this.maxLoadCapacity = maxLoadCapacity;\n",
    "    }\n",
    "\n",
    "    @Override // Override allows for displayInfo to now also show the trait specific to the Truck while still keeping the main variables\n",
    "    public void displayInfo() {\n",
    "        super.displayInfo(); // Reuse the displayInfo method from the superclass\n",
    "        System.out.println(\"Max Load Capacity: \" + maxLoadCapacity + \" tons\");\n",
    "    }\n",
    "}\n",
    "\n",
    "class Car extends Vehicle {\n",
    "    // something that cars have\n",
    "    private int numberOfDoors;\n",
    "\n",
    "    public Car(String brand, int year, int numberOfDoors) {\n",
    "        super(brand, year);\n",
    "        this.numberOfDoors = numberOfDoors;\n",
    "    }\n",
    "\n",
    "    @Override // Override allows for displayInfo to now also show the trait specific to the Car while still keeping the main variables\n",
    "    public void displayInfo() {\n",
    "        super.displayInfo(); // Reuse the displayInfo method from the superclass\n",
    "        System.out.println(\"Number of Doors: \" + numberOfDoors);\n",
    "    }\n",
    "}\n",
    "\n",
    "class Sedan extends Car {\n",
    "    // Sedan is luxury so trait specific to sedan\n",
    "    private boolean leatherSeats;\n",
    "\n",
    "    public Sedan(String brand, int year, int numberOfDoors, boolean leatherSeats) {\n",
    "        super(brand, year, numberOfDoors);\n",
    "        this.leatherSeats = leatherSeats;\n",
    "    }\n",
    "\n",
    "    @Override // Override allows for displayInfo to now also show the trait specific to the Sedan while still keeping the main variables\n",
    "    public void displayInfo() {\n",
    "        super.displayInfo(); // Reuse the displayInfo method from the superclass\n",
    "        System.out.println(\"Leather Seats: \" + leatherSeats);\n",
    "    }\n",
    "}\n",
    "\n",
    "public class Main {\n",
    "    public static void main(String[] args) {\n",
    "        Vehicle v1 = new Truck(\"Ford\", 2023, 10.5);\n",
    "        Vehicle v2 = new Car(\"Toyota\", 2023, 4);\n",
    "        Vehicle v3 = new Sedan(\"Honda\", 2023, 4, true);\n",
    "\n",
    "        System.out.println(\"Truck Information:\");\n",
    "        v1.displayInfo();\n",
    "        \n",
    "        System.out.println(\"\\nCar Information:\");\n",
    "        v2.displayInfo();\n",
    "        \n",
    "        System.out.println(\"\\nSedan Information:\");\n",
    "        v3.displayInfo();\n",
    "    }\n",
    "}\n",
    "Main.main(null)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Popcorn Hack: In your own words describe the importance of Inheritance Hierarchies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9.6 Polymorphism\n",
    "\n",
    "## Learning Objectives\n",
    "<mark>MOD-3.D</mark>: Call methods in an inheritance relationship.  \n",
    "<mark>MOD-3.D.1</mark>: Utilize the Object class through inheritance.  \n",
    "<mark>MOD-3.D.2</mark>: At compile time, methods in or inherited by the declared type determine the correctness of a non-static method call.  \n",
    "<mark>MOD-3.D.3</mark>: At run-time, the method in the actual object type is executed for a non-static method call.  \n",
    "\n",
    "## What is Polymorphism?\n",
    "**Polymorphism** is a greek word meaning many-formed (poly=many, morph=form). In the context of programming, Polymorphic behavior is defined as being able to reference objects of different types at different points during compilation.  \n",
    "\n",
    "One example of Java polymorphism, is our ability to store references to objects instantiated from any class AND its *subclasses* in a variable. Another example is for methods, where we override the behavior of a method in a subclass such that it differs from the parent class. We successfully perform polymorphism when we override non-static methods and execute them from the correct, corresponding class at runtime.  \n",
    "\n",
    "Here is a simple example of polymorphism:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "// This is our Parent class\n",
    "class Shape {\n",
    "    public void draw() {\n",
    "        System.out.println(\"Drawing a shape\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// Subclass 1\n",
    "class Circle extends Shape {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        System.out.println(\"Drawing a circle\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// Subclass 2\n",
    "class Rectangle extends Shape {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        System.out.println(\"Drawing a rectangle\");\n",
    "    }\n",
    "}\n",
    "\n",
    "public class Main {\n",
    "    public static void main(String[] args) {\n",
    "        \n",
    "        // Here we have reference variables circle and rectangle defined with static type \"Shape\"\n",
    "        Shape circle = new Circle();            // Circle has dynamic type \"Circle\"\n",
    "        Shape rectangle = new Rectangle();      // Rectangle has dynamic type \"Rectangle\"\n",
    "        \n",
    "        // Calling the draw() method\n",
    "        circle.draw();    // Output: Drawing a circle\n",
    "        rectangle.draw(); // Output: Drawing a rectangle\n",
    "    }\n",
    "}\n",
    "\n",
    "Main.main(null);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even though the circle and rectangle have identical data-types, the compiler knows to call the correct method at run-time. We have successfully performed polymorphism"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Popcorn hack\n",
    "1. Create any example of polymorphism, perferably with a class from your project, with corresponding methods and attributes as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "// Program your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Static and Dynamic types\n",
    "Typically in Java, a reference variable storing an object instantiated from a child class can only store other objects of that class. If we try to store an object of another class, we'd get an error i.e.  \n",
    "\n",
    "```java\n",
    "Integer myNumber = new Integer(6);      // Instantiates an Integer object\n",
    "System.out.println(myNumber);           // Would print Integer type 6 normally\n",
    "myNumber = new Double(6.1);             // Compile error occurs, incompatible types\n",
    "System.out.println(myNumber);           // This line is not reached\n",
    "```  \n",
    "\n",
    "But what if we want want a reference variable to store objects of other classes? We get an error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compile-time vs Runtime methods\n",
    "Sometimes, when we perform polymorphism, we have to be careful to distinguish between our **compile time** and **run-time** methods. When we instantiate a dynamic variable that is of *a different type* from our static variable, our program at run time will attempt to search for the methods and attributes in the superclass, NOT the child class that we created. Although the compiled program will still output the correct outputs of the method in the child class, it will not be able to find a method that exists in the child class but not in the parent class.  \n",
    "\n",
    "To resolve this issue, we need use **Down-casting**.\n",
    " - **Downcasting**: Essentially telling the compiler to refer to a variable's subclass (the programmer specifies this), instead of the static type. We are telling the compiler to search our dynamic type for the methods and attributes that we want to access.\n",
    "\n",
    "Below is an example of compile versus run-time methods and downcasting that I used in our group's project."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "import java.util.HashMap;\n",
    "// This is our parent class for all child classes that make up a graph\n",
    "public class GraphObject {\n",
    "    private int value;\n",
    "\n",
    "    // constructor\n",
    "    public GraphObject(int value) {\n",
    "        this.value = value;\n",
    "    }\n",
    "\n",
    "    // getter method\n",
    "    public int getValue() {\n",
    "        return this.value;\n",
    "    }\n",
    "\n",
    "    // setter method\n",
    "    public void setValue(int value) {\n",
    "        this.value = value;\n",
    "    }\n",
    "\n",
    "    // Method overloading to print object to terminal\n",
    "    @Override\n",
    "    public String toString() {\n",
    "        return Integer.toString(this.value);\n",
    "    }\n",
    "}\n",
    "\n",
    "// This is our child class. Represents a vertex or a node in a graph\n",
    "public class GraphNode extends GraphObject {\n",
    "    private HashMap<Integer,Integer> edges;     // Hashmap of destination vertices and weights of paths <Target:Weight>\n",
    "\n",
    "    // Constructor of child class\n",
    "    public GraphNode(int value, HashMap<Integer,Integer> edges){\n",
    "        super(value);                           // super keyword to run constructor of parent class, which sets the value of the node\n",
    "        this.edges = edges;                     // adds any needed edges\n",
    "    }\n",
    "\n",
    "    public HashMap<Integer,Integer> getEdges() {\n",
    "        return this.edges;\n",
    "    }\n",
    "\n",
    "    public void addEdge(int targetId, int weight) {\n",
    "        this.edges.put(targetId, weight);\n",
    "    }\n",
    "\n",
    "    public void removeEdge(int targetId) {\n",
    "        this.edges.remove(targetId);\n",
    "    }\n",
    "    \n",
    "    // Overloading the toString method of the parent class, using super to get the output of the parent class\n",
    "    @Override\n",
    "    public String toString() {\n",
    "        return \"GraphNode[value=\" + super.toString() + \",edges=\" + this.edges + \"]\";\n",
    "    }\n",
    "} \n",
    "HashMap<Integer, Integer> node1Connections = new HashMap<Integer, Integer>();\n",
    "node1Connections.put(2, 7);\n",
    "node1Connections.put(3, 2);\n",
    "node1Connections.put(4, 10);\n",
    "GraphObject node1 = new GraphNode(1, node1Connections);\n",
    "System.out.println(node1.toString());\n",
    "((GraphNode)node1).addEdge(5,6);        // Here, we downcast node1, which is a GraphObject, to what it references, which is GraphNode\n",
    "// node1.addEdge(5,6);                  // This wouldn't work as the compiler attempts to find addEdge() in GraphObject, which it can't, throwing an error  \n",
    "System.out.println(node1.toString());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Popcorn Hacks\n",
    "1. Define each of the following terms in your own words\n",
    " - **Downcasting**\n",
    " - **Static Type**\n",
    " - **Dynamic Type**\n",
    " - **Polymorphism**\n",
    " - **Compile-time method**\n",
    " - **Run-time method**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [],
   "source": [
    "// Do popcorn hack here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9.7 Object Superclass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The Object class is the superclass of all other classes as well as data types and is a part of the java.lang package\n",
    "\n",
    "-  If a parent class doesn't specify by using the `extends` keyword, the class will inherit from the Object \n",
    "\n",
    "- `String toString()` and `boolean equals(object other)` are the most frequently used and subclasses of Object override the equals and toString methods by using class-specific implementations\n",
    "\n",
    "Normally when you use the `toString` method without overriding it, it returns a hash code value as seen in the example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REPL.$JShell$18$Person@4da14117\n"
     ]
    }
   ],
   "source": [
    "class Person {\n",
    "    private String name;\n",
    "    private int age;\n",
    "\n",
    "    public Person(String name, int age) {\n",
    "        this.name = name;\n",
    "        this.age = age;\n",
    "    }\n",
    "}\n",
    "\n",
    "public class ToStringNoOverride {\n",
    "    public static void main(String[] args) {\n",
    "        Person person = new Person(\"Alice\", 25);\n",
    "        // When you print this out, it will return the hash code since its using the default method for toString\n",
    "        System.out.println(person);\n",
    "    }\n",
    "}\n",
    "ToStringNoOverride.main(null)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, we can fix this by creating a new method by **overriding** the normal `toString` method and building our own representation of the object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Person Name: Alice\n",
      "Person Age: 25\n"
     ]
    }
   ],
   "source": [
    "class Person {\n",
    "    private String name;\n",
    "    private int age;\n",
    "\n",
    "    public Person(String name, int age) {\n",
    "        this.name = name;\n",
    "        this.age = age;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public String toString() { // We override the toString method here\n",
    "        return \"Person Name: \" + name + \"\\nPerson Age: \" + age; // We then add our own custom string representation\n",
    "    }\n",
    "}\n",
    "\n",
    "public class ToStringOverride {\n",
    "    public static void main(String[] args) {\n",
    "        Person person = new Person(\"Alice\", 25);\n",
    "\n",
    "        // When you print the person object, it calls the overridden toString method we made\n",
    "        System.out.println(person);\n",
    "    }\n",
    "}\n",
    "ToStringOverride.main(null)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we want to compare 2 people by using `boolean equals(Object other)` and determine if they are the same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Person 1 equals Person 2: false\n"
     ]
    }
   ],
   "source": [
    "class Person {\n",
    "    private String name;\n",
    "    private int age;\n",
    "\n",
    "    public Person(String name, int age) {\n",
    "        this.name = name;\n",
    "        this.age = age;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public String toString() {\n",
    "        return \"Person Name: \" + name + \"\\nPerson Age: \" + age;\n",
    "    }\n",
    "}\n",
    "\n",
    "public class EqualsNoOverride {\n",
    "    public static void main(String[] args) {\n",
    "        Person person1 = new Person(\"Alice\", 25);\n",
    "        Person person2 = new Person(\"Bryce\", 25);\n",
    "\n",
    "        System.out.println(\"Person 1 Age equals Person 2 Age: \" + person1.equals(person2)); // use the equals method to compare the two people\n",
    "    }\n",
    "}\n",
    "EqualsNoOverride.main(null)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "False is returned when you use the `boolean equals(Object other)` because the parameters is of Type Object superclass is unable to detect them since the Object class saves them under two different memory addresses and to fix this, we have to make an override method for this.\n",
    "\n",
    "To do this, we use `instanceof` and casting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "vscode": {
     "languageId": "java"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Person 1 Age equals Person 2 Age: true\n"
     ]
    }
   ],
   "source": [
    "class Person {\n",
    "    private String name;\n",
    "    private int age;\n",
    "\n",
    "    public Person(String name, int age) {\n",
    "        this.name = name;\n",
    "        this.age = age;\n",
    "    }\n",
    "\n",
    "    @Override // We override the equals method\n",
    "    public boolean equals(Object other) {\n",
    "        if (!(other instanceof Person)) // Using instanceof, we are making sure that the we compare objects of the same class\n",
    "            return false;\n",
    "        Person that = (Person) other; // Here we perform casting to make sure that other is converted to Person\n",
    "        return this.age == that.age;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public String toString() {\n",
    "        return \"Person Name: \" + name + \"\\nPerson Age: \" + age;\n",
    "    }\n",
    "}\n",
    "\n",
    "public class EqualsOverride {\n",
    "    public static void main(String[] args) {\n",
    "        Person person1 = new Person(\"Alice\", 25);\n",
    "        Person person2 = new Person(\"Bryce\", 25);\n",
    "\n",
    "        System.out.println(\"Person 1 Age equals Person 2 Age: \" + person1.equals(person2));\n",
    "    }\n",
    "}\n",
    "EqualsOverride.main(null)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hacks\n",
    "\n",
    "Create a superclass with at least 2 subclasses based on your own topic.\n",
    "\n",
    "- Create a DrawIO diagram for your structure and label them with superclasses and subclasses\n",
    "- Create a superclass on your own topic\n",
    "- Create at least two subclasses\n",
    "- Each class must create at least two methods, one private and public variable, and examples of local, static, instance, and parameter variables\n",
    "- Override at least one method\n",
    "- Use the `super` keyword at least once"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "11.0.20+8-post-Ubuntu-1ubuntu120.04"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}