Please enable JavaScript.

Coggle requires JavaScript to display documents.

Chapter 5. CLASS DESIGN (Introducing Class Inheritance (Defining…

- - - - Accessed only by a subclass or class within the same package
      - A Java file can have many classes but at most one public class -> Define many classes within the same Java file
  - - - No constructor is declared -> compiler will automatically insert a default no-argument constructor.
    - - Either a call to another constructor within the class, using this().
      - Or a call to a constructor in the direct parent class, using super().
  - - - use any public or protected member of parent class
      - if same package, use any default member in the parent class
      - never access a private member of the parent class
    - - super(): parent constructor + only be used in the first line of a constructor of a child class
      - super: reference a member defined in a parent class
  - - - Same signature (method name + input parameter)
      - At least as accessible or more accessible
      - May NOT throw a checked exception that is new or broader than the class of any exception thrown in the parent class method
      - covariant return types
    - - Same or modified signature
      - The method in the child class is separate, independent method, unrelated to the parent version's method.
    - - Same as Overriding a Method
      - The method defined in the child class must be marked as static if it is marked as static in the parent class.
    - - Overriding: Replace the parent method in a calls defined in both the parent and child
      - Hiding: Replace parent methods in the calls defined in the child class.
    - - Cannot be overridden
  - - - Same name as a variable in a parent class
      - 2 copies: one for parent, one for child
- - - - first non-abstract subclass that extends an abstract class
      - required to implement all inherited abstract method
- - - - First concrete class MUST provide an implementation of all of the inherited abstract method
      - Interface extends another interface + Abstract class implements an interface -> inherit all of the abstract methods
    - - The signature for the two interface methods are compatible => NO PROBLEM
      - Same method name + Different input parameter => NO PROBLEM
      - Same name, input parameter + Different return types => NO COMPILE
  - - - ONLY be declared within an interface
      - MUST be marked with the default keyword
      - MUST provide a method body
      - NOT assumed to be static, final, or abstract
      - ASSUMED to be public
    - - If a class implements 2 interfaces that have default methods with the same name and signature, the compiler will throw an error.
      - The subclass MUST overrides the duplicate default methods