Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Inheritance v2.2 225 City Avenue, Suite 106 Bala Cynwyd, PA 19004 610.206.0101, phone 610.206.0102, fax www.learnquest.com Learning Objectives Overview of Inheritance The super keyword Inheritance Models The “Is-A” Relationship The extends keyword Abstract Classes Extension, Overriding and Overloading Casting 2 Chapter Overview Now that we’ve gotten a better sense of Java programming we’ll return to the idea of inheritance and look at it more closely After reviewing the basic ideas, we’ll introduce three important new ones: - overriding - overloading - the super keyword We’ll also look at re-factoring, take another look at abstract classes and introduce casting 3 Inheritance Overview An inheritance relationship is one of the fundamental mechanisms for code reuse in object-oriented programming Inheritance allows classes to be derived from an existing class The class which inherits is called: the subclass, the derived class or the child class The class which is inherited from is called: the superclass, the base class or the parent class A subclass inherits variables and methods from its superclass and all of its ancestors unless those elements are scoped as private or package 4 Inheritance in Java The general form of subclass: class subclassname extends superclassname { variables declaration ; methods declaration ; } The keyword extends signifies that the properties of the superclassname are extended to the subclassname 6 java.lang.Object If a class does NOT include the extends keyword, it is assumed to extend java.lang.Object All Java classes ultimately inherit from Object This means that all classes in Java share the methods found in Object. Take a moment to examine some of these methods in the online documentation. 7 Inheritance in Java (con’t) Multilevel Inheritance Multilevel Inheritance allows several levels of superclass In Java a class can only extend from one other class A B – A is superclass of B – B is superclass of C – This works in Java: B and C each have only one superclass. C 9 Inheritance in Java (con’t) Hierarchical Inheritance Hierarchical Inheritance has one superclass and many subclasses A – A is superclass – B and C are subclasses of A B C – This works in Java. 10 An Example Superclass public class Car { private int speed; // The default Constructor public class Car() {} // A constructor that sets speed public Car(int s) {this.setSpeed(s);} public int getSpeed() { return speed;} public void setSpeed(int s){speed = s;} } 11 An Example Subclass public class StationWagon extends Car { private int cargo_weight; public void setCargoWeight(int w) { cargo_weight = w; } public int getCargoWeight() { return cargo_weight; } } 12 Implications of extends The subclass becomes a specialization of the existing class through one or more of the following three mechanisms: The subclass adds new data members and/or methods The subclass “overloads” existing methods The subclass “overrides” existing data members and methods Overloading and overriding are covered in the next set of slides 13 Overloading Existing Methods An overloaded method has the same name as another method in the same class (or in a parent class) but has a different parameter list An overloaded method provides specialized functionality by accepting a different parameter list 14 Overloading Example In our SportsCar class we want the option of setting the speed more precisely via a double public class SportsCar extends Car { double preciseSpeed; //overloading setSpeed(int) from Car public void setSpeed(double s) { preciseSpeed = s; } } 15 Overriding Existing Methods An overridden method is a method, in a subclass, that has exactly the same signature as a method in a parent class You can overload methods in the same class but you can only override methods in a subclass 16 Overriding Example Our StationWagons are not allowed to go more than 50 miles per hour. We enforce this via an overridden setSpeed method public class StationWagon extends Car { //overriding setSpeed(int) from Car public void setSpeed(int s) { if(s >50) s = 50; speed = s; //what’s wrong here???? } } 17 The super Keyword When you override a method, the code in the parent’s class method is no longer available to the subclass If you want to access the parent’s code you can use the super keyword. To call setSpeed in Car for StationWagon you would do this: public class StationWagon extends Car { public void setSpeed(int s) { if(s > 50) s = 50; super.setSpeed(s); } } 18 Overriding Existing Data It is also possible to override data members This is not considered good design practice. You are subverting rather than specializing the original superclass Inheritance should not be used to wipe out features that you don’t want in a subclass 19 Constructors and Inheritance A constructor may include the super() statement to call the constructor of the superclass from which it inherits In a constructor, super can only be the first statement in the constructor’s code block (comments excepted!). This is okay… public StationWagon() { …this is not. public StationWagon() { System.out.println(“Okay”); System.out.println(“Okay”); super(); } super(); } 20 Constructors and Inheritance (con’t) To call a specific constructor in the superclass, the super() statement should be provided with parameters that match that constructor: public class StationWagon extends Car { //All StationWagons start of going 40. public StationWagon() { super(40); System.out.println(“Okay”); } } 21 The protected Modifier If an attribute or method is declared as protected then its visible to all subclasses This visibility also extends across package boundaries! 22 The “Is A” Relationship Inheritance should typically be used to model an “is – a” relationship between Superclass and Subclass StationWagon is a Car Penguin is a Bird Factory is a Workplace While “is a” is a matter for philosophical debate on occasion it is a good metric for building a well engineered inheritance relationship 23 When “Is-A” Breaks Down public class Bird { public void fly (int altitude) { /* code here */} } public class Penguin extends Bird { public void fly (int altitude) { /* ??? */} } A penguin clearly “is-a” bird but not all penguins can fly! 24 What NOT To Do – Version 1 One (bad) solution is to let Penguins fly() but create a fly method that doesn’t do anything: public class Penguin extends Bird { public void fly (int altitude) {} } If someone tries to make a penguin “fly” they are probably expecting it to work – somehow. But nothing will happen: myPenguin.fly (1000); // nothing happens mySwallow.fly (1000); // fly to 1000 feet 25 What NOT To Do – Version 2 Another (bad) solution is to give Penguins a fly() method which actually means something else. Perhaps fly() for a penguin should be swim! public class Penguin extends Bird { public void fly (int alt){ /* swim code here */ } } This makes the purpose of the code difficult to understand – objects may respond to methods in unexpected, inappropriate ways! myPenguin.fly (1000); // swim 1000 feet in depth mySwallow.fly (1000); // fly 1000 feet in height 26 Solution : Refactor the Relationship Bird fly() FlyingBird Swallow FlightlessBird Penguin Refactor the hierarchy into Bird, FlightlessBird and FlyingBird! Then build your specific class abstractions! 27 Abstract Classes Revisited To close out this chapter, we’ll revisit abstract classes Although we’ve already covered this, abstract classes bear a rather subtle relationship to our next topic: Interfaces A review now will help you better understand the material in the next chapter. For our review we will consider items (Books, VHS tapes and DVDs) being lent from a library 28 Abstract Classes An Abstract class is a class that may not be instantiated An abstract class may include: Attributes Abstract Methods – these methods have no code blocks Methods – these methods have code blocks 29 Abstract Class Example public abstract class Car { protected int speed; protected boolean engineState; /* Other attributes omitted to save space */ // We’ve decided to not provide a // default way of setting speed. public abstract void setSpeed(); public boolean getEngineState () { return engineState; } /* Other methods omitted to save space. */ } 30 Concrete Class Example public class SportsCar extends Car { int horse_power; public int setSpeed(int new_speed) { if(new_speed > horse_power*1.7) new_speed = horse_power*1.7; this.speed = new_speed; } /* Other methods omitted to save space. */ } 31 Abstract Class Syntax public abstract class Car { … } A class that is abstract must be declared using the keyword abstract This indicates that it may NOT be instantiated Car x = new Car(); This will cause a compilation error 32 Abstract Method Syntax public abstract void setSpeed(int new_speed); The keyword abstract in a method signature indicates that the method must be implemented by an extending (or “concrete”) class If a class does not provide an implementation for an abstract method it inherits it must also be declared abstract – or the code will not compile Note: it is possible for an abstract class to have no abstract methods! 33 Building a “Concrete” Class A Concrete class extends an abstract class and provides an implementation for all inherited abstract methods: public class SportsCar extends Car { int horse_power; public int setSpeed(int new_speed) { if(new_speed > horse_power*1.7) new_speed = horse_power*1.7; this.speed = new_speed; } public int getHorsePower(){ return horse_power;} /* Other methods omitted to save space. */ } 34 Key Design Implications An abstract class can provide general functionality and data fundamental to all concrete subclasses through implemented methods; however such functionality may not make sense on its own Abstract methods collectively specify a list of methods that all concrete subclasses must implement 35 Using Abstract References It is possible to assign concrete objects to abstract references Car mySportsCar = new SportsCar(); However, in this example, mySportsCar only has access to the attributes and methods defined in Car. Methods defined in SportsCar are NOT available to it: boolean x = mySportsCar.getEngineState(); // no problem this is a method in Car int hp = mySportsCar.getHorsePower(); /* this will not compile – Car doesn’t have a definition for getHorsePower() – it’s a SportsCar method! */ 36 Using Abstract References (con’t) This enables us to write what is often called polymorphic code, the ability for unrelated classes to respond to common messages - we’ll address this is detail later BUT this technique allows us to group objects that are similar as long as we work only with the attributes and methods they have in common See the example on the next slide 37 Using Abstract References (con’t) The method below will accept ANY class that extends Car. This includes SportsCar, Cargo, SUV and StationWagon All classes that extend Car are required to have a setSpeed() method. So we know that the line aCar.setSpeed(55) will work public void travelAtSpeedLimit (Car aCar) { aCar.setSpeed(55); } 38 Casting: An Introduction In Java, classes are arranged in a strict hierarchy. Every class – except class Object- has one superclass and can have any number of subclasses Our SUV class for example inherits from Cargo, which in turn inherits from Car which inherits from Object Object Car Cargo SUV Java guarantees that: SUV will have all the attributes and methods of Cargo, Car and Object Cargo will have all the attributes and methods of Car and Object but not SUV Car will have all the attributes and methods of Object but not Cargo or SUV 39 Upcasting Because of these guarantees Java allows us to regard a class as any one of the classes from which it inherits So we can choose to regard an SUV as a Cargo object, a Car object or even just a plain old Object object When we do this we lose access to the attributes and methods in the subclass Regarding a class as one of its superclasses is called “upcasting” 40 Upcasting Syntax We’ve already seen one way to upcast: Car myCar = new SportsCar(); But what if we already have a SportsCar and want to create a Car reference to it? Well, we’d do this: SportsCar mySportsCar = new SportsCar(); Car myCar = (Car)mySportsCar; As we continue through this class we’ll see a variety of ways in which this is useful 41 Downcasting Downcasting lets us take a class which has been upcast to a more general class and switch back to regarding it as a more specific class For example: // Create a SportsCar and regard it as a Car Car myCar = new SportsCar(); // Now create a new reference to regard myCar // as a SportsCar SportsCar mySportsCar = (SportsCar)myCar; 42 Issues with Casting In many cases Java can check at compile time to ensure that you’ve got the correct type But this is not always so. As we will see in the chapter on Collections, Java will not always be able to determine that you’ve specified the right types when it compiles your code So, if you make a mistake you may encounter a run time error 43 Any Questions? After discussing this chapter with your instructor please complete the exercises in Lab 5 These exercises will focus on abstract classes and casting 44