Object-Oriented Programming (721112) - Philadelphia

Object Oriented Paradigms by Dr. Nadia Y. Yousif

Object-Oriented Programming (721112)

A Core Module for Students in

CS, CIS, SE, ACS Departments

Faculty of IT / Philadelphia University

Second Semester 2006/2007

Object-Oriented Programming (721112)

Lecturer: Dr. Nadia Y. Yousif

Email: nyaaqob@philadelphia.edu.jonadiayy@hotmail.com

Room: IT 332

Course Outline

• Aims• Objectives• Assessment and Passing the Subject• Lectures and Practice Classes• Lecturer and Consultation• Recommended Reading• Course Overview • Chapter 1

Aims of this module

• To develop an understanding of the principles of the object-oriented paradigm.

• To provide familiarity with approaches to object-oriented modeling and design.

• To provide a familiarity with the syntax, class hierarchy, environment and simple application construction for an object-oriented programming language.

Course Objectives• Acquire a full Object Oriented Thinking.• Have a clear understanding of the object-oriented

concepts such as objects, classes, inheritance, and polymorphism.

• Have an informal understanding of the operational semantics of object-oriented programs in terms of creation of objects and messages passing between them.

• Be able to design small object oriented programs which meet requirements expressed in English, with a strong software engineering foundation

• Have knowledge of Object Oriented Design guidelines.• Be able to code small programs in Java language.• Be able to produce and maintain large, high-quality

software systems

Assessment and Passing

• There are three assessment components:- Two midterm exams worth 15% of the marks

each- Course work worth 20% of the marks- Final exam worth 50%

• You need to achieve an overall mark of 50% to pass the course.

Lectures and Practice Classes

• Lectures will be held at:11:15 am on Monday and Wednesday in Lab 7501There will be one practice class each week:12:45 pm to 13:45 pm on Wednesday, Lab 7501

During the first three weeks, tutorials will be given in the practice class,

• During the rest weeks, students are expected to work on practice problems, or on their assignments

• The lecturer will be available to comment on, and help with, solutions during the practice class.

Lecturer and Consultation

• Lecturer:Dr. Nadia Y. YousifFaulty of IT, Room 332, Phone Ext: 2544email: nyaaqob@philadelphia.edu.jo

• Consultation– The primary time for consultation is during the

practice classes– Other consultation at the office hours (in room

332) on:(Sun, Tues, Thu) 13:00 – 14:00 (Mod, Wed) 13:45 – 15:15

Recommended Reading

• The text book is:David J. Barnes and Michael Kolling,Objects First with Java: A Practical Introductionusing BlueJ, Prentice Hall, 2003

Note:Most of the slides of this module are from the above

reference

Lab and BlueJ

• In the lab hours, we will implement java program by using the Java Development Environment (BlueJ) that runs on top of Sun Microsystems's Java Development Kit.

Course Overview

• Overview• Objects and classes• Understanding class definitions• Object interaction• More sophisticated behaviour - libraries• Well-behaved objects - testing, maintaining, debugging• Designing classes• Inheritance• Polymorphism• Extendable, flexible class structures• Handling errors• Grouping objects• Designing applications

Overview

Topics to cover:- Structured Programming Paradigm (SPP)- Object-Oriented Paradigm (OOP)- Paradigm Shift from (SPP to OOP)- What is this OO thing?

Structured Programming Paradigm (SPP)

• Top Down – Step wise refinement• Solves all of problem in one program• Break down into hierarchy of modules

1. INITIALISE2. MAIN PROCESS A

2.1 PROCEDURE-A2.2 PROCEDURE-B

2.2.1 Function A2.2.2 Procedure B

Function B1Subroutine B2

65. FINALISE

Object-Oriented Paradigm (OOP)

Objects – real world thingsArrows – messages for tasks and activities

Window

Enrolment

DB Connection

Button

Student Application

Network Socket

Authorised Clerk

TextArea

Student

Paradigm Shift from (SPP to OOP)

• Real World DATA first• Not processing first

– In real world, algorithms and processes change– Underlying data objects remain stable

• Intended benefits– Solve the “software” crisis– Break complexity into small manageable chunks– Make software maintenance easier– Allow reuse of components – plug and play

What is this OO thing?

• The world consists of "objects" and we are trying tosolve real world problems - hence we should useobjects to model and hopefully solve some of theproblems.

• Object Oriented Software Engineering Paradigm - setof techniques and processes focusing on how toanalyse and model a real world problem and todesign a solution.

• Object Oriented Programming Language - aprogramming language which supports theimplementation of an object oriented model - we willuse Java.

The Promise

• Allows us to build better software systems cheaper by– breaking complexity into small manageable chunks– make software maintenance easier– allow to reuse software pieces

• Does it work in real life? Sort of. Not perfectly, but much better than any other approach so far.

Chapter 1: Objects and ClassesTopics to cover:• Objects and Classes

- Objects; Classes- Describing the Objects- Finding Generalizations and Associations- Behavior- Class Design Hints- Good Programming Style- Object Communication- Methods and Parameters- Method Invocation- State of the Object- Source Code of the Class

Chapter 1: Objects and Classes (Cont.)

Objects• Objects represent ‘things’ from the real world, or from some problem domain (example: “the red car down there in the car park”)

• Any "thing" can be an object.• physical things (chair, car, ...)• occurrences (meeting, date, ...)• …• Rule of thumb: If you can describe the "thing" using an English noun, it could be an object.

• Each object is unique.

Objects

• We can think of an object as a collection of- variables (or attributes) i.e. stuff the object "knows“- operations (or behaviors) i.e. stuff the object "does”

• This is a mechanism for encapsulation. This provides- modularity- information hiding

• Object’s operations (Java calls them methods) can be invoked (or called)

Classes• A class describes – in an abstract way - all objects of a

particular kind (example: “Car”)

• NOTE:– You should choose meaningful names for classes and

methods that express the required task– Names of classes start with capital letter (e.g. Circle)– Names of objects start with lowercase letters (e.g. circle_1)– Name of variables (or fields) start with lowercase letters

(e.g get, print)– If name is longer than one word, capitalize first letter of

each word except the first, e.g.– for a class: ShortPureBredDogs– for a method: takeDogForWalk

Classes (Cont.)

• A class describes an object - think of it as a blueprint. A class defines:- the attributes- the behavior- how to construct (usually)- how to destruct (if necessary)- a particular type of object.

• A class is NOT an object.- You can use a class to create object of this class.- An object is called instance of the class it was createdfrom.

- The object is of type of this class.

Example of Class vs. Object

• A blueprint (class) of a Car tells you– the attributes (number of wheels, color, number of gears, ...)– the behavior (accelerate, brake, turning, ...)– how to construct one (1. Take a large sheet of metal andbend it 2. ...)

– how to destruct one (Take it to the wreckers)

• IMPORTANT: A class is NOT an object.• It is hard to drive around with the blueprint, but you could use

it to build one or more cars.

Our World In This Lecture

