Lecture 131. Inheritance and Abstraction. Inheritance. Inheritance. Inheritance. Seminars. Seminars. Recall Player class (noughts and crosses)

Transcript

1 1 Lecture 131 Seminars Seminars for the final problem sheet begin Thursday at 5pm They contain some material which you have not yet covered just do what you can Starting Thursday week 9 the seminars will be in the lab and will troubleshoot coursework 2 Lecture 131 Seminars Seminars for the final problem sheet begin Thursday at 5pm They contain some material which you have not yet covered just do what you can Starting Thursday week 9 the seminars will be in the lab and will troubleshoot coursework 2 2 and Abstraction OOP has several ways in which classes can be made more powerful One of these is program composition classes containing instances of other classes e.g. MyGame class that contained instances of the Board and Player classes Two other techniques (which are covered in this course) are inheritance (this lecture) abstraction (the next lecture) Recall Player class (noughts and crosses) this.piece = piece; public char playingwith() return piece; public int chooserow() return (int)(math.random()*3); public int choosecolumn() return (int)(math.random()*3); 3 4 Recall Player class (noughts and crosses) Recall Player class (noughts and crosses) this.piece = piece; this.piece = piece; public char playingwith() return piece; public char playingwith() return piece; public int chooserow() return (int)(math.random()*3); public int chooserow() return (int)(math.random()*3); public int choosecolumn() return (int)(math.random()*3); public int choosecolumn() return (int)(math.random()*3); 5 6

2 7 Recall Player class (noughts and crosses) Recall Player class (noughts and crosses) this.piece = piece; this.piece = piece; public char playingwith() return piece; public char playingwith() return piece; public int chooserow() return (int)(math.random()*3); public int chooserow() return (int)(math.random()*3); public int choosecolumn() return (int)(math.random()*3); public int choosecolumn() return (int)(math.random()*3); 8 Player class: criticism Recall Player class (noughts and crosses) this.piece = piece; public char playingwith() return piece; public int chooserow() return (int)(math.random()*3); This class does not model the range of possible players: Players have names Players might play for a particular club There might be reckless players There might be methodical players etc public int choosecolumn() return (int)(math.random()*3); 9 10 What is inheritance? What is inheritance? I ve inherited my Mum s hair 11 12

3 13 What is inheritance? What is inheritance? I ve inherited my Mum s hair I ve inherited my Mum s hair My Dad s wit My Dad s wit The milkman s good looks Something you get (for free) from a parent 14 in Java What is inheritance? I ve inherited my Mum s hair My Dad s wit The milkman s good looks Something you get (for free) from a parent So what s inheritance got to do with Java? 15 Allows class designs to be built in a hierarchical (family-tree like) manner Super (Parent/Base) Class Sub- (Child/Derived) Class inherits features and capabilities of the super class E.g. Super & derived classes representing player types Have traditional player characteristics plus extra features not present in the basic Player model es inherit properties of super class for free Not necessary to write out data fields and methods of the super class in derived class 16 in Java Allows class designs to be built in a hierarchical (family-tree like) manner Super (Parent/Base) Class Sub- (Child/Derived) Class inherits features and capabilities of the super class E.g. Super & derived classes representing player types Parent class Have traditional player characteristics plus extra features not present in the basic Player model in Java Allows class designs to be built in a hierarchical (family-tree like) manner Super (Parent/Base) Class Sub- (Child/Derived) Class inherits features and capabilities of the super class E.g. Super & derived classes representing player types Parent class Sub-class Have traditional player characteristics plus extra features not present in the basic Player model es inherit properties of super class for free Not necessary to write out data fields and methods of the super class in derived class 17 es inherit properties of super class for free Not necessary to write out data fields and methods of the super class in derived class 18

4 19 in Java Allows class designs to be built in a hierarchical (family-tree like) manner Super (Parent/Base) Class Sub- (Child/Derived) Class inherits features and capabilities of the super class E.g. Super & derived classes representing player types Have traditional player characteristics plus extra features not present in the basic Player model es inherit properties of super class for free Not necessary to write out data fields and methods of the super class in derived class Player Player type in Java Allows class designs to be built in a hierarchical (family-tree like) manner Super (Parent/Base) Class Sub- (Child/Derived) Class inherits features and capabilities of the super class E.g. Super & derived classes representing player types Player Player type Have traditional player characteristics plus extra features not present in the basic Player model es inherit properties of super class for free Not necessary to write out data fields and methods of the super class in derived class 20 A basic model car, something unspectacular like a Ford Fiesta 1.1L A basic model car, something unspectacular like a Ford Fiesta 1.1L Posh A fancy car, leather, sat. nav., CD, like a Ford Fiesta 2.0Lux A basic model car, something unspectacular like a Ford Fiesta 1.1L Parent Class Posh A fancy car, leather, sat. nav., CD, like a Ford Fiesta 2.0Lux Posh BoyRacer A fast car, bucket seats, fury dice, like a Ford Fiesta 3.0 TwinCam Kickin Ass Turbo BoyRacer 23 24

