Inheritance, Subtyping and Polymorphic variables. Inheritance.

Transcription

1 Inheritance, Subtyping and Polymorphic variables. Inheritance. We saw before that it is not good to repeat the same code in several methods of a class. Now we can extend this idea, saying that it is a signal of a bad design, when you repeat the same fields and methods in different classes. How we deal with this? We consider inheritance. We use inheritance to 1) Add functionality to classes by extending them. 2) Avoid duplication of code. When we should use inheritance? The main idea is that when you have two or more classes that have some common fields and/or methods, instead of repeating the fields or the methods, you move the common things into a superclass. Then you extend the original classes using this superclass. The modified original classes inherit the fields and values of the superclass. You could have several classes that have the same superclass, and a subclass on this environment can be the superclass for another set of classes. Example: We had a BankAccount class that was generic. If we want to use a CheckingAccount (our original BankAccount) and a CheckingAccount, some of the fields would be the same, like every account needs to have a Customer name, and account number, a balance, etc.. Also you can deposit money on each account, or withdraw from it, among the common methods. The BankAccount is a superclass, and the SavingsAccount and CheckingAccount are classes that inherit the fields and methods of the BankAccount. Then they have special methods for their own fields, and some specific methods for the being a subclass (like clearcheck() in the CheckingAccount). So, look at the following diagram, where the BankAccount has the common things, and the other two have the specific fields and/or methods corresponding to each particular nature. This type of diagram will help us to determine which are the fields that we should place in the superclass, and which ones in the subclasses. The same can be said for the methods.

2 The BankAccount is a superclass, and the SavingsAccount and CheckingAccount are classes that inherit the fields and methods of the BankAccount. Then they have special methods for their own fields, and some specific methods for the being a subclass (like clearcheck() in the CheckingAccount) In order to be concise given the main ideas, we are not going to display the code, only the interfaces of the superclass (the code can be seen in the examples in the syllabus) import java.util.*; public class BankAccount { // Fields of this class private static int m_nnextaccountnumber; private double m_dbalance; private String customer; private int custaccountnumber;

3 // Constructors public BankAccount (String customer, double dinitialdeposit) public BankAccount(String customer) // Mutator Methods public void newdeposit(double amount) public void newwithdrawal(double withdraw) public static void putinitialaccountnumber(int newnumber) public void putaccountnumber(int newnumber) // Accessor Methods public double getbalance() public int getaccountnumber() public String getcustomer() public static int getnextaccountnumber() } // End the class definition of BankAccount. We are now going to define the subclasses of the superclass. Two points should be remarked 1) How we define the subclasses using the new keyword extends + the name of the superclass, when we give its name. Example: public class CheckingAccount extends BankAccount 2) How we implement the constructors in the subclasses, to populate the fields in the superclass. Example: public CheckingAccount(String customer, double dinitialdeposit)

4 { super(customer, dinitialdeposit); } You fill up the fields of the superclass first using the new method super(), and then the fields of the subclass should be filled up. This means that the super call must be the first statement in the subclass constructor. Therefore subclass constructors should always contain a 'super' call first. If none is written, the compiler inserts one (without parameters). This approach only works only, if the superclass has a constructor without parameters For the code of both subclasses check the examples in the syllabus.. Inheritance and access rights: Anything public in the superclass and subclasses can be accessed by objects of other classes. Anything private can only be accessed by objects of the class. Since the subclass extends the superclass it could be thought that the subclass could access the private elements of the superclass. This is not the case. If a subclass needs to access and/or change a field in the superclass, the superclass needs to have a accessor and/or mutator method to allow the subclass to perform its duty. Example: The method clearcheck(double amount) in the subclass CheckingAccount. public void clearcheck(double amount) { // We ask for the balance to the superclass double balancenow = getbalance(); if (balancenow < amount) System.out.println("There are not sufficent money to cover this check"); else newwithdrawal(amount); // Ask the superclass to withdraw the amount } // End of clearcheck

5 Inheritance (so far) helps with: Avoiding code duplication Code reuse Easier maintenance Extendibility Subtyping Java has the basic simple types that you can find in any other language, like int, double, char. They have their own operations, but they are not objects. On the other hand, when we define a class, we are defining a new a type, Therefore, by defining a new subclass, we are defining a subtype. What does it mean? When we assigned an object to a variable, both must be of the same type so far-, but because of the extension of classes, we can also extend the assignment procedure: A variable can hold any object of its declared type, or of any subtype of its declared type. So if we declare the superclass Vehicle and the subclasses Car and Bicycle We can make the following assignments But we can t make the following ones: Car v1 = new Vehicle(); // Bad assignment Bicycle = new Vehicle(); // Bad assignment Note that passing parameters as arguments, in calls to methods, follows the same rules as the assignments. It should be noted that if we knew that class of Vehicle that we have, either a Car or a Bicycle, we could cast the object Vehicle so it becomes a Car (or Bicycle) object.

6 For instance, if v is a Vehicle, that we know to contain a Car, and c is a variable of the type Car, we could write the following assignment (or pass it as an argument) c = (Car) v; If you want to be sure, you can use the keyword instanceof if (myitem instanceof Car) Car mycar = (Car) myitem; else Bicycle mybike = (Bike) myitem; Polymorphic variables Variables holding objects are polymorphic variables. This means that the can hold objects of different types the declared type or any of its subtypes. They will behave differently according which object they hold. The Object class and wrapper classes Object is the only class on Java that does not have a superclass. All the other classes, even if we don t declare them as subclasses of the Object class, they are actually its subclasses. When dealing with the simple types, like int, double, char, etc.. we are dealing with something different that an object. If we don t n modify them, we cannot use them in instances where an object is required. For instance, a HashMap requires two objects, the key and the value. If the key is an int we couldn t create the HashMap. Java deals with this situation by the wrapper classes. Each simple type in Java has a corresponding wrapper class that represents the same type, but now it is a real object, You may check in the Java library the classes Integer, Character, Boolean, Double, Float, etc.. and their corresponding methods. Once the proper objects have been declared, the compiler automatically substitutes a simple type value by the corresponding object, or vice versa, when the context being used needs a substitution.