PowerPoint Presentation - Java Methods A & AB

slimwhimperΛογισμικό & κατασκευή λογ/κού

3 Νοε 2013 (πριν από 3 χρόνια και 7 μήνες)

68 εμφανίσεις

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

Characteristics

fields or instance
variables

Behaviors

(methods)


Class Object

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

Class: Car Object: a car

Attributes:


String model


Color color


int numPassengers


double amountOfGas


Behaviors:



Add/remove a passenger


Get the tank filled


Report when out of gas

Attributes:


model = "Mustang"


color = Color.YELLOW


numPassengers = 0


amountOfGas = 16.5


Behaviors:




car calls methods of
class as needed


Class vs. Object


A piece of the
program’s source
code


Written by a
programmer


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 vs. Object


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


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


public class Car

{


...

}

Car.java

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.*;


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.

Imports all classes
from
awt
,
awt.event
,
and
swing

packages

public class SomeClass


Fields



Constructors



Methods

}

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)

{

Class header

SomeClass.java

import ...

import statements

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.

private [static] [final]

datatype

name
;

Types of Fields

May be present:
means the field
is a constant

int
,
double
, etc., or an
object:
String
,
Image
,
SavingsAccount, etc.

You name it!

May be present:
means the field is
shared by all
objects in the class

Usually
private

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

public class
SavingsAcount

{


...



public
SavingsAcount
(
int firstName, int lastName, int pin, …
)


{


...


}


...

}


// ATM_Test.java


...


...


savings =
new SavingsAcount (first, last, p, …)
;


...


The number, order, and types of parameters must match.

Constructor Code

Constructor Call

Constructors Documentation

JButton go =
new

JButton("Go");

A class’s API can show you how to
use constructors of the class.

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:




g.drawString (
"Welcome", 120, 50
);


public void drawString (
String msg, int x, int y

)


{


...


}

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

private field





private method


Class Y









public method


public 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

(Derived class)

subclass
extends

superclass

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.