• In this lecture we will use object orientation to think about all our "Contacts".

• Contacts are all persons we interact with in some way. We give them phone calls, we meet them, we write them email, letters, faxes. We also "in contact“with non-persons - companies, student groups, ...

• So what's the program supposed to do? There is no program. The idea is think about these objects, about their attributes and behavior. At the end, we might think about what the objects we put together could be used for.

Object Candidates

• Person - Ahmed, Ali, Saba, ...• Companies, Student Organizations• Email, Fax, Letter, Phone Calls• Meetings• Relationships (marriage, partner, employee, boss,

friend, ...)• ...

Describing The Objects (Classes)

• What are the attributes of a person?- Name - Birthday- Address - Length - ...

• What are the attributes of a company?- Name - Address- Task - …

• What are the attributes of a student organization?- …

Finding Generalizations and Associations

• What's common between persons, companies, student organizations?

• How can we generalize, so we don't have to repeat ourselves when describing each of the ones above?

• Which objects are "related"?- Person to Person- Person to Organization- Organization to Organization

• Associations can have different cardinalities.

Behavior

• What can the different objects do?• Person: Say name• Organization: Move• Person: getJob. looseJob• Organization: goBankrupt• What could be the sequence of message passing in

goBankrupt be?

Less Obvious Objects

• Is a meeting an object?• Does it have attributes?• Does it have "behavior"?

• Meeting can be a object:- Attributes: Date, Time, Location, ...- Behavior: Schedule, Cancel, ...- Relationship: Attendees- Generalization: Encounter

A Closer Look at Address Attribute

• What is an address?- Street, State, Postcode, City, ...

• We may expand our Person class ...• And what is a location in our meeting class?• Address is an object by itself!• Attributes?• Behaviour?• Now an organization can have multiple addresses!

Creating An Address Book For All Your Contacts

• Now you want to write down the addresses of all your contacts.

• You also want to include the birthdays of all your contacts.• We need a behavior on all contacts which talks about them.• Persons should give their name, address and birthday.• Companies should give their name and address.• We don't want to specify how to give name and address twice -

what's a better way?• Note that giveDetails( ) does different things in different

subclasses even though the interface is the same - when a message is sent, the type of object it is sent to determine,which behavior is invoked. This is called polymorphism

Discovering Classes

• Noun phrase approach• “Object Think”• Hybrids

Noun Phrase Approach• Assume well specified requirements/problem specification

document• Look for noun phrases - each noun is candidate class• Group

– relevant classes– fuzzy classes– irrelevant classes

• Discard synonyms. Refine until list includes only relevant classes

• Use this as basis• More will be discovered during design process• Bottom up approach that assumes requirement document is

complete and correct• Is this true in reality ?

Object Think

• The Object-Oriented Approach, • Purpose is to change way developers think

about computer systems from whole approachto one object at a time

• Let object speak for itself• Let object speak for itself in context of

application

Example

• I am a button on the screen– I know what window I am attached to– .. my position– .. my height and width– .. my background color– .. what the label says– .. what to do when clicked

• I am a window– I know my title– ……– I Know what objects are attached to me– … how to move– … how to shrink– … how to close myself

In context of application

• I am actually a rock– I don’t know anything– I don’t know how to do anything

• I am a rock in context of a rock collector– I know my type, weight, shape, color, density and value– I know who discovered me– … where I was found– … how I was foundAnd– I can tell people about myself– I can add myself to a collection (and remove myself)– I can associate myself with a shelf

• Think in terms of objects for people and transportation - think at least about persons, cars, bikes and locations.

• So, this is all totally easy and a waste of time for you? Great, you'll make a lot of many as a star OO Analyst and Designer ...

Class Design Hints• Always keep data private• Always initialize data

- don’t rely on defaults• Do not use too many primitive types

- if needed, introduce a new class- e.g. Address instead of street, city, state and zip

• Not all fields need individual accessors and mututors (discussed later)

- e.g. setDate not setDay, setMonth, setYear• Use consistent form for class definitions

- attributes - constants - constructors - methods - static- public - package scope - private

• Break up classes with too many responsibilities• Make names reflect responsibilities

Program Documentation

• Programs are often the only form of system documentation !

• Use comments• Use comments to describe purpose• Use comments to clarify difficult concepts• Write self-documenting code using good

programming styles

Good Programming Style

• Use blank lines, space characters, etc for readability• Java - use naming conventions

– ClassName– objectIdentifier– methodName– for widgets use prefixes lbl txt btn

• Use aligned braces (use comments at ends of blocks)• Use indentations• Use spacing (e.g. in lists, expressions)• Meaningful variable names• Split long statements meaningfully

Object Communication

• Messages- Object communicate via message passing.- A message consists of an object (the recipient), a

method, and optional parameters.• Example

An object: point1– Attributes or fields: int x, y;– Method: void move (int dx, int dy)– A message: point1.move(10, 10)

Methods and Parameters

– Methods may have parameters of different types to pass additional information needed to execute

– A type specifies what kind of data can be passed to a parameter.

– Methods may return a result via a return value

Methods and Parameters (Cont.)

– Method Signature provides information about the method:- its name- type of its returned result (or void if no returned result)- list of parameters

– Examplesint method1 ( )

void moveHorizontal (int distance)

methodmethod (no parameter)(no parameter)Type of Type of resultresult

(parameter)(parameter)methodmethodNo returned resultNo returned result

Methods Invocation

• Methods are invoked by objects using the dot notation.

e.g.circle_1.moveHorizontal (50)

This means that object circle_1 invokes methodmoveHorizontal with 50 as parameter

Methods Invocation (Cont.)

• The called method could be within the same class, in which case only the method name is needed

myMethod();

myMethodcompute

Methods Invocation (Cont.)

• The called method could be part of another class or object

obj.doIt( );

main doIt helpMe

helpMe();

Other observations

• many instances can be created from a single class• an object has:

- attributes: values stored in fields (the state of the object).- behaviors (or methods) - what it can do (or be done to it)

• the class defines what fields an object has, but each object stores its own set of values (the state of the object)

• For example, consider a Circle class that has diameter as a field

• The state of the object circle_1 is its current diameter• The behavior of circle_1 is that it can be enlarged by

increasing its diameter• Note that the behavior of the circle object might change its

Two Circle Objects

Source Code

• Each class has source code (Java code) associated with it that defines its details (fields and methods).

int x, y;char ch; Field declarations

Method declarations

Object-Oriented Paradigms 1

Chapter 2Understanding Class Definitions

Main concepts to be covered:• fields• constructors• methods• parameters• assignment statements• conditional statements

Ticket Machines – an External View

• Exploring the behavior of a typical ticket machine.– Use the naive-ticket-machine project.– Machines supply tickets of a fixed price.

• How is that price determined?

– How is ‘money’ entered into a machine?– How does a machine keep track of the money

that is entered?

Ticket Machines – an External View (Cont.)

• Interacting with an object gives us clues about its behavior.