5 25 Parent Class Parent Class Posh Posh BoyRacer BoyRacer Parent class has all the basic features es have all the fancy add-ons In the subclasses you just define the new stuff Not the bits that you inherit from the parent class 26 Related example: Named players Parent Class Named players have all the features of a standard Player and morea name (String) Posh class NamedPlayer extends Player BoyRacer A bit like inheriting features from your parents They give you the basics (hair colour, eye colour etc) And you add the fancy features (degree, overdraft etc) Extends Player class NamedPlayer(char c, String theirname) // new constructor // name is stored System.out.println("Player name: " + playername); Related example: Named players Related example: Named players Named players have all the features of a standard Player and morea name (String) Named players have all the features of a standard Player and morea name (String) class NamedPlayer extends Player class NamedPlayer extends Player NamedPlayer(char c, String theirname) Does not redefine data from Player class // new constructor // name is stored System.out.println("Player name: " + playername); 29 NamedPlayer(char c, String theirname) // new constructor // name is stored Constructor: 1. Takes two parameters System.out.println("Player name: " + playername); 2. Calls the constructor of super class 3. Then constructs the new class 30

6 31 Related example: Named players Named players have all the features of a standard Player and morea name (String) this.piece = piece; class NamedPlayer extends Player public char playingwith() return piece; private String playername; NamedPlayer(char c, String theirname) // new constructor // name is stored Constructor: 1. Takes two parameters System.out.println("Player name: " + playername); 2. Calls the constructor of super class 3. Then constructs the new class Related example: Named players Named players have all the features of a standard Player and morea name (String) class NamedPlayer extends Player NamedPlayer(char c, String theirname) // new constructor // name is stored Constructor: 1. Takes two parameters System.out.println("Player name: " + playername); 2. Calls the constructor of super class 3. Then constructs the new class 32 Related example: Named players hierarchy Named players have all the features of a standard Player and morea name (String) class NamedPlayer extends Player NamedPlayer(char c, String theirname) Public method to go with the private data // new constructor // name is stored System.out.println("Player name: " + playername); Player class (properties) piece Player (constructor) playingwith chooserow choosecolumn NamedPlayer class playername parent class derived class NamedPlayer (constructor) Visibility (scope) hierarchy hierarchy Player class (properties) piece Player (constructor) playingwith chooserow choosecolumn NamedPlayer class playername parent class derived class NamedPlayer (constructor) Visibility (scope) Player class (properties) piece Player (constructor) playingwith chooserow choosecolumn NamedPlayer class playername parent class derived class Do your parents inherit from you? weird NamedPlayer (constructor) Visibility (scope) 35 36

7 37 Keyword super Keyword super The keyword super is used to reference super class super() invokes constructor of super class super.playingwith() invokes method of super class Could also call playingwith(), but not Player() The keyword super is used to reference super class super() invokes constructor of super class super.playingwith() invokes method of super class Could also call playingwith(), but not Player() NamedPlayer(char c, String theirname) NamedPlayer(char c, String theirname) If you define a constructor in the super class and then don t call super() in the first line of the constructor of the sub-class then you will get a compile error If you define a constructor in the super class and then don t call super() in the first line of the constructor of the sub-class then you will get a compile error 38 Keyword this Modifying the Noughts and Crosses game The keyword this is used to reference current class this.playername - accesses playername data in (this) current class NamedPlayer(char c, String playername) this.playername = new String(playerName); Without the this, the local definition (the formal parameter) takes precedence over the instance or class definition. NamedPlayer p1 = new NamedPlayer('X',"Stephen"); NamedPlayer p2 = new NamedPlayer('O',"Jack"); NamedPlayer currentplayer = p1; currentplayer.(); Players (P1 and P2), and currentplayer are NamedPlayers Prints the name of the winner at the end of game Super class (Player); derived class (NamedPlayer) Modifying the Noughts and Crosses game Modifying the Noughts and Crosses game NamedPlayer p1 = new NamedPlayer('X',"Stephen"); NamedPlayer p2 = new NamedPlayer('O',"Jack"); NamedPlayer currentplayer = p1; currentplayer.(); NamedPlayer p1 = new NamedPlayer('X',"Stephen"); NamedPlayer p2 = new NamedPlayer('O',"Jack"); NamedPlayer currentplayer = p1; currentplayer.(); Players (P1 and P2), and currentplayer are NamedPlayers Prints the name of the winner at the end of game Super class (Player); derived class (NamedPlayer) Players (P1 and P2), and currentplayer are NamedPlayers Prints the name of the winner at the end of game Super class (Player); derived class (NamedPlayer) 41 42

