Table of Contents

Fundamental Concepts

Abstraction

• Hide non-essential data and implementation details from the user of a function/code block.
• How to implement:
  • Use interfaces or abstract classes.
    • Ex. pidgeon.fly() where fly() is part of an interface or abstract class. The method’s implementation is not visible to the user, but it’s clear what it will do.
  • Separate application logic into layers, e.g. Controller, Service, DAO, Repository

Inheritance

• How to implement:
  1. Have a base class with predefined properties, e.g. Bird
     1. Can use a Class, Abstract Class, or Interface as the Base class
  2. Have a subclass that inherits the base class and uses the same properties, e.g. Pidgeon extends Bird
  3. Add differences in implementation unique to Pidgeon where they’re needed.
     1. Overridden methods, additional Fields, etc.
• Benefits
  • Lets you reuse code without copying it over multiple times. This way if the parent class changes, you don’t have to recopy everything to its subclasses.
  • Lets you create a base/default implementation for methods, then override them only when necessary.
• Limitation: Multiple Inheritance
  • Having 1 Subclass inherit from multiple Parent classes.
  • Not supported in Java.
  • Can work around with Interfaces. If you want to inherit fields/methods from multiple parents, you need to make the parent classes into Interfaces.
• Abstract Class vs Interface
  • Tradeoff: Customizability (Abstract Class) vs Multiple Inheritance (Interfaces)
  • Both provide Abstract Methods: methods that have no body, and must be implemented by the subclass inheriting them.
  • Interfaces support Multiple Implementation. Abstract Classes (and regular Classes) don’t support Multiple Inheritance.
    • Can have one subclass implement multiple Interfaces.
  • Interfaces are less customizable.
    • No field variables.
    • All methods are abstract. No default implementation. Must be overridden in subclass.
    • All methods are public.
  • Abstract classes are more customizable (halfway between full class and interface).
    • Can add field variables. Field variables can either be abstract or have a default value.
    • Methods can either be abstract or have a default implementation.
    • Methods can be public, private, or protected

Encapsulation

• Only give the user of a class/function/field as much access as they need to it, and no more than that.
  • Use access modifiers for classes, fields, and methods to only expose essential information about a class.
• How to implement:
  • Make class Fields private.
  • Add public getter/setter methods for accessing variables.
  • Make internal helper methods private.
  • Use the smallest scope access modifiers necessary for each class, field, and method.
    • public, private, default (package-protected), protected
• Benefits
  • Security: Users cant see sensitive information.
  • Visibility: Only expose information the user needs to see/use about the class. Makes writing code easier.
  • Easier to control class variables:
    • Can’t access class variables directly, have to use getter/setter methods
  • Can make certain Fields read-only or write-only by omitting their Getters/Setters.

Polymorphism

• What is it?

  • Give a class multiple different ways to do something, depending on the use case.
  • Giving multiple ways to use a method.

• Benefits

  • Code readability/elegance
  • Lets you reuse methods and fields from an existing base class (animals) for many related classes (pigs, cows, etc.)

• Ways to implement polymorphism

  1. Override the inherited methods in a subclass (runtime Polymorphism).
  2. Overload a Class’s methods to use them in different ways depending on input parameters (compile-time Polymorphism)

• Example

  // Parent Class
  class Animal {
  	// Default implementation
    public void animalSound() {
      System.out.println("The animal makes a sound");
    }
  }
  
  class Pig extends Animal {
  	// Overriding Animal.animalSound()
    @Override
    public void animalSound() {
      System.out.println("The pig says: wee wee");
    }
  }
  
  class MyMainClass {
    public static void main(String[] args) {
      Animal myAnimal = new Animal();  // Create a Animal object
      Animal myPig = new Pig();  // Create a Pig object
  
      myAnimal.animalSound();	// Base method
      myPig.animalSound();	// Unique implementation method for related class
      myDog.animalSound();
    }
  }