Java Class Hierarchies

Class Hierarchies

• Class hierarchies can be utilized to handle designs with similar classes.
• Java hierarchies allow classes to inherit from one another, facilitating the creation of a parent class containing common methods and fields of child classes.
• Using hierarchies avoids the need to rewrite code classes.
• Standalone classes in Java, where each instance represents the same type of object
• Using one class to play multiple roles can be messy
• Making separate classes may result in re-writing code
• Parent classes enable reuse of common methods and fields by child classes.
• This promotes easier building and maintenance of code.

Practitioner Example

• Consider a scenario with doctors and pharmacists, who share common attributes like names and birthdates but also have distinct characteristics.
• A general class, Practitioner, can be introduced.
• Doctors and Pharmacists, are subclasses of Practitioner.
• Practitioner is a generalization, while doctors and pharmacists are specializations.
• This design results in three classes: Practitioner (superclass), Doctor, and Pharmacist (subclasses).
• A Doctor object is an instance of Practitioner, but not a Pharmacist object.
• Creating a Practitioner object means that it is neither a Doctor nor Pharmacist.
• The Practitioner class contains methods and fields that are common to Doctor and Pharmacist subclasses.
• Doctor class includes fields and methods specific to doctors, inheriting fields and methods from Practitioner.
• Pharmacist class includes fields and methods specific to pharmacists, inheriting fields and methods from Practitioner.

UML Class Diagram

• UML shows the variables of Practitioner as firstName, lastName, and gender.
• Doctor contains the variable specialty, while Pharmacist contains the variable location.

Practitioner Class

• The Practitioner class implementation has private variables for firstName, lastName, and gender.
• Includes methods like getName() and toString().
• The java code to show the how the practitioner class is defined using public class

Creating Practitioner Objects

• Code is written to create objects using both the no-argument constructor and the constructor with arguments (name, gender etc).
• The no-argument constructor will print "unknown unknown unknown"
• The constructor taking arguments would return values set in creation e.g. "Tom Smith Male"

Pharmacist Class

• The extends keyword specifies the superclass.
• The no-arg constructor automatically calls the superclass no-arg constructor.
• Explicitly call the superclass' constructor: super(firstName, lastName, gender);
• A field (location) exists in Pharmacist but not in its superclass. New getters and setters are needed for this value.
• Include super if you want to inherit the values from the other class
• The Pharmacist class contains a no-argument constructor that sets the location to "unknown" by default.

Doctor Class

• Extends the Practitioner Class
• Contains the variable 'specialty'
• Includes Constructors, getters, and setters
• The Doctor class includes a no-argument constructor that sets the specialty to "unknown".

Practitioners and Polymorphism

• Classes can be put together in one ArrayList of the type Practitioner.
• Practitioners, Doctors, and Pharmacists can be stored this way, utilizing a single enhanced for loop.
• The instanceof method determines the type of a given object.
• The getFirstName() is used for all three objects, as it is defined for Practitioners and inherited by the other classes.

Overriding Methods

• If an object is a doctor, the JVM runs getName() for Doctor, otherwise, it runs the getName() method defined for Practitioner.
• Different object types results different behaviors.
• The method to be used is determined at runtime. The JVM polymorphically selects behavior.
• Polymorphism is the ability of something to assume different forms.
• A Practitioner may take the form of Practitioner, Doctor, or Pharmacist.

Super prefix

• Methods in a subclass automatically override methods in a superclass
• A subclass can call its superclass' method by super.getName();
• Be careful with recursion by calling getName, ensure you are referencing the correct class

Protected Keyword

• Besides public and private, a third protection option is protected.
• protected methods/fields are only granted access within its class and subclasses, or classes within the same package.
• It is similar to private, but allows access to the class' ''family''.
• If you set firstName and lastName to protected in Practitioner, the subclasses no longer need to use getter methods to access these fields

Abstract Classes and Methods

• An abstract class cannot be instantiated.
• Make a Practitioner class abstract to prevent it from ever accidentally being instantiated.
• An abstract method has no implementation.
• If each subclass needs to implement a method differently, it may be designated as being abstract. Use public abstract double area();
• Abstract method can only be in an abstract class.
• An abstract class doesn't need to have any abstract methods.

Shapes Example

• Shape should be abstract and cannot be instantiated.
• Shape should implement an abstract area method.
• Square and Circle implement the logic separately
• Square and Circle are not abstract, and can be instantiated, and are concrete subclasses.

Summary

• All Java files are subclasses of Object with default definitions
• Arrows symbolize inheritance
• Object instantiated is instance of the subclass and superclass
• The binary operator instanceof determines object type
• If a subclass defines a method already defined in its superclass, the method has been overridden
• The JVM determines at runtime which method to run
• ie polymorphically
• Abstract classes cannot be instantiated and do not contain implementations
• Implementation is left to the subclass. Subclasses can only have 1 superclass
• Enums are not arranged in hierarchies