Chapter 3 - Types and Interfaces

Question 1

interface

Answer 1

• contains abstract methods which don’t have an implementation
• use implements keyword to tie a class to an interface; this class is a subtype of the interface and must implement the abstract methods

Question 2

Comparable

Answer 2

• uses o1.compareTo(o2)
• class that implements this method needs to use keyword “implements Comparable”; only one way to compare using this method
• returns: 0 if equal; negative if o1 < o2; positive if o1 > o2
• use Collections.sort(list) to then sort the objects based on implemented compare method

Question 3

Comparator

Answer 3

• separate class from the element type we’re comparing
• create multiple separator classes that implement Comparator that each have their own method to compare to objects (implement method compare(o1, o2))
• call Collections.sort(List<T> list, Comparator)</T>
• use static factory methods to define Comparator classes

Question 4

static factory method for Comparator createByRankComparator

Answer 4

pg. 63 textbook

Question 5

SWITCH STATEMENT antipattern

Answer 5

relying on a global variable that stores the required strategy and switching strategies based on this flag

Question 6

Iterable interface

Answer 6

• implement Iterator<T> iterator()</T>
• for lists (eg. aCards) -> return aCards.iterator(); suffices

Question 7

ITERATOR design pattern

Answer 7

provides a way to access the elements encapsulated within another object without exposing the underlying representation

Question 8

STRATEGY design pattern

Answer 8

• define a family of algorithms, encapsulate each one, and make them interchangeable (have an interface that is implemented by multiple classes that each have their own strategy)

Question 9

dependency injection technique

Answer 9

• inject the dependency into the client class (usually using a constructor)