1) Two classes are "unrelated" if they are not connected by inheritance (except, of course, through the Object class). (T) 2) A method call is "polymorphic" if you write it different ways depending on what object you're calling it on. (F) 3) If a data member is "protected", it can be accessed from within its class and within any subclass. (T) 4) A superclass may access any non-private data member of its subclass. (F) 5) If you do not define a constructor in your class, you get a default version that contains only a call to super(). (T) 6) A subclass inherits all of the non-private superclass data and methods. (T) 7) A subclass can override a superclass method by writing another method with the same name and different parameters. (F) 8) A subclass can overload either its own method or a superclass method. (T) 9) If a method has been overridden, it can no longer be accessed from the subclass. (F) 10) If a superclass is abstract, it is not instantiable. (T) 11) If you make a subclass of an abstract class, the subclass is always instantiable. (F) 12) An abstract method has the keyword "abstract" in the header and has no body. (T) 13) An interface is another way to share code between classes. (F) 14) If you declare that a class "implements" an interface, then there will be methods that you are required to define in that class. (T) 15) An overriding method must have the same header as the original, except that the visibility is allowed to be greater. (T) 16) If a subclass method has the same name as a superclass method, it always qualifies as either overriding or overloading. (F) 17) Due to dynamic binding, Java only knows at runtime whether a reference contains a superclass or a subclass object, which is why you sometimes need to use the "instanceof" operator to check which it is. (T) 18) A class can implement as many interfaces and extend as many superclasses as you want. (F)