8 43 Modifying the Noughts and Crosses game Players personalities NamedPlayer p1 = new NamedPlayer('X',"Stephen"); NamedPlayer p2 = new NamedPlayer('O',"Jack"); NamedPlayer currentplayer = p1; currentplayer.(); Players (P1 and P2), and currentplayer are NamedPlayers Prints the name of the winner at the end of game Super class (Player); derived class (NamedPlayer) Extend NamedPlayer to develop a blueprint for a PersonalityPlayer (personality type and a catch phrase!) class PersonalityPlayer extends NamedPlayer private char personalitytype; private String catchphrase; // new private data // new constructor super.(); System.out.println(catchPhrase); 44 Players personalities Players personalities Extend NamedPlayer to develop a blueprint for a PersonalityPlayer (personality type and a catch phrase!) class PersonalityPlayer extends NamedPlayer private char personalitytype; private String catchphrase; // new private data Extend NamedPlayer to develop a blueprint for a PersonalityPlayer (personality type and a catch phrase!) class PersonalityPlayer extends NamedPlayer private char personalitytype; private String catchphrase; // new private data // new constructor // new constructor super.(); System.out.println(catchPhrase); super.(); System.out.println(catchPhrase); Players personalities Players personalities Extend NamedPlayer to develop a blueprint for a PersonalityPlayer (personality type and a catch phrase!) class PersonalityPlayer extends NamedPlayer private char personalitytype; private String catchphrase; // new private data Extend NamedPlayer to develop a blueprint for a PersonalityPlayer (personality type and a catch phrase!) class PersonalityPlayer extends NamedPlayer private char personalitytype; private String catchphrase; // new private data // new constructor // new constructor super.(); System.out.println(catchPhrase); super.(); System.out.println(catchPhrase); 47 48

9 49 Constructors and methods Note the chain of constructor calling // new constructor Note that the method has been redefined - what's going on here? Player Constructors and methods Note the chain of constructor calling // new constructor Note that the method has been redefined - what's going on here? super.(); System.out.println(catchPhrase); super.(); System.out.println(catchPhrase); Worse still, now calls super.() Worse still, now calls super.() 50 Constructors and methods Constructors and methods Note the chain of constructor calling Note the chain of constructor calling Player Player NamedPlayer // new constructor NamedPlayer // new constructor Personality Player Note that the method has been redefined - what's going on here? Note that the method has been redefined - what's going on here? super.(); System.out.println(catchPhrase); super.(); System.out.println(catchPhrase); Worse still, now calls super.() Worse still, now calls super.() Constructors and methods Overriding Note the chain of constructor calling If a call is made to the () method from a PersonalityPlayer object // new constructor PersonalityPlayerObject.(); method from PersonalityPlayer, rather than from NamedPlayer, is executed Note that the method has been redefined - what's going on here? This is called method overriding 1. look for a method of that name in the local class 2. if the method exists - execute it and stop super.(); System.out.println(catchPhrase); 3. else move up to the super class and go back to step 1 Worse still, now calls super.() 53 54

10 55 Overriding Some benefits of inheritance If a call is made to the () method from a PersonalityPlayer object PersonalityPlayerObject.(); Consider the valid method call PersonalityPlayerObject.playingWith(); method from PersonalityPlayer, rather than from NamedPlayer, is executed This is called method overriding 1. look for a method of that name in the local class 2. if the method exists - execute it and stop 3. else move up to the super class and go back to step 1 The type of the overriding method must have exactly the same type as the method which is overridden from the super class playingwith is not defined within PersonalityPlayer it is inherited from the super- by all derived classes Thus inheritance is very powerful as you can maintain control using method overriding you can relinquish control by inheriting methods 56 Brain full? : Summary I might stop here One of the main purposes of inheritance in OOP is to link together several classes which have properties in common If this is the case, the common properties are extracted and placed in the base class for all the derived (more specialised) classes to inherit Well ordered classes will form an extensive hierarchy - the Java built-in libraries (API) are one example of such a construction and scope Using super and derived classes How do scope rules and inheritance interact? class PersonalityPlayer extends NamedPlayer super.(); System.out.println(catchPhrase); Could we replace this with playername? Java allows an object to be declared as belonging to a base class, but then created as an object of any derived class Eg. Let's change the code in main so that p1 and p2 are defined as standard Players Player p1, p2; but when p1 and p2 are initialised as objects PersonalityPlayer inherits from NamedPlayer and Player, so aren t references to this valid? No, because the definition is local to the Player class p1 = new PersonalityPlayer('X',"Stephen",'A',"Dr. Java"); p2 = new NamedPlayer('O',"Jack"); we are more specific about exactly what kind of player p1 and p2 are 59 60

