Upload
alaina-wilkins
View
215
Download
0
Embed Size (px)
Citation preview
The child gets it all.
Factor out common behavior parent class implements behavior needed by
children guarantee that all subclasses have the
characteristics promotes code re-use, avoids duplication & errors
Specialization child class redefines behavior of the parent
Extension child class adds new attributes or behavior
Provide common behavior implement once in the
superclass, all children inherit it
Example:all bank accounts have account ID, owner, balance
BankAccount
# accountName# accountID# balance+ deposit( ) : void+ withdraw( ) : void+ getBalance( ) : double+ getAcctName( ) : String ...etc...
CheckingAccount+ CheckingAccount( )+ withdraw( ) : void+ toString( ) : String
SavingAccount+ SavingAccount( )+ withdraw( ) : void+ toString( ) : String
An object of the subclass can be used anywhere that an object of the superclass is expectedIn a program, if all objects of the superclass are replaced by objects from a subclass, the program should still work correctly.
ORSubtypes must be substitutable for their base types
A subclass can override (redefine) a method inherited from the parent, in order to specialize the behavior.
The subclass specializes the behavior for its own needs
public class Person {protected string name;public string ToString() { return name; }
}public class Student : Person {
protected string studentID;// redefine ToString() to return our ID, too.public string ToString() {
return string.Format(“{0} {1} “, name, studentID);}
}
Bank accounts have different rules for deposit and withdraw, so we specialize (redefine) these methods in SavingAccount and CheckingAccount
BankAccount+ deposit( ) : void+ withdraw( ) : void+ getBalance( ) : double+ getAcctName( ) : String ...etc...
CheckingAccount+ deposit( ) : void+ withdraw( ) : void
SavingAccount+ deposit( ) : void+ withdraw( ) : void
A subclass cannot "reduce visibility" of a method it redefines from parent. Example: Object ToString() is public.
A subclass cannot define its own ToString() to be protected or private.
assign weaker access permissions is OK.
Visibility in Parent Class Visibility in Child Class
public ToString( ) public ToString( )
protected setName( ) protected or public OK
private getRadix( ): int anything -- private method is statically bound, visible only inside parent class.
Why these access rules? Its a consequence of the Substitution Principle
"An object of a child class can be substituted any where that an object of the parent class is expected"
Example: the Greeter class expects a Person object and issues a greeting:public class Greeter {public static void greet( Person p ) {
Console.WriteLine("Hello " + p.ToString() )}
}
Person joe = new Person("Joe Nerd");Greeter.greet( joe );joe = new Student("Joe Scholar", "12345678");Greeter.greet( joe );
Student ToString( ) must be at least as visible as Person ToString( )
public class Person {protected string name;protected long ID;public long getID() { return ID; }
}
public class Student : Person {private string ID; // OK to redefine ID!
// OK to redefine method: visibility & type samepublic string ToString() { return name+" "+ID; }
// Illegal! (1) less visible, (2) change typeprotected string getID() { return ID; }
}
Parent's data members and methods are not replaced by child's members, they are simply shadowed.
Use “base" to access parent's members (except private ones). (in java the keyword for this is “super”)
public class Person {protected string name;protected long ID;public string ToString() { return name; }
}
public class Student : Person {private string ID; // OK to redefine ID!
public string ToString() { return name + " " + base.ID; // parent's ID
}}
A subclass can define new behavior that the superclass does not have.
A subclass can also define new attributes.public class Person {
protected string name;public string ToString() { return name; }
}
public class Student : Person {protected int credits; // new attribute
// new behaviorpublic void addToCredits(int n) { credits += n; }public void getCredits( ) { return credits; }
}
A simple test for whether inheritance is reasonable is the "is a" rule.
a Student is a Person
Student extends Person
a Button is a WebControl
Button extends System.Web.UI.WebControls
Apply the “is a” rule
In the case of a Tub, we would say:
"a Bathroom has a Tub" "has a" means that something should be an
attribute "has a" indicates an association. UML uses an open arrowhead for association
Bathroom- items : Tub
Tub1
The "is a" rule does not always indicate inheritance.
Barak Obama is a Person BarakObama is an instance of the Person
class A C # book is a Book
Java book doesn't specialize any behavior of Book. This is a classifier that can be modeled using an attribute.
A Fraction is Comparable Describes a kind of behavior that Fractions
possess. Model this using an interface.
Subclass doesn't add significant extension or specializationExample: a library has several types of recordings: Jazz Recording, Classical Recording, Pop Recording, ...Recordings may be Tape or CDROM
. . .
Recording
JazzRecordingClassicalRecording PopRecording
JazzTapeRecordingJazzCDROMRecording
Don't use a subclass in situations where an object may need to change class during its life time.
Example: Full-time and Part-time students have different requirements and behavior. Should we model this using inheritance?
Student
PartTimeStudentFullTimeStudent
A student could change from Full-time to Part-time... and back again!
Full-time or part-time is a role or status. A Part-time student may have some behavior that is different from Full-time
student. Model this using an attribute of Student that references an object of the appropriate status.
attendance
PartTimeFullTime
StudentEnrollment1 *
C++ has multiple inheritance: subclasses can "mix in" the properties of several parent classes.
class iostream: public istream, public ostream {
public: iostream( streambuf* ); virtual ~iostream();
protected: iostream( );
}
istream ostream
iostream
Java and C# do not allow multiple inheritance. In many situations interfaces can substitute
for use of multiple inheritance.
public class Student extends Person, Thread {...
}Error: no multiple inheritance
public class Student extends Person implements IRunnable {
...}
Runnable interface for Threaded application
Java and C# do not allow multiple inheritance. In many situations interfaces can substitute
for use of multiple inheritance.
public class Student : Person, Thread {...
}Error: no multiple inheritance
public class Student : Person, IRunnable {...
}Runnable interface for Threaded application
In our game we have 2 objects that are very similar
If we take what is similar and create a base object, then we eliminate duplication of code.
GAME OBJECT TARGET OBJECT
Right click on the library(engine) project > Add > New Item
Pick “Class”
TARGET OBJECT BASE OBJECT
What happens if you don’t?
CompileRemove the reference from the
game projectAdd the reference back in (just to
make sure the changes are in the game)