Inheritance In object-oriented programming, a mechanism called inheritance is used to design two or more entities that are different but share many common features. First we define a class that contains the common features of the entities. Then we define classes as an extension of the common class The common class is called the superclass and all classes that inherit from it subclasses. The superclass is an ancestor of the descendant subclass. We did not distinguish the savings and checking accounts in designing the Account class. If these two types of accounts are treated in the same way, then only one class to model them is enough. However, if we have to keep track of different information or process the data differently for the savings and checking accounts, using one class to model both is not appropriate. Defining two distinct classes, for example, Savings Account and Checking Account, is not appropriate because we would end up duplicating methods. For example, if the way we deduct the amount of a withdrawal from a savings account and the check amount from a checking account is the same, then we will have to define identical methods for both classes, duplicating the same code. We avoid the problems by using inheritance.

Sample Inheritance Hierarchy Account Savings Checking Interest Bearing ATM Checking SuperSaver Regular Student

Inheritance Subclasses inherit from their superclass Everything that's in the superclass is inherited by the subclass. Objects created from the subclass consist of the inherited components and any new components defined in the subclass If a subclass defined something that is in the superclass, the subclass elements override the superclass elements Constructors (and other things – see later) of the superclass can be called using super() We did not distinguish the savings and checking accounts in designing the Account class. If these two types of accounts are treated in the same way, then only one class to model them is enough. However, if we have to keep track of different information or process the data differently for the savings and checking accounts, using one class to model both is not appropriate. Defining two distinct classes, for example, Savings Account and Checking Account, is not appropriate because we would end up duplicating methods. For example, if the way we deduct the amount of a withdrawal from a savings account and the check amount from a checking account is the same, then we will have to define identical methods for both classes, duplicating the same code. We avoid the problems by using inheritance.

Example Program Ding … out to reality … ColdMedicine.java, ColdPills.java, ColdSyrup.java, UseColdMedicine.java

Inheritance and Member Accessibility Superclass Subclass Which members of a superclass are accessible from its subclasses? There is a third visibility modifier called protected. public private protected

Access from the Outside Only the public elements are accessible from the outside objects. mySub Subclass Superclass mySuper Client test

Access from the Subclass Methods Subclass methods can access public and protected superclass methods and data. Subclass methods cannot access private superclass methods and data. mySub Subclass Superclass accessible inaccessible

Accessing Superclass Data and Methods Constructors of the superclass can be called using super() Public and protected components of the superclass that have been overridden in a subclass can be accessed using super.<the component> Note: Make sure that the superclass has a constructor that takes no arguments. If the superclass does not have one, then the call super( ) from the subclass becomes invalid. To call a constructor that takes one or more arguments, you must explicitly call it from a subclass constructor, such as public Truck( int weightLimit, String vin ) { super( vin ); cargoWeightLimit = weightLimit; }

Example Program Dong … out to reality … Student.java, GraduateStudent.java, UndergraduateStudent.java, UseStudent1.java Dung … out to reality … HouseOccupant.java, Human.java, Pet.java, UseHouseOccupant.java

Polymorphism Polymorphism allows a variable to refer to objects from different (but related by inheritance) classes. References to data or methods are correctly resolved according to the object’s class. Requires that the superclass have the inherited data or method Student student; student = new GraduateStudent(); student.computeGrade( ); This will call the method of GraduateStudent Student student; student = new UndergraduateStudent(); student.computeGrade( ); This will call the method of UndergraduateStudent

Creating the roster Array roster is an array of Student objects. Student roster[ ] = new Student[40]; roster[0] = new GraduateStudent( ); roster[1] = new UndergraduateStudent( ); roster[2] = new UndergraduateStudent( ); roster[3] = new GraduateStudent( ); Create instances of the subclasses of Student. 1 2 3 4 36 37 38 39 roster Graduate- Student Under- graduate- Student

Example Programs Dung … out to reality … Student.java, GraduateStudent.java, UndergraduateStudent.java, UseStudent2.java

Abstract Classes Often we want to place elements common to all subclasses in their superclass. But we do not want any instances to be created from the superclass. In such case, we designate the superclass as an abstract class. This is also a way to enforce existence of methods in subclasses.

Abstract Methods It is common for an abstract class to include an abstract method that must be implemented by the descendant classes. If a class includes an abstract method, then it is considered as an abstract class and must have the abstract modifier in the class declaration.

Sample Abstract Class abstract class Student { . . . abstract public void computeGrade( ); } Reserved word abstract in the class declaration. Abstract method has no method body. class GraduateStudent extends Student { . . . public void computeGrade( ) //method body comes here } Abstract method is must be fully implemented in the descendant class.

Example Programs Deng … out to reality … H2O.java, Ice.java, Water.java, Steam.java, UseH2O.java