11 61 Using super and derived classes cont Dynamic binding This feature is useful when dealing with arrays (which must contain elements of the same type) System.out.println("Noughts and Crosses!"); // main routine Player[ ] playerarray = new Player[2]; playerarray[0] = p1; playerarray[1] = p2; This code is valid, even though players are actually different Board b = new Board(); // create board b.printboard(); // print board Player p1, p2; // establish players p1 = new PersonalityPlayer('X',"Stephen",'A',"Dr.J coming your way!"); p2 = new NamedPlayer('O',"Jack"); Player currentplayer = p1; // current player while (!b.iswinner()) // play game. if (currentplayer == p1) currentplayer = p2; else currentplayer = p1; // establish and // print winner currentplayer.(); Looks legitimate 62 Dynamic binding Dynamic binding System.out.println("Noughts and Crosses!"); // main routine System.out.println("Noughts and Crosses!"); // main routine Board b = new Board(); // create board b.printboard(); // print board Player p1, p2; // establish players p1 = new PersonalityPlayer('X',"Stephen",'A',"Dr.J coming your way!"); p2 = new NamedPlayer('O',"Jack"); Player currentplayer = p1; // current player while (!b.iswinner()) // play game. if (currentplayer == p1) currentplayer = p2; else currentplayer = p1; // establish and // print winner currentplayer.(); Looks legitimate Board b = new Board(); // create board b.printboard(); // print board Player p1, p2; // establish players p1 = new PersonalityPlayer('X',"Stephen",'A',"Dr.J coming your way!"); p2 = new NamedPlayer('O',"Jack"); Player currentplayer = p1; // current player while (!b.iswinner()) // play game. if (currentplayer == p1) currentplayer = p2; else currentplayer = p1; // establish and // print winner currentplayer.(); Looks legitimate Dynamic binding: Problem Dynamic binding: Problem mygame.java:209: Method () not found in class Player. mygame.java:209: Method () not found in class Player. currentplayer.(); currentplayer.(); ^ ^ 1 error Player class piece Player (constructor) playingwith chooserow choosecolumn 1 error Player class piece Player (constructor) playingwith chooserow choosecolumn properties visibility NamedPlayer class playername NamedPlayer (constructor) PersonalityPlayer class personalitytype, catchphrase PersonalityPlayer (constructor) properties visibility NamedPlayer class playername NamedPlayer (constructor) PersonalityPlayer class personalitytype, catchphrase PersonalityPlayer (constructor) 65 66

12 67 Dynamic binding cont Dynamic binding cont Error might seem odd. Although currentplayer is declared as a Player (and does not have a method called ), the object it is referencing is actually a PersonalityPlayer or a NamedPlayer - which do have as part of their class definitions If the compiler can detect PersonalityPlayerObject.playingWith() The answer is that this is not really the compilers job The Player objects are not actually created until the program is run. It's only when the objects are created that the computer can know that what you have written in your code is actually valid This process is known as dynamic binding by means of inheritance, why can t it work out that currentplayer is not simply a Player? 68 Dynamic binding: the solution : Summary What should a programmer do? Need to convince compiler that when referencing currentplayer, the code is indeed correct - i.e. it is a PersonalityPlayer (p1) or a NamedPlayer (p2) We have already seen a solution type casting One of the main purposes of inheritance in OOP is to link together several classes which have properties in common If this is the case, the common properties are extracted and placed in the base class for all the derived (more specialised) classes to inherit //currentplayer.(); if (currentplayer == p1) ((PersonalityPlayer) p1).(); if (currentplayer == p2) ((NamedPlayer) p2).(); Well ordered classes will form an extensive hierarchy - the Java built-in libraries (API) are one example of such a construction 69 70