View
225
Download
2
Category
Preview:
Citation preview
The DoME Example
The Database of Multimedia Entertainment We will be storing information about CDs and
videos We will want to be able to perform actions on
each of these lists of items.
Desired Functionality
Enter information about CDs and videos Store information permanently Search functionality Print lists of all CDs or videos
Desired Information
Title of album Artist Number of tracks Total Playing time “Got it” flag Comment
Title of video Name of director Total Playing time “Got it” flag Comment
Design Discussion
Each of the private fields would have a setter and a getter
The each list of CDs and videos could be stored in a separate array list
Do you see any issues with this approach? DoME Source Code
Major Issue
Code duplication There is code duplication in almost every
aspect of every class With the two ArrayLists we have to duplicate
every method. With repeated information we have to repeat
the same code in both the CD and video class
What happens when we want to add books?
Inheritance
Inheritance allows us to define one class as an extension of another
Inheritance allows subclasses to get all the fields and methods from the superclass.
In this way, we can put all the common information in one class and inherit from it
Then we can put the specialized information in the subclasses
Better Classes for DoME
ItemtitleplayingTimegotItcommentsetCommentgetCommentsetOwngetOwnprint
CDartistnumberOfTracksgetArtistgetNumberOfTracks
VideodirectorgetDirector
Inheritance and Java
There are some syntax issues when dealing with Java and inheritance
We use the keyword extends to indicate that one class inherits from another class
We may choose to use different access modifiers within the base class to allow for easier access in the child classes
We need ways to initialize the super class
Inheritance and Java
public class Item{
private String title;private int playingTime;private boolean gotIt;private String Comment;…
}
public class CD extends Item
{private String artist;private int numberOfTracks;…
}
Inheritance and Access Rights Just like any other class a subclass of a
superclass is not allowed to access any private data; it must use setters and getters
It does not need to use a dot in front of any methods
It can call them as if they were their own We will come back to this issue when later
and introduce a protected access modifier
Inheritance and Initialization
When we create an object the constructor is called and the state of the object is set.
But how do we set the state of the superclass?
In the first line of the subclass’s constructor we use the key word super and supply any necessary parameters to the superclass’s constructor
Example
public class Item{
…public Item( String theTitle, int time ){
title = theTitle;playingTime = time;gotIt = false;comment = “”;
}…
}
public class CD extend Item{
…public CD( String theTitle, String theArtist, int tracks, int time ){
super(theTitle, time);
artist = theArtist;numberOfTracks =
tracks;}…
}
Things to Notice
The constructor for the CD receives the information necessary to create an item in addition to the information need to create the CD
The key word super is the call to Item’s constructor and we pass in the information it wants
The first line of the subclass’s constructor must always be to the superclass’s constructor through the key word super
Subtyping
Let’s take a look at the Database code since we have changed to inheritance
DoME Example V2 It is much simpler The reason is subtyping
Subtyping Again
When we have said in the past that when you call a method, the actual parameters must match the type of the formal parameters
We could have said must match the type or be a subtype of the formal paramaters
We can now have one ArrayList that will hold items
So addItem will take an item or any of its subclasses as a parameter.
Subtyping and Assignments
We are allowed to assign to a variable any object that matches its type or is a subtype of its type
These are allowed Vehicle v1 = new Vehicle(); Vehicle v2 = new Car(); Vehicle v3 = new Bike(); This is not Car c1 = new Vehicle();
Vehicle
Car Bike
Polymorphism
Polymorphism, for now, is an idea that allows a variable to be able to be more than one thing at different times.
It allows us to simplify our print code for the database.
We will come back to this important idea later
The Object class
In Java all objects inherit from the Object class. We don’t have to do anything, it is automatic. This is how ArrayLists can hold any type of object. They expect an Object as their parameters. Since all objects inherit from this common base, we
can pass any object to a collection in Java That is also why, it gives us an object back and we
have to cast it back to its particular type.
Recommended