Transcript class

Inheritance
A Review of
Objects, Classes, and Subclasses
Objects
• Can model real-world objects
• Can represent GUI (Graphical User Interface)
components
• Can represent software entities (events, files,
images, etc.)
• Can represent abstract concepts (for example,
rules of a game, etc.)
Classes and Objects
•A class is a piece of the program’s source code that
describes a particular type of object. Object-Oriented
programmers write class definitions.
•An object is called an instance of a class. A program
can create and use more than one object or instance
of the same class as needed.
•The word instance is a good word to represent an
object because it indicates an object that exists for a
period of time during part or all of the time a program is
running.
Difference Between a Class and an Object
Class
A blueprint for objects of a
particular type … a cookie cutter.
Defines the structure (number,
types) of the characteristics or
attributes
Defines available behaviors of its
objects
Object
Characteristics
fields or instance
variables
Behaviors
(methods)
Class: Car
Attributes:
String model
Color color
int numPassengers
double amountOfGas
Object: a car
Attributes:
model = "Mustang"
color = Color.YELLOW
numPassengers = 0
amountOfGas = 16.5
Behaviors:
Behaviors:
Add/remove a passenger
Get the tank filled
car calls methods of
Report when out of gas
class as needed
Class
• A piece of the
program’s source
code
• Written by a
programmer
vs.
Object
• An entity in a
running program
• Created when the
program is running
(by a constructor or
another method in a
driver program or
other file)
Class
• Specifies the structure
(the number and
types) of its objects’
attributes — the same
for all of its objects
• Specifies the possible
behaviors of its
objects
vs.
Object
• Holds specific
values of attributes
or characteristics;
these values can
change while the
program is running
• Behaves
appropriately when
called upon
Classes and Source Files
• Each class is stored in a separate file
• The name of the file must be the same as the
name of the class, with the extension .java
Car.java
public class Car
{
...
}
By convention, the
name of a class
(and its source file)
always starts with
a capital letter.
(In Java, all names are case-sensitive.)
Libraries
• Java programs are usually not written from
scratch.
• There are hundreds of library classes for all
occasions.
• Library classes are organized into packages.
For example:
java.util — miscellaneous utility classes
java.awt — windowing and graphics toolkit
javax.swing — GUI development package
Import Statements
• You can import names for all the classes in a
package by using a wildcard .*:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
Imports all classes
from awt, awt.event,
and swing packages
• java.lang is imported automatically into all classes
and programs.
• java.lang defines System, Math, Object, String,
and other commonly used classes. Its nice to not
have to take the time to import these.
SomeClass.java
import ...
import statements
public class SomeClass
{
• Fields
• Constructors
• Methods
}
Class header
Attributes / variables that define the
object’s state; can hold numbers,
characters, strings, other objects
Procedures for constructing
a new object of this class
and initializing its fields
Actions that an object
of this class can take
(behaviors)
Fields
The word fields is used to represent not only instance variables
but also class variables and class constants. Specifically:
• Instance variables constitute the “private memory” of an
object.
• Class variables are usually private, but class constants are
generally public.
• Each field has a data type (int, double, String, Image, etc.)
Any field can be an object of any type.
• Each field has a name given by the programmer that should
meaningfully describe its use.
Types of Fields
You name it!
private [static] [final] datatype name;
Usually
private
May be present:
means the field is
shared by all
objects in the class
int, double, etc., or an
object: String, Image,
SavingsAccount, etc.
May be present:
means the field
is a constant
Fields
Examples:
• private int pin;
// private instance variable
• public static final double INTEREST_RATE = 0.025; // class
constant
• private static int numberOfAccounts;
The last example is a class variable. It is not an attribute of any
object of the class, but rather it is an attribute of the class.
The class (not any specific object) will maintain how many
accounts have been created. Usually there is a public class
method that allows a programmer to access its value.
Constructors
• Short procedures for creating objects of a class
• Always have the same name as the class
• Have the responsibility to initialize the object’s
fields
• May have parameters that pass off their values to
the fields
• A class may have several constructors that differ
in the number and/or types of their parameters
Constructor Parameters
// ATM_Test.java
...
...
savings = new SavingsAcount (first, last, p, …);
...
Constructor Call
public class SavingsAcount
{
...
public SavingsAcount (int firstName, int lastName, int pin, …)
{
...
Constructor Code
}
...
}
The number, order, and types of parameters must match.
Constructors Documentation
A class’s API can show you how to
use constructors of the class.
JButton go = new JButton("Go");
Methods of a Model Class
• Methods of a Model class are called for a particular
object. In other words, in this form:
savings.deposit(amount);
checking.withdrawl(amount);
• These kind of methods are sometimes called
instance methods. These methods do not contain
the word static in their method signatures. They
may be accessor or mutator methods.
• Class methods contain the word static in their
method signatures and are usually called to obtain
the value of a class variable.
Example of a Class Method
Example of a class method:
public static int getNumberOfAccounts ( )
{
return numberOfAccounts;
}
This method would return the value stored in the
private class variable numberOfAccounts.
Parameters of Methods
• The number and types of parameters (a.k.a.
arguments) passed to a method must match
method’s parameters:
public void drawString ( String msg, int x, int y )
{
...
}
g.drawString ("Welcome", 120, 50);
Encapsulation and Information Hiding
• A class interacts with other classes only through
constructors and public methods.
• Other classes do not need to know the mechanics
of a class to use it effectively. In other words, a
class doesn’t need to know the implementation
details of how the code is written in another class.
• Encapsulation is the combining of attributes an
behavior together to define an object. In other
words, writing a model class to define the fields and
methods needed for a particular kind of object.
Encapsulation facilitates team work and program
maintenance (making changes to the code).
The Scope of a Class’s Methods
• A class’s constructors and methods can call other
public and private methods of the same class.
• However, a class’s constructors and methods can
call only public methods of another class.
Class X
Class Y
private field
public method
public method
private method
A method of one class can’t access any private items of another class.
Inheritance
In Object Oriented Programming, a programmer can
create a new class by extending an existing class.
Superclass
(Base class)
subclass extends
superclass
Subclass
(Derived class)
Subclasses
A subclass …
•
•
•
•
inherits fields and methods of its superclass
can add new fields and methods
can redefine (override) a method of the superclass
must provide its own constructors, but calls
superclass’s constructors
• does not have direct access to its superclass’s
private fields, but has access to protected fields
Sample Structure of Inheritance
Many times
programmers will
organize hierarchies of
classes using an
interface, a superclass
and subclasses.
Interface
Super Class
Subclass Class 1
Subclass Class 2
You can think of the red arrow
as meaning “inherits from”
Objects in a Bank Account Program
In a Bank Account program
we might have a
SavingsAccount and a
CheckingAccount, but to
keep from duplicating code
we might have an
AbstractAccount class to
accumulate the code that
would be the same in those
classes. An interface could
also serve to further
organize objects of these
types to standardize the
type of accounts used for
our purpose.
BankAccount Interface
AbstractAccount Class
SavingsAccount Class
CheckingAccount Class
You can think of the red arrow
as meaning “inherits from”
Structure of an Interface
public interface BankAccount
{
public String getFirstName();
public String getLastName();
public int getAccountNumber();
public double getBalance();
public double deposit (double d);
public double withdrawl (double d);
}
An interface is a listing of methods that must be implemented by
a class or another interface. (Yes it is possible to have a
subinterface.) In the list, only the method signature of the
method to be implemented followed by a semicolon is
included for each method. Also, the interface definition line
uses public interface instead of public class.
Declaring an Abstract Class
Here is the class definition line of an abstract class that
implements an interface.
abstract public class AbstractShape implements Shape
Notice it looks the same as a typical class definition line, except
that the Java keyword abstract is added to the first of it.
One thing you can’t do is instantiate an object of an abstract
class. Think about that. An object of an abstract class would
really be an incomplete object. It would be a partial object that
would contain only some parts of an object that might be
constructed of a subclass. So it would be meaningless.
So to prevent an object of an abstract class from being
constructed, we add the keyword abstract to the class
definition line.
Final Methods of an Abstract Class
As mentioned previously, an abstract class is a super class that
contains the code that would be duplicated in any subclasses.
An abstract class will contain fields and methods that would be
the same for all subclasses that would extend it.
For the methods that would be the same in any subclass, we
just need to code them once in the abstract class and not in
the subclasses. To do this, we place the Java keyword final at
the first of the method signature to indicate that the method
can’t be overridden in a subclass.
If for some reason, you might want the method to be overridden
in one class but not other subclasses, then you would leave
off the word final.
Final Methods of AbstractShape
These final methods were used in the AbstractShape class,
because the code would have been exactly the same in the
Circle, Rectangle, or Triangle classes. So we place it in the
AbstractShape class and make the methods final.
public final int getXPos() {
return xPos;
}
public final int getYPos() {
return yPos;
}
public final Color getColor() {
return color;
}
Abstract Methods of an Abstract Class
For methods that will be provided by subclasses, we just provide
the method signature along with the word abstract and a
semicolon to end the method signature. No code or curly
braces are included.
If the abstract class implements an interface, it is necessary to
include the word abstract with methods like this so Java
knows that the subclass will be providing the method. By
implementing the interface, Java is forcing the abstract class
to implement the method. So if is not going to provide the
method, then it must have the method signature with abstract
so Java knows how it will be handled.
Abstract Methods of the AbstractShape Class
These abstract methods were used in the AbstractShape class,
because the code for each one in the Circle, Rectangle, and
Triangle classes was different. Therefore the AbstractShape
class couldn’t provide each method’s code.
abstract public double area();
abstract public void draw (Graphics g);
abstract public void paint (Graphics g);
abstract public void move (int xLoc, int yLoc);
abstract public void stretchBy (int factor);
Using the Super Keyword in Java
When super is used inside a constructor, it must be the first line
of code.
If it is in the default constructor of a subclass and you write:
super( );
then you are calling the default constructor of the superclass.
If it is in an initializing constructor, and you need to pass
parameters up to the superclass, then you will be calling the
initializing constructor of the superclass. The code might look
like this, but it still needs to be the first line of code:
super(xLoc, yLoc, r, c);
Using the Super Keyword in Java
When super is used inside any other method, it doesn’t have to
be the first line of code.
If it is in the draw method of a subclass and you write:
super.draw(g);
when you are calling the draw method of the super class, then it
can be any place in the method.