This OOP Online Test
Separates Good From Bad Hires

Your team has started to write software for managing a vehicle storehouse using a programming language that supports OOP. This is the class hierarchy you plan to use:

class Vehicle
class Car inherits Vehicle
class Bicycle inherits Vehicle
class MountainBike inherits Bicycle
class Downhill inherits MountainBike

Objects of which type can be assigned to a variable of type Bicycle?

In a language that supports the OOP paradigm, we have the following code that serializes the content of a shopping cart to JSON format:

class ShoppingCart
  private content : Dictionary<Int, String> 

  public function serialize() : String
    return new JsonSerializer().serialize(content.clone())
  end function
end class

class JsonSerializer  
  public function serialize(value : Dictionary<Int, String>) : String
    // Code that serializes dictionary to JSON format and returns it as string
  end function
end class

A client wants to allow loosely coupled plugins to be able to serialize the shopping cart content to their own formats (e.g., XML). Select lines of code that, together, would extend the code above to allow this.

A word processor uses the following code for defining font format:

class FontFormat inherits Object
  private fontName : String
  private fontSize : Int

  public constructor(name : String, size : Int)
    fontName = name
    fontSize = size
  end constructor

  public function getFontName() : String
    return fontName
  end function

  public function getFontSize() : Int
    return fontSize
  end function

  override public function equals(obj : Object) : Bool
    if (!(obj instanceof FontFormat))
      return false
    end if
    
    FontFormat f = (FontFormat)obj
    return f.getFontName() == fontName && f.getFontSize() == fontSize
  end function

  override public function getHashCode() : Int
    return fontName.getHashCode() ^ fontSize.getHashCode()
  end function
end class

Analysis shows that even the largest documents use fewer than a hundred different combinations of font name and size. The same analysis shows that the application sometimes uses thousands of FontFormat objects, most of which share the same font name and size.

(Fill in the blank with the software design pattern that solves the issue.)

The ____________ software design pattern can be used to minimize the memory footprint by sharing FontFormat objects.