• Looking inside allows us to determine how that behavior is provided or implemented.

• All Java classes have a similar-looking internal view.

Basic Class Structure

The outer wrapperof TicketMachine

public class TicketMachine{

Inner part of the class omitted.}

public class ClassName{

FieldsConstructorsMethods

The contents of aclass

Fields• Fields store values for an object.• They are also known as instance variables.• Use the Inspect option to view an object’s fields.• Fields define the state of an object.public class TicketMachine{ private int price;

private int balance;private int total;

Constructor and methods omitted.}

private int price;

visibility modifier type variable name

Constructors• Constructors initialize an object.• They have the same name as their class.• They store initial values into the fields.• They often receive external parameter values for this.

public TicketMachine (int ticketCost){

price = ticketCost;balance = 0;total = 0;

Passing Data via Parameters

Assignment

• Values are stored into fields (and other variables) via assignment statements:

variable = expression;e.g. price = ticketCost;

• A variable stores a single value, so any previous value is lost.

Accessor Methods

• Methods implement the behavior of objects.• Accessors provide information about an

object.• Methods have a structure consisting of a

header and a body.• The header defines the method’s signature.

public int getPrice()• The body encloses the method’s statements.

Accessor Methods

public int getPrice( ){

return price;}

visibility modifierreturn type

method name

parameter list (empty)

return statement

start and end of method body (block)

Mutator Methods

• Have a similar method structure: header and body.

• Used to mutate (i.e., change) an object’s state.

• Achieved through changing the value of one or more fields.– Typically contain assignment statements.– Typically receive parameters.

Mutator Methods

public void insertMoney (int amount){

balance += amount;}

visibility modifier return type (void)method name parameter

assignment statement

field being changed

Printing from Methodspublic void printTicket(){ // Simulate the printing of a ticket.

System.out.println("##################");System.out.println("# The BlueJ Line");System.out.println("# Ticket");System.out.println("# " + price + " cents.");System.out.println("##################");System.out.println();

// Update the total collected with the balance.total += balance;// Clear the balance.balance = 0;

Reflecting on the Design of the Ticket Machines

• Their behavior is inadequate in several ways:– No checks on the amounts entered.– No refunds.– No checks for a sensible initialization.

• How can we do better?– We need more sophisticated behavior.

Making choices

public void insertMoney(int amount){ if(amount > 0)

{balance += amount;

}else{ System.out.println("Use a positive amount: "

+ amount);}

Making choices

if(perform some test) {Do the statements here if the test gave a true result

}else {

Do the statements here if the test gave a false result}

‘if’ keyword boolean condition to be tested - gives a true or false result

actions if condition is true

actions if condition is false‘else’ keyword

Local variables

• Fields are one sort of variables.– They store values through the life of an object.– They are accessible throughout the class.

• Methods can include shorter-lived variables.– They exist only as long as the method is being

executed.– They are only accessible from within the

method.

Local variables

public int refundBalance(){

int amountToRefund;amountToRefund = balance;balance = 0;return amountToRefund;

A local variable

No visibilitymodifier

Review• Class bodies contain fields, constructors and methods.• Fields store values that determine an object’s state.• Constructors initialize objects.• Methods implement the behavior of objects.• Fields, parameters and local variables are all variables.• Fields persist for the lifetime of an object.• Parameters are used to receive values into a constructor or

method.• Local variables are used for short-lived temporary storage. • Objects can make decisions via conditional (if) statements.• A true or false test allows one of two alternative courses of

actions to be taken.

Chapter 3Object interaction

Creating cooperating objectsTopics to Cover• An Example: A Digital Clock to demonstrates:

- Abstraction and Modularization- Object Diagram- Class Diagram- Primitive Types and Composite Types- Objects Creating Objects- Method Calling- Internal Methods

An Example: A Digital Clock

• In this chapter, a digital clock is considered • Digital clock is as follows:

Abstraction and Modularization

• Abstraction is the ability to ignore details of parts to focus attention on a higher level of a problem.

• Abstraction is also considered as a modelof a complex system that includes only the details essential to the perspective of the viewer of the system.

• For example Programs are abstractions.

Abstraction and Modularization (Cont.)

• Example: A car is viewed by two different ways

• Modularization is the process of dividing a whole thing into well-defined parts, which can be built and examined separately, and which interact in well-defined ways.

• Modularizing the Clock Display

One four-digit display?

Or two two-digit displays?

Implementation - NumberDisplay

public class NumberDisplay{

private int limit;private int value;

Constructor andmethods omitted.

Implementation - ClockDisplay

public class ClockDisplay{

private NumberDisplay hours;private NumberDisplay minutes;

Constructor andmethods omitted.

Object Diagram

• Object diagram shows the objects interactions. Forexample, myDisplay is an object of class ClockDisplay. It has two fields of type NumberDisplay.

Class Diagram

• Class diagram shows the set of classes that a problem involves with.

Primitive Types and Composite Types

• Data types could be:• Atomic (simple) or primitive type: A data type whose

elements are single, nondecomposable data items; e.g. integer, float, char type.

• Composite type: A data type whose elements are composed of multiple data items; e.g. classes

• Structured composite type: An organized collection of components in which the organization determines the means of accessing individual data components or subsets of the collection; e.g. arrays

Primitive and Composite Data Types (Cont.)

Example: Java’s Built-In Types

Primitive Types vs. Object Types

SomeObject obj;object type

int i;32 primitive type

Primitive Types vs. Object Types

b = a;int a;

int b;32

• Assignments on primitive types is different than that on object types. For example:

SomeObject a; SomeObject b;

Source Code: Methods of NumberDisplay

public NumberDisplay(int rollOverLimit){

limit = rollOverLimit;value = 0;

public void increment(){

value = (value + 1) % limit;}

Source Code: Methods of NumberDisplay

public String getDisplayValue(){

if(value < 10)return "0" + value;

elsereturn "" + value;

Objects Creating Objects

public class ClockDisplay{

private NumberDisplay hours;private NumberDisplay minutes;private String displayString;

public ClockDisplay(){

hours = new NumberDisplay(24);minutes = new NumberDisplay(60);updateDisplay();

Objects Creating Objects (Cont.)

in class NumberDisplay:

public NumberDisplay(int rollOverLimit);

formal parameter

in class ClockDisplay:hours = new NumberDisplay(24);

actual parameter

ClockDisplay Object Diagram

Method Calling

public void timeTick( ){

minutes.increment( );if (minutes.getValue( ) == 0) {

// it just rolled over!hours.increment( );

}updateDisplay( );

Internal Method

/*** Update the internal string that represents the* display.*/

private void updateDisplay( ){

displayString = hours.getDisplayValue( ) + ":" + minutes.getDisplayValue( );

Method Calls

• internal method calls: use the name of the method;

updateDisplay();…

private void updateDisplay()

• external method calls: use the dot notation

minutes.increment();

Concepts

• abstraction• modularization• classes define types• class diagram• object diagram• object references

• primitive types• object types• object creation• overloading• internal/external

method call

Object-Oriented Paradigms1

Chapter 4Grouping Objects

Collections and Iterators

Topics to be covered:• Collections• Loops• Iterators• Arrays

The Requirement to Group Objects

• Many applications involve collections of objects:– Personal organizers.– Library catalogs.– Student-record system.

• The number of items to be stored varies.– Items added.– Items deleted.

A Personal Notebook

• Notes may be stored.• Individual notes can be viewed.• There is no limit to the number of notes.• It will tell how many notes are stored.• Explore the notebook1 project.

Class Libraries

• Collections of useful classes.• We don’t have to write everything from scratch.• Java calls its libraries, packages.• Grouping objects is a recurring requirement.

- The java.util package contains classesfor doing this.

• Java has a class library called ArrayList in java.util package

• An example (next slide)

import java.util.ArrayList;/*** ...*/public class Notebook{

// Storage for an arbitrary number of notes.private ArrayList notes;

/*** Perform any initialization required for the* notebook.*/// Notebook constructorpublic Notebook(){

notes = new ArrayList();}

Class Library (Cont.)

• The import statementimport java.util.ArrayList;

illustrates the way in which we gain access to a library class in Java.

• Import statement must always be placed before class definition in a file.

• Using ArrayList object in our class by declaring it:private ArrayList notes;

• Creating an ArrayList object:notes = new ArrayList ( );

ArrayList Methods

ArrayList class has the following methods:• add to store an element in the list

public void add (String s)• remove to remove an element from the list

public void remove (String s)• get to get an element from the list

public String get (int n)• size to return the size of the list (number of

elements)public int size ( )

Object Structures with Collections

Adding a Third Note

Features of the collection

• It increases its capacity as necessary.• It keeps a private count (size( ) accessor).• It keeps the objects in order.• Details of how all this is done are hidden.

– Does that matter? Does not knowing how prevent us from using it?

Using the Collection

public class Notebook{

private ArrayList notes;...

public void storeNote(String note){

notes.add(note);}

public int numberOfNotes(){

return notes.size();}

Adding a new note

Returning the number of notes(delegation).

Index numbering

Retrieving an Object

Index validity checks

Retrieve and print the note

public void showNote(int noteNumber){

if(noteNumber < 0) {// This is not a valid note number.

}else if(noteNumber < numberOfNotes()) {

System.out.println(notes.get(noteNumber));}else {

// This is not a valid note number.}

Removal May Affect Numbering

Review• Collections allow an arbitrary number of objects to be

stored.• Class libraries usually contain tried-and-tested collection

classes.• Java’s class libraries are called packages.• We have used the ArrayList class from the java.util

package.• Items may be added and removed.• Each item has an index.• Index values may change if items are removed (or

further items added).• The main ArrayList methods are add, get, remove and

Iteration

• We often want to perform some actions an arbitrary number of times.– E.g., print all the notes in the notebook. How

many are there?• Most programming languages include loop

statements to make this possible.• Java has three sorts of loop statement.

– We will focus on its while loop.

While Loop Pseudo Code

while(loop condition) {loop body

while(there is at least one more note to be printed) {show the next note

Boolean testwhile keyword

Statements to be repeated

Pseudo-code example to print every note

General form of a while loop

A Java Example

/*** List all notes in the notebook.*/public void listNotes(){

int index = 0;while(index < notes.size( )) {

System.out.println(notes.get(index));index++;

Increment by one

Iterating Over a Collection

• To examine every element in the collection, we need an Iterator object.

• ArrayList class provides a special way to iterate over its contents.

• The iterator method of ArrayList returns an Iterator object.

• Iterator is also defined in the java.util package, so we must add a second import statement to the class file:

import java.util.Iterator;

Iterating Over a Collection (Cont.)

• Iterator class provides two methods to iterate over collection:- hasNext to check if there are any more

objects in the list- next to get the next object from the list

java.util.Iterator

Iterator it = myCollection.iterator();while(it.hasNext()) {

call it.next() to get the next objectdo something with that object

Returns an Iteratorobject

public void listNotes(){

Iterator it = notes.iterator();while(it.hasNext()) {

System.out.println(it.next());}

• In the last code fragment, we first use the iteratormethod of the ArrayList class to obtain an iteratorobject:

Iterator it = myCollection.iterator ( );• We use that iterator (i.e. it) to repeatedly check

whether there are anymore objects while (it.hasNext ( ))

and to get the next object it.next ( )

• Note that, it is the iterator that we ask to return the next item, and not the collection.

Index Access versus Iterators

• We have seen two different ways to iterate over an ArrayList:– By using the get method of ArrayList with an index– By using an Iterator object

• For an ArrayList object, these two ways are good• But Java provides some other collection classes (to be

discussed later). For those collections, it is either impossible or inefficient to access individual elements by providing an index.

• So the second way, using an Iterator, is available for all collections in the Java class library.

The Auction Project• The auction project provides further illustration of collections

and iteration.• Two further points to follow up:

– The null value: it means “no object” (when an object variable is not currently referring to a particular object.

– Casting is commonly seen when retrieving objects from the collection. It is required because it is possible to store any type of object in a collection. Casting is needed when using the next method of an iterator, and when using the get method of collection.

e.g. casting is used to store the result of get into a variable:String message = (String) notes.get(0);Lot lot1 = (Lot) it.next ( );

Review

• Loop statements allow a block of statements to be repeated.

• A Java while loop allows the repetition to be controlled by a Boolean expression.

• Collection classes have special Iterator objects that simplify iteration over the whole collection.

Fixed-Size Collections

• Sometimes the maximum collection size can be pre-determined.

• Programming languages usually offer a special fixed-size collection type: an array.

• Java arrays can store objects or primitive-typevalues.

• Arrays use a special syntax.

Projectanalyzer-weblogThe

• Web server records details of each access.• Supports webmaster’s tasks.

– Most popular pages.– Busiest periods.– How much data is being delivered.– Broken references.

• Analyze accesses by hour.

Declaring and Creating an Array Object

public class LogAnalyzer{private int[] hourCounts;private LogfileReader reader;

public LogAnalyzer(){

hourCounts = new int[24];reader = new LogfileReader();

Array variable declaration

Array object creation

The hourCounts Array

Using an Array Object• Square-bracket notation is used to access an array element:

hourCounts[...]• An index is used to access any array element.• Using indices outside the bounds of an array will lead to

runtime error called an ArrayOutOfBoundsException.

• Elements are used like ordinary variables.– On the left of an assignment:

hourCounts[hour] = 8 ;– In an expression:

adjusted = hourCounts[hour] – 3;hourCounts[hour]++;

The for Loop

• Similar to a while loop.• Often used to iterate a fixed number of times.• Often used to iterate over an array.

For Loop Pseudo-Code

General form of a for loop

for(initialization; condition; post-body action) {statements to be repeated

Equivalent in while-loop form

initialization;while(condition) {

statements to be repeatedpost-body action

A Java Example

for loop version

for(int hour = 0; hour < hourCounts.length; hour++) {System.out.println(hour + ": " + hourCounts[hour]);

while loop version

int hour = 0;while(hour < hourCounts.length) {

System.out.println(hour + ": " + hourCounts[hour]);hour++;

Review

• Arrays are appropriate where a fixed-size collection is required.

• Arrays use special syntax.• For loops offer an alternative to while loops

when the number of repetitions is known.• For loops are often used to iterate over arrays.

Chapter 5More Sophisticated Behavior

Main concepts to be covered• Using library classes to implement some

more advanced functionality• Reading documentation• Writing documentation

The Java Class Library

• Thousands of classes• Tens of thousands of methods• Many useful classes that make life much easier• A competent Java programmer must be able to work

with the libraries.

ibraryLWorking with the

You should:• know some important classes by name;• know how to find out about other classes.

Remember:• We only need to know the interface, not the

implementation.

A Technical Support System: An Example

• As example, Use the TechSupport system which is atextual dialog system

• Its idea is based on ‘Eliza’ (the ground-breaking artificial intelligence program) developed by Joseph Weizenbaum (MIT, 1960s)

• It provides technical support for customers of the fictitious DodgySoft software company.

• Customers can communicate with the technical support system online.

A Technical Support System: An Example

• The project has three classes:- SupportSystem (the main class)- InputReader- Responder

• SupportSystem uses- InputReader to get some input from the terminal- Responder to generate a response

Main Loop Structure in Class SupportSystem

boolean finished = false;

while(!finished) {

do something

if(exit condition) {finished = true;

}else {

do something more}

Main Loop Body in Class SupportSystem

String input = reader.getInput();...String response = responder.generateResponse();System.out.println (response);

• The loop repeatedly - reads some user input- asks the responder to generate a response- prints out that response

The Exit Condition in Class SupportSystem

String input = reader.getInput();

if (input.startsWith ("bye")) {finished = true;

• Where does ‘startsWith’ come from? (from classString)

• What is it? What does it do?• How can we find out?

Reading Class Documentation

• Documentation of the Java libraries in HTML format;• Readable in a web browser• Class API: Application Programmers’ Interface• Interface description for all library classes

Interface Versus Implementation

The documentation includes• the name of the class;• a general description of the class;• a list of constructors and methods• return values and parameters for

constructors and methods• a description of the purpose of each

constructor and method

the interface of the class

Interface Versus Implementation (Cont.)

The documentation does not include

• private fields (most fields are private)• private methods• the bodies (source code) for each method

the implementation of the class

Using Library Classes

• Classes from the library must be imported using an import statement (except classes from java.lang).

• They can then be used like classes from the current project.

Packages and Import

• Classes are organised in packages.• Single classes may be imported:

import java.util.ArrayList;

• Whole packages can be imported:

import java.util.*;

Side Note: String Equality

if(input == "bye") { tests identity...

}if(input.equals("bye")) { tests equality

• Strings should (almost) always be compared with.equals

Identity Versus Equality 1

Other (non-String) objects:

person1 == person2 ?

“Fred”

:Person

person1 person2

“Jill”

:Person

“Fred”

:Person

person1 person2

“Fred”

:Person

“Fred”

:Person

person1 person2

“Fred”

:Person

Identity Versus Equality (Strings)

:String

String input = reader.getInput();if(input == "bye") {

== tests identity

(may be) false!

Identity vs Eequality (Strings)

:String

String input = reader.getInput();if(input.equals("bye")) {

equals tests equality

equals ?

Using Random

• The library class Random can be used to generate random numbers

import java.util.Random;...Random randomGenerator = new Random();...int index1 = randomGenerator.nextInt();int index2 = randomGenerator.nextInt(100);

Generating Random Responses

public Responder(){

randomGenerator = new Random();responses = new ArrayList();fillResponses();

public String generateResponse(){

int index = randomGenerator.nextInt(responses.size());return (String) responses.get(index);

public void fillResponses()...

• Maps are collections that contain pairs of values.• Pairs consist of a key and a value.• Lookup works by supplying a key, and retrieving a

value.• An example: a telephone book.

Using Maps

• A map with Strings as keys and values

"Charles Nguyen"

:HashMap

"(531) 9392 4587"

"Lisa Jones" "(402) 4536 4674"

"William H. Smith" "(998) 5488 0123"

Using Maps

HashMap phoneBook = new HashMap();

phoneBook.put("Charles Nguyen", "(531) 9392 4587");phoneBook.put("Lisa Jones", "(402) 4536 4674");phoneBook.put("William H. Smith", "(998) 5488

0123");

String number = (String)phoneBook.get("Lisa Jones");System.out.println(number);

Using Setsimport java.util.HashSet;import java.util.Iterator;...HashSet mySet = new HashSet();

mySet.add("one");mySet.add("two");mySet.add("three");

Iterator it = mySet.iterator();while(it.hasNext()) {

call it.next() to get the next objectdo something with that object

Compare this to ArrayListcode!

Tokenizing Stringspublic HashSet getInput() {

System.out.print("> "); String inputLine =

readInputLine().trim().toLowerCase();

StringTokenizer tokenizer = new StringTokenizer(inputLine);

HashSet words = new HashSet();

while(tokenizer.hasMoreTokens()) {words.add(tokenizer.nextToken());

}return words;

Writing Class Documentation

• Your own classes should be documented the same way library classes are.

• Other people should be able to use your class without reading the implementation.

• Make your class a 'library class'!

Elements of Documentation

Documentation for a class should include:• the class name• a comment describing the overall purpose and

characteristics of the class• a version number• the authors’ names• documentation for each constructor and each method

Elements of Documentation

The documentation for each constructor and method should include:

• the name of the method• the return type• the parameter names and types• a description of the purpose and function of the

method• a description of each parameter• a description of the value returned

javadocClass comment:

/*** The Responder class represents a response* generator object. It is used to generate an * automatic response.* * @author Michael Kölling and David J. Barnes* @version 1.0 (1.Feb.2002)*/

javadoc

Method comment:/*** Read a line of text from standard input (the text terminal), and* return it as a set of words.** @param prompt A prompt to print to screen.* @return A set of Strings, where each String is* one of the words typed by the user*/

public HashSet getInput(String prompt) {

Public Versus Private

• Public attributes (fields, constructors, methods) are accessible to other classes.

• Fields should not be public.• Private attributes are accessible only within the same

class.• Only methods that are intended for other classes

should be public.

Information Hiding

• Data belonging to one object is hidden from other objects.

• Know what an object can do, not how it does it.• Information hiding increases the level of

independence.• Independence of modules is important for large

systems and maintenance.

Class Variables

Constants

private static final int gravity = 3;

• private: access modifier, as usual• static: class variable• final: constant

Review

• Java has an extensive class library.• A good programmer must be familiar with the library.• The documentation tells us what we need to know to

use a class (interface).• The implementation is hidden (information hiding).• We document our classes so that the interface can be

read on its own (class comment, method comments).

Improving Structure With Inheritance

• Main Concept to cover:

• Inheritance• Subtyping• Substitution• Polymorphic variables

The DoME Example

"Database of Multimedia Entertainment"

• stores details about CDs and videos– CD: title, artist, # tracks, playing time, got-it,

comment– Video: title, director, playing time, got-it,

comment• allows (later) to search for information or print

ObjectsDoME

ClassesDoME

DoME Object Model

Class Diagram

CD source code

public class CD {private String title;private String artist;private String comment;

CD(String theTitle, String theArtist){

title = theTitle;artist = theArtist;comment = " ";

void setComment(String newComment){ ... }

String getComment(){ ... }

void print(){ ... }...

incomplete(comments!)[ ]

Video source code

public class Video {private String title;private String director;private String comment;

Video(String theTitle, String theDirect){

title = theTitle;director = theDirect;comment = " ";

void setComment(String newComment){ ... }

String getComment(){ ... }

void print(){ ... }...

incomplete(comments!)[ ]

class Database {

private ArrayList cds;private ArrayList videos;...

public void list(){

for(Iterator iter = cds.iterator(); iter.hasNext(); ) {CD cd = (CD)iter.next();cd.print();System.out.println(); // empty line between items

for(Iterator iter = videos.iterator(); iter.hasNext(); ) {Video video = (Video)iter.next();video.print();System.out.println(); // empty line between items

Database Source Code

DoMECritique of

• code duplication– CD and Video classes very similar (large parts are

identical)– makes maintenance difficult / more work– introduces danger of bugs through incorrect

maintenance• code duplication also in Database class

Using Inheritance

• define one superclass : Item

• define subclasses for Video and CD

• the superclass defines common attributes

• the subclasses inherit the superclass attributes

• the subclasses add own attributes

Inheritance Hierarchies

Inheritance in Java

public class Item{

public class CD extends Item{

public class Video extends Item {

no change here

change here

Superclass

public class Item{

private String title;private int playingTime;private boolean gotIt;private String comment;

// constructors and methods omitted.}

Subclasses

public class CD extends Item{

private String artist;private int numberOfTracks;

public class Video extends Item {

private String director;

public class Item{

private String title;private int playingTime;private boolean gotIt;private String comment;

/*** Initialise the fields of the item.*/public Item(String theTitle, int time){

title = theTitle;playingTime = time;gotIt = false;comment = "";

// methods omitted}

Inheritance and Constructors

Inheritance and Constructors (Cont.)public class CD extends Item{

private String artist;private int numberOfTracks;

/*** Constructor for objects of class CD*/public CD(String theTitle, String theArtist,

int tracks, int time){ //call superclass constructor

super(theTitle, time);artist = theArtist;numberOfTracks = tracks;

}// methods omitted

Superclass Constructor Call

• Subclass constructors must always contain a 'super' call.

• If none is written, the compiler inserts one (without parameters)– works only, if the superclass has a constructor

without parameters• Must be the first statement in the subclass

constructor.

Adding More Item Types

Deeper Hierarchies

Review (so far)

Inheritance (so far) helps with:• Avoiding code duplication• Code reuse• Easier maintenance• Extendibility

public class Database{ private ArrayList items;

/*** Construct an empty Database.*/public Database(){

items = new ArrayList();}/*** Add an item to the database.*/public void addItem(Item theItem){

items.add(theItem);}...

New Database Source Code

avoids code duplication in client!

/*** Print a list of all currently stored CDs and* videos to the text terminal.*/public void list(){

for(Iterator iter = items.iterator(); iter.hasNext(); ){

Item item = (Item)iter.next();item.print();System.out.println(); // empty line between items

New Database Source Code (Cont.)

Subtyping

First, we had:public void addCD(CD theCD)public void addVideo(Video theVideo)

Now, we have:public void addItem(Item theItem)

We call this method with:Video myVideo = new Video(...);database.addItem(myVideo);

Subclasses and Subtyping

• Classes define types.• Subclasses define subtypes.• Objects of subclasses can be used where

objects of supertypes are required.(This is called substitution .)

Subtyping and Assignment

Vehicle v1 = new Vehicle();Vehicle v2 = new Car();Vehicle v3 = new Bicycle();

subclass objects may be assigned to superclass variables

Subtyping and Parameter Passing

public class Database{

public void addItem(Item theItem){

Video video = new Video(...);CD cd = new CD(...);

database.addItem(video);database.addItem(cd);

subclass objects may be passed to superclass parameters

Object iagram

Object Diagram

Class Diagram

Polymorphic Variables

• Object variables in Java are polymorphic.

(That is, They can hold objects of more than one type)

• They can hold objects of the declared type, or of subtypes of the declared type.

The Object Class

All classes inherit from Object.

Polymorphic Collections

• All collections are polymorphic.• The elements are of type Object.

public void add(Object element)

public Object get(int index)

Casting Revisited

• Can assign subtype to supertype.• Cannot assign supertype to subtype!

String s1 = myList.get(1); error!

• Casting fixes this:String s1 = (String) myList.get(1);

(only if the element really is a String!)

Wrapper Classes

• All objects can be entered into collections...• ...because collections accept elements of type

Object...• ...and all classes are subtypes of Object.• Great! But what about simple types?

Wrapper Classes (Cont.)

• Simple types (int, char, etc) are not objects. They must be wrapped into an object!

• Wrapper classes exist for all simple types:

simple type wrapper classint Integerfloat Floatchar Character... ...

Wrapper Classes (Cont.)

int i = 18; Integer iwrap = new Integer(i);

myCollecton.add(iwrap);...

Integer element = (Integer) myCollection.get(0);int value = element.intValue()

wrap the int value

add the wrapper

retrieve the wrapper

unwrap

Review

• Inheritance allows the definition of classes as extensions of other classes.

• Inheritance – avoids code duplication– allows code reuse– simplifies the code– simplifies maintenance and extending

• Variables can hold subtype objects.• Subtypes can be used wherever supertype objects are

expected (substitution).

Chapter 9: More About InheritanceExploring Polymorphism

Main concepts to be covered• Method Polymorphism• Static and Dynamic Type• Overriding• Dynamic Method Lookup• Protected Access

The Inheritance Hierarchy

Conflicting Output

CD: A Swingin' Affair (64 mins)*Frank Sinatratracks: 16my favourite Sinatra album

video: The Matrix (136 mins)Andy & Larry Wachowskimust see if interested in virtual reality!

title: A Swingin' Affair (64 mins)*my favourite Sinatra album

title: The Matrix (136 mins)must see if interested in virtual reality!

What we want

What we now have

The Problem

• The print method in Item class only prints the common fields.

• Inheritance is a one-way street:– A subclass inherits the superclass fields.– The superclass knows nothing about its

subclass’s fields.

Attempting to Solve The Problem

• Place print where it has access to the information it needs.

• Each subclass has its own version.

• But Item’s fields are private.

• Database cannot find a print method in Item.

Attempting to Solve The Problem

In the previous model there are some errors:1) The subclass cannot access the supper class fields:

Reason: they are declared as privateSolution:

- define public accessor methods for them, since wedo not want to break encapsulation and make thesevariables public

- other solution will be discussed later

(2) Database class cannot find the print methodSolution: see next slides

Static Type and Dynamic Type

• A more complex type hierarchy requires further concepts to describe it.

• Some new terminology:– static type– dynamic type– method dispatch/lookup

Static and Dynamic Type

Car c1 = new Car();What is the type of c1?

Vehicle v1 = new Car();What is the type of v1?

Static and Dynamic Type (Cont.)• The declared type of a variable is its static type, because it is declared in the source code

• The type of the object a variable refers to is its dynamic type, because it depends on assignments at runtime.

• The compiler’s job is to check for static-type violations.Item item = (Item) iter.next();item.print(); // Compile-time error.

(This is because the static type of item is Item, while the dynamic type is either CD or Video. We do not know which one of these it is.)

Overriding: The Solution

print method in both super-and subclasses.

Satisfies both static and

dynamic type checking.

The print Method in Super and Sub Classes

public class Item{ …

public void print ( ){ System.out.println (title+“ (“ + playingTime + “ mins}”);

if (gotIt){System.out.println ( “ * “ ); }

else{System.out.println (“ “ + comment); }

The print Method in Super and Sub Classes

public class CD extends Item{ public void print ( )

{ System.out.println (“ “ + artist);System.out.println (“ tracks: “ + numberOf

Tracks);}

public class Video extends Item{ public void print ( )

{ System.out.println (“ “ + director); }}

Overriding

• Superclass and subclass define methods with the same signature.

• Each has access to the fields of its class.• Superclass satisfies static type check.• Subclass method is called at runtime – it overrides

the superclass version.• What becomes of the superclass version?

Method Lookup

No inheritance or polymorphism.The obvious method is selected.

Method Lookup (Cont.)

Inheritance but no overriding. The inheritance

hierarchy is ascended, searching for a match.

Method Lookup (Cont.)

Polymorphism and overriding. The ‘first’version found is used.

Method Lookup Summary

• The variable is accessed.• The object stored in the variable is found.• The class of the object is found.• The class is searched for a method match.• If no match is found, the superclass is searched.• This is repeated until a match is found, or the class

hierarchy is exhausted.• Overriding methods take precedence.

Super Call in Methods

• Overridden methods are hidden ...• ... but we often still want to be able to call them.• An overridden method can be called from the

method that overrides it.– super.method(...)– Compare with the use of super in constructors.

Calling an Overridden Method

public class CD{

...public void print(){

super.print();System.out.println(" " + artist);System.out.println("tracks: " +

numberOfTracks);}...

Method Polymorphism

• We have been discussing polymorphic methoddispatch.

• A polymorphic variable can store objects of varying types.

• Method calls are polymorphic.– The actual method called depends on the

dynamic object type.

The Object Class’s Methods

• Methods in Object are inherited by all classes.• Any of these may be overridden.

• The toString method of Object is commonly overridden:– public String toString()– Returns a string representation of the object.

Overriding toString Methodpublic class Item{

...public String toString(){ String line1 = title +

" (" + playingTime + " mins)"); if(gotIt) {

return line1 + "*\n" + " " +comment + "\n");

} else {return line1 + "\n" + " " +

comment + "\n");}

Overriding toString Method (Cont.)

• Explicit print methods can often be omitted from a class:– System.out.println(item.toString());

• Calls to println with just an object automatically result in toString being called:– System.out.println (item);

Protected Access

• Private access in the superclass may be too restrictive for a subclass.

• The closer inheritance relationship is supported by protected access.

• Protected access is more restricted than public access.

• We still recommend keeping fields private.– Define protected accessors and mutators.

Access Levels

Review

• The declared type of a variable is its static type.– Compilers check static types.

• The type of an object is its dynamic type.– Dynamic types are used at runtime.

• Methods may be overridden in a subclass.• Method lookup starts with the dynamic type.• Protected access supports inheritance.

Chapter 10:Further Abstraction TechniquesAbstract Classes and Interfaces

Main concepts to be covered:• Abstract classes• Interfaces• Multiple inheritance

Simulations

• Programs regularly used to simulate real-world activities.– city traffic– the weather– nuclear processes– stock market fluctuations– environmental changes

• They are often only partial simulations.• They often involve simplifications.

– Greater detail has the potential to provide greater accuracy.– Greater detail typically requires more resource.

• Processing power.• Simulation time.

Benefits of Simulations

• Support useful prediction.– The weather.

• Allow experimentation.– Safer, cheaper, quicker.

• Example:– ‘How will the wildlife be affected if we cut a

highway through the middle of this national park?’

Predator-Prey Simulations• Such simulations are often used to model the

variation in population sizes that result from a predator species feeding on a prey species.

• There is often a delicate balance between species.– A lot of prey means a lot of food.– A lot of food encourages higher predator numbers.– More predators eat more prey.– Less prey means less food.– Less food means ...

The Foxes-and-Rabbits Project

Main Classes of Interest

• Fox– Simple model of a type of predator.

• Rabbit– Simple model of a type of prey.

• Simulator– Manages the overall simulation task.– Holds a collection of foxes and rabbits.– Performs a sequence of steps.– In each step, each fox and each rabbit is allowed to

move. After each step, the current state if the field is displayed on screen.

The Remaining Classes• Field

– Represents a 2D field. It is composed of a fixed number of locations (arranged in rows and columns)

– At most one animal may occupy a single location within the field.• Location

– Represents a 2D position within the field. Its position is determined by a row and a column value.

• SimulatorView, FieldStats, Counter- Maintain statistics and present a view of the field.

• SimulatorView:- provides a graphical visualization of the state of the field (see next slide).

• FieldStats- provides counts of the numbers of foxes & rabbits in the field to the visualization.

• Counter- stores a current count for one type of animal to assist with the counting.

Example of The Visualization

A Rabbit’s State

public class Rabbit{ Static fields omitted.

// Individual characteristics (instance fields).// The rabbit's age.private int age;// Whether the rabbit is alive or not.private boolean alive;// The rabbit's positionprivate Location location;

Method omitted.}

A Rabbit’s Behavior

• Managed from the run method.• Age incremented at each simulation ‘step’.

– A rabbit could die at this point.• Rabbits that are old enough might breed at each step.

– New rabbits could be born at this point.

Rabbit Simplifications

• Rabbits do not have different genders.– In effect, all are female.

• The same rabbit could breed at every step.• All rabbits die at the same age.• Others?

A Fox’s State

public class Fox{ Static fields omitted

// The fox's age.private int age;// Whether the fox is alive or not.private boolean alive;// The fox's positionprivate Location location;// The fox's food level, which is increased by eating// rabbits.private int foodLevel;

Methods omitted.}

A Fox’s Behavior

• Managed from the hunt method.• Foxes also age and breed.• They become hungry.• They hunt for food in adjacent locations.

Configuration of Foxes

• Similar simplifications to rabbits.• Hunting and eating could be modeled in many

different ways.– Should food level be additive?– Is a hungry fox more or less likely to hunt?

• Are simplifications ever acceptable?

The Simulator Class

• Three key components:– Setup in the constructor.– The populate method.

• Each animal is given a random starting age.– The simulateOneStep method.

• Iterates over the population.• Two Field objects are used: field and updatedField.

The Update Stepif (animal instanceof Rabbit){ Rabbit rabbit = (Rabbit) animal;

if (rabbit.isAlive ( ) ) { rabbit.run (updatedField, newAnimals); }else{ iter.remove ( ); }

}else if (animal instanceof Fox) { Fox fox = (Fox) animal;

if (fox.isAlive ( ) ){ fox.hunt (field, updatedField, newAnimals); }else{ iter.remove ( ); }

Room for Improvement

• Fox and Rabbit have strong similarities but do nothave a common superclass.

• The Simulator is tightly coupled to specific classes.– It ‘knows’ a lot about the behavior of foxes and

rabbits.

The Animal Superclass

• Place common fields in Animal:– age, alive, location

• Method renaming to support information hiding:– run and hunt become act.

• Simulator can now be significantly decoupled.

Revised (Decoupled) Iteration

for(Iterator iter = animals.iterator(); iter.hasNext(); )

{ Animal animal = (Animal)iter.next();if(animal.isAlive()) { animal.act(field, updatedField,

newAnimals);}else{ iter.remove(); }

The Act Method of Animal• Static type checking requires an act method in Animal.

• There is no obvious shared implementation.• Define act as abstract:

abstract public void act( Field currentField,Field updatedField,List newAnimals);

Abstract Classes and Methods

• Abstract methods have abstract in the signature.• Abstract methods have no body.• Abstract methods make the class abstract.• Abstract classes cannot be instantiated.• Concrete subclasses complete the implementation.

The Animal Class

public abstract class Animal{ fields omitted

/*** Make this animal act - that is: make it do* whatever it wants/needs to do.*/abstract public void act ( Field currentField,

Field updatedField,List newAnimals);

other methods omitted}

Further Abstraction

Selective Drawing(Multiple Inheritance)

Multiple Inheritance

• Having a class inherit directly from multiple ancestors.

• Each language has its own rules.– How to resolve competing definitions?

• Java forbids it for classes.• Java permits it for interfaces.

– No competing implementation.

An Actor Interface

public interface Actor{ /**

* Perform the actor's daily behavior.* Transfer the actor to updatedField if it is to participate in* further steps of the simulation.* @param currentField The current state of the field.* @param location The actor's location in the field.* @param updatedField The updated state of the field.*/void act ( Field currentField, Location location,

Field updatedField);}

Classes Implement an Interface

public class Fox extends Animal implements Drawable{

public class Hunter implements Actor, Drawable{

Interfaces as Types

• Implementing classes do not inherit code, but ...• ... implementing classes are subtypes of the interface

type.• So, polymorphism is available with interfaces as well

as classes.

Interfaces as Specifications

• Strong separation of functionality from implementation.– Though parameter and return types are mandated.

• Clients interact independently of the implementation.– But clients can choose from alternative

implementations.

Alternative Implementations

Review

• Inheritance can provide shared implementation.– Concrete and abstract classes.

• Inheritance provides shared type information.– Classes and interfaces.

• Abstract methods allow static type checking without requiring implementation.

• Abstract classes function as incomplete superclasses.– No instances.

• Abstract classes support polymorphism.

Interfaces

• Interfaces provide specification without implementation.– Interfaces are fully abstract.

• Interfaces support polymorphism.• Java interfaces support multiple inheritance.

Object-Oriented Programming (721112) - Philadelphia

Documents

CS 3050 Object-Oriented Analysis and Design. Objectives What is “Object-Oriented?” Object-Oriented Approach Vs. Structured Approach How Has the Object-Oriented

OBJECT ORIENTED PROGRAMMING · UML Notation . . . 40 16. CRC Cards . . . 46 17. Object Oriented Class Relationships . . . 47 18. Object Oriented Aggregation . . . 48 19. Object Oriented

Object-Oriented Systems Engineering (OOSE), the Object ... · Object-Oriented Systems Engineering (OOSE), the Object- ... • “OOSEM is also intended to ease integration with object-oriented

Object-Oriented Analysis (OOA) Object-Oriented Analysisdigital.cs.usu.edu/~xqi/Teaching/CS2450F08/Notes/Ch12.OOA.pdf · 1 1 Object-Oriented Analysis Xiaojun Qi 2 Object-Oriented Analysis

Object-oriented programming • Visual Basic for ...faculty.umb.edu/david.tenenbaum/eeos472/eeos472-midtermreview.pdf · Object-oriented programming • Object-oriented programming

Object Oriented Methodologies J.N.Kotuba SYST39409 - Object Oriented Methodologies 1

Introduction of Object-Oriented Programming Object ...courses/coe808/Truman/Lecture20.pdf · Introduction of Object-Oriented Programming Object-Oriented Programming in Java Object-Oriented

Object-oriented Programming with PHP · Object-oriented Programming with PHP [2 ] Object-oriented programming Object-oriented programming is a popular programming paradigm where concepts

Object-Oriented Programme 1 SSD3: Object-Oriented Programming and Design

Developing Object-Oriented PHP. PHP-Object Oriented Programming2 Object-Oriented Programming Object-oriented programming (OOP) refers to the creation

Object Oriented Programming and Object Oriented Design

12. Object-oriented Design - Aalborg Universitetkom.aau.dk/~dimon/old-control/teaching/Object-oriented-design.pdf · 2 Object-oriented Design ©Ian Sommerville 2000 Object-oriented

7. Object-Oriented Programming - HMC Computerkeller/cs60book/ 7 Object-Oriented.pdf · 7. Object-Oriented Programming 7.1 Introduction This chapter describes object-oriented computing

Object-oriented design CSE 432: Object-Oriented Software Engineering

Module 3 Object Oriented Data Models Object Oriented notations

Object-Oriented Application Development in CAD · of object-oriented application development in general and ... Using object-oriented design, ... The course is called Object-Oriented

mysarkarinaukri.com€¦ · Unit 4: Programming and Object Oriented Programming Object Oriented Paradigm: Structured vs object oriented development, elements of object oriented programming,

Object-Oriented Programming (721112) - Philadelphia University Files/cs/721112le.pdf · Object-Oriented Programming (721112) A Core Module for Students in CS, CIS, SE, ACS Departments

COS 240 Object-Oriented Languages 5.1 Object-Oriented Design Object-oriented thinking begins with object-oriented design

Introduction to Object Oriented Programming · 2020. 9. 12. · Introduction to Object Oriented Programming: Object-oriented vs Procedure-oriented Programming languages: 1. Object-oriented