Transcript Lecture 1 - GEOCITIES.ws

Comp 5421 Object Oriented Programming
What is Object Oriented Design?
Lecture 1
Tianxiang Shen
Summer 2002
Department of Computer Science
Concordia university
Concordia TAV 2002 Comp5421_1
1
Project
• The main practical component of the course is a
project that you will complete as a member of a team.
• Each team will consist of five or six team members.
• Each team may propose a project, or choose one
from Dr. Grogono’s project list:
www.cs.concordia.ca/~faculty/grogono/projects.html.
In either case, you must submit a project proposal to
the instructor before proceeding.
Concordia TAV 2002 Comp5421_1
2
Project
• The project consists of six components, each
with its own marks, as shown in the following
table.
1 User Manual
2 Design Document
3 Implementation Notes
10%
15%
10%
4 Source Code
5 Demonstration
6 Individual Report
20%
20%
20%
Concordia TAV 2002 Comp5421_1
3
Project (cont.)
• Items 1 through 5 are submitted by the team.
Everyone in the team will get the same marks
for these items. I will give different marks to
team members for one or more items only if I
receive a written request signed by all team
members.
• Item 6 is submitted by individual team
members. This document will be used to
assess your individual contribution to the
project.
Concordia TAV 2002 Comp5421_1
4
Description of Project Components (cont.)
1.
The User Manual describes the external attributes of
the software in such a way that anyone can use the
program. (marking by Lab Instructor)
2.
The Design Document includes the high-level design
and the detailed design of the software. You can use
diagrams, text, or both.
3.
The Implementation Notes describe: the
implementation plan; the test plan; test results; problems
that you encountered and how you solved them;
comments on the good/bad features of the language,
platform, GUI, etc., that you used; anything else that you
think is worth reporting.
Concordia TAV 2002 Comp5421_1
5
Description of Project Components (cont.)
4.
Source Code should be complete; it should be
formatted properly with appropriate indentation and
spacing; and it should contain useful comments.
5.
Demonstration is a meeting of the entire team with
the instructor in front of a computer. We will run the
software and discuss the project. (Marking by Lab
Instructor)
6.
Individual Report describes: your role in the
project; your interactions with other team members;
problems you encountered with team work (if any)
and how you solved them; your assessment of the
contributions of team members - your own and the
others; and what you learned by doing this project.
Concordia TAV 2002 Comp5421_1
6
Project Schedule
• Week 1:
Team set up.
• Week 3:
Submit proposal.
• Week 5:
Submit design document.
• Week 12:
Demonstration
• Week 13:
Final Submission
Concordia TAV 2002 Comp5421_1
7
Object Oriented Programming
(1)
Introduction
Of
Object Oriented Design
Concordia TAV 2002 Comp5421_1
8
Phases of Software Development (cont.)
Waterfall Model
System
requirements
engineering
System requirements specification
Software
requirements
engineering
Software requirements specification
Software design specification
Software
design
Programming
and unit testing
Executable software system
Completed system
System testing
System
operation
Concordia TAV 2002 Comp5421_1
9
Phases of Software Development (cont.)
•
Requirement analysis is to find out what the program is
expected to do (application domain)
•
Specification is precise description of what the
program is supposed to do (but not how it works); it
bridges application domain and implementation domains
since it describes the external behavior of the system.
(can be viewed as a contract)
•
Design is precise description of internal structures. OOD
is usually a description of the class and the their
interactions. It is most important phase, if good
design, then implementation should be straightforward,
otherwise, the project may fail together.
Concordia TAV 2002 Comp5421_1
10
Phases of Software Development (cont.)
• Implementation: writing code (programming)
• Testing: To ensure that the finished program meets
its specification
• Documentation: User manual for users. Updated
design, specification, and requirements documents
• Demonstrations: Trade shows and Marketing efforts,
etc.
• Revisions & Versions: Incorporate new features,
enhancements, suggestions, correct any bugs, etc.
Concordia TAV 2002 Comp5421_1
11
Example of Object Oriented Design
Description
You are to write a program that simulates a solar system. The program will accept
as input the initial location, mass, and velocity of the sun, each of the planets and
their moons, and some set of asteroids and comets. The program should then
simulate the specified solar system in action by repeatedly computing the next
position of each of the specified bodies over a period ranging from hundreds to
millions of years. The only force you need consider is the gravitational attraction
between bodies. Do not worry about collisions.
A solar system can be comprised of about one hundred bodies. The simulation
of these bodies will proceed in discrete time steps. At each time step the total
gravitational force on each body is computed by summing the gravitational attraction
between that body and all other bodies.
Then, using the current
position, velocity, and this accumulated force, the next position is found. To
make the computation more tractable given the large number of bodies, the
bodies are grouped hierarchically into subsystems. This sharply reduces the
number of necessary gravity computations at a small cost in accuracy. For
example, in our solar system Jupiter and all its moons are considered as a single
subsystem when computing its attraction with the distant Earth.
Concordia TAV 2002 Comp5421_1
12
Example of Object Oriented Design
•
•
Solar system simulation: an example of a
continuous simulation.
Requirements:
1. Simulate motion of the sun, planets, satellites
and a few other assorted objects;
2. Simulation should run faster than real time;
3. Output of the simulation should be graphical
display of the solar system with facilities like
scaling, zooming, etc.
Concordia TAV 2002 Comp5421_1
13
Solar system simulation
• Specification:
Provide a way of setting-up the initial conditions of
simulation: mass, position, and velocity at a particular
time;
Start from these initial condition, use Newton’s laws to
compute position and velocity of each body at subsequent
times.
First-order approximations are sufficient.
Note: This is not a complete specification, in more detail
later on.
Concordia TAV 2002 Comp5421_1
14
Review Physics
Newton’s Law:
• 1st Law:
If net (resultant) force acting on an body is zero,
the velocity of an body does not change.
•
2nd Law:
If net force acting on an body is not zero, the body
will be accelerated in the direction of the force;
F = M  a = M  P"
• 3rd Law:
If body A exerts a force FBA on a body B, the
second body exerts an equal and opposite force on the first.
(Action equals reaction for quantity)
Concordia TAV 2002 Comp5421_1
15
Review Physics (cont.)
• Newton’s Law of Gravitation:
Any two particles 1 and 2 attract each other with a force
F1,2 = G  M1  M2 / d2
where G is a universal gravitational constant
G = 6.672 X 10-11 N · m2/kg 2
d is distance between them
• Let F i k be gravitational force on body i by body k, then total
gravitational force:
Fi=  F ik
ik
• Position pi, Newton's 2nd law:
mi d2Pi / dt2 = F i
Concordia TAV 2002 Comp5421_1
16
Review Physics (cont.)
• When an object moves with constant speed around a
circle, the object is acted by a force, it is called
centripetal force.
F = M X V2 / R
Note: The centripetal force on satellites is the
gravitational force.
Concordia TAV 2002 Comp5421_1
17
Review Physics (cont.)
•
•
•
Rewrite F=M*A into orthogonal components parallel to X, Y, Z axes:
x“ = Fx / M, y“ = FY / M, z“ = Fz / M
To first-order approximation (by specification of the problem)
x’ (t) = [ x(t + t) – x(t) ] / t
x(t + t) = x(t) + x’(t) t
Similarly,
x’(t + t) = x’(t) + x’’(t) t
Note: Taylor Series:
x(t+t)=x(t)+ x’(t)t+ x’’(t)/2! (t)2 +···+ x(n-1)(t)/(n-1)! (t)n-1 + Rn
where Remainder Rn = x (n)()/(n)! (t)n
(  lies between t and t+ t )
Concordia TAV 2002 Comp5421_1
18
Review Physical (cont.)
• Linear Momentum of an object:
a vector P, defines as
P=mV
• Law of conservation of linear momentum:
If the system is closed, and isolated, then the total
linear momentum  Pi = constant.
Concordia TAV 2002 Comp5421_1
19
Units
• Astronomical units are either very large or very small.
To avoid this problem, we use arbitrary units.
• Consider two-body system (sun s, planet p):
Mass of sun:
Mass of planet:
Radius of orbit:
Orbital velocity:
Ms= 20,
M p= 1,
R = 20,
V = 50.
• Gravitational force between sun and planet must
balance with “centrifugal force” acting on the planet:
G Ms Mp / R2 = Mp V2 / R
Concordia TAV 2002 Comp5421_1
20
Units (cont.)
• Modified gravitation constant G in our arbitrary units
will be:
G = V2 R / Ms = 502 X 20 / 20 = 2500 (units)
• Say, t =0.01, then the distance moved in one step
is v t = 0.5 (unit).
Number of steps needed to orbit once:
2  R / (V t ) = 80   250
• This is a reasonable choice between speed and
precision.
Concordia TAV 2002 Comp5421_1
21
Subsystems
• Subsystems reduce the amount of computation.
• Consider the system with: the Sun, the Earth, the Moon,
the planet Jupiter with its 11 major satellites. Then, the
total interactions are 105.
• The effect of Jupiter's satellites on the Earth is negligible.
 Consider only 3 subsystems: the Sun, the Earth &
Moon, the Jupiter & 11 planets.
• Sun's 3 interactions + 1 interaction within Earth/Moon + 66
interactions within Jupiter subsystem  A total of 70
interactions.
Concordia TAV 2002 Comp5421_1
22
Object Oriented Design
• Describe a solution to a problem in terms of real
world objects (of a class) that behave in the
same way (member data & member functions /
methods).
• Identify methods (not its actual implementation).
• Understand how one object of a class interacts
with other object of the same or other class.
• OO design identifies all classes and interactions.
Concordia TAV 2002 Comp5421_1
23
Identifying Classes
•
Finding potential classes (from noun):
Attraction, body, force, moon, number, position,
program, solar system, subsystem, and velocity
•
Choosing top-level classes:
1. minimum subset of the classes is sufficient to
describe a solution
2. Classes & instances:
Solar system (unique instance)
Subsystem (Earth/ Moon, etc.)
Body
(Sun, Earth, Moon, etc.)
Concordia TAV 2002 Comp5421_1
24
Attributes
• Attributes:
Solar system has a set of components (subsystem or body);
subsystem has a set of components, mass, current position,
current velocity;
Body has a mass, current position, current velocity.
• Note:
Mass of a subsystem is the total mass of its components.
Position and velocity of a subsystem are actually the position and
velocity of the center of mass of its components.
Position and velocity of a body that is a component of a subsystem
are relative to the center of mass of the system.
Concordia TAV 2002 Comp5421_1
25
Methods
• Constructor for each object.
• Update() to update position and velocity at time t
to position and position at t+t.
• To tell an object the total force on it, two ways:
1. setForce();
2. clearForce() to set the force to zero, and
addForce() to add a force to current force.
Concordia TAV 2002 Comp5421_1
26
Methods
(cont.)
• setForce() needs all forces on the object to be summed
externally to the object, whereas object itself sums forces
with clearForce() and addForce().
• Which approach is better? It's a design choice.
• Let us assume to use clearForce(), addForce().
• Unique solar system object first sends clearForce() to all its
components and then, for each pair of components i and k
with ik, sends addForce(Fik) to component i, and
addForce(-Fik) to component k. Likewise for each
subsystem.
• display() for an object to write a message or update a
graphical image
Concordia TAV 2002 Comp5421_1
27
Class Vector
• Position, Velocity and Acceleration are all vector
quantities. We introduce class Vector to represent
them.
• Advantage of class vector is that we can overload
standard operators to act on vectors.
For example, to update a position, we write simply
pos += pos + vel * t
where
operator+= and operator+ defined for vectors
operator* defined to multiply a vector by a
scalar.
Concordia TAV 2002 Comp5421_1
28
Designing Class Body
•
Attribute (data member) of class Body.
class Body {
public:
private:
double mass;
Vector pos;
Vector vel;
Vector acc;
Vector force; }
Concordia TAV 2002 Comp5421_1
29
Designing Class Body
(cont.)
• Constructor provides initial values for mass,
position and velocity, and default values for
acceleration and force.
Body: :Body(double iMass, Vector iPos, Vector iVel)
{
mass = iMass;
pos = iPos;
vel = iVel;
acc = Vector();
// assignment operator &
force = Vector();
// construct a zero vector
}
Concordia TAV 2002 Comp5421_1
30
Designing Class Body
(cont.)
• update() method updates the state of a body.
void Body::update (const double DT)
{
acc = force / mass;
vel += acc * DT;
pos += vel * DT;
}
// multiply & divide a vector by a scalar,
// operator+= for vectors
Concordia TAV 2002 Comp5421_1
31
Designing Class Body
(cont.)
// Update for the whole system
void update(double DT)
{
int a, b;
for (a = 0; a < numbodies; a++)
bods [a] - >clear Force();
for ( a = 0; a < numBodies; a++)
for (b = a + 1; b < numBodies; b++)
{
Vector sep = bods [a]->getPos() – bods [b]->getPos ();
Vector dir = sep.unit();
double dist = sep.length();
double mag = (GRAV * bods[a] ->getMass () *
bods[b]->getMass( ) ) / (dist * dist);
Vector force = dir * mag;
bods[a]->addForce(-force);
bods[b]->addForce(force);
}
for (a = 0; a < numBodies; a++)
bods [a] ->update (DT);
}
Concordia TAV 2002 Comp5421_1
32
Designing Class Body
(cont.)
• Above code needs the following functions of class
Body, and some more methods of class Vector
(binary -, unary -, unit, length, multiplication of
scalars. getMass(), getPos() are trivial and therefore
they are not shown here.
• Void Body::clearForce ()
{
force = Vector (); }
• Void Body::addForce (Vector f )
{
force += f;
}
Concordia TAV 2002 Comp5421_1
33
Designing Class Vector
• The representation of class vector is an array
with three components:
class Vector
{
.
public:
....
private:
double cpts [3] ;
}
Concordia TAV 2002 Comp5421_1
34
Designing Class Vector
(cont.)
• A single constructor initializes the three
components with zero as the default value. (for
creating zero vector.)
Vector::Vector(double x=0.0, double y=0.0,double z = 0.0)
{
cpts [0] = x; cpts [1] = y; cpts [2] = z; }
• Give clients access to the components by
overloading the subscript operator, [],
as follows:
double & Vector::operator[] (int i)
{
return cpts[i];
}
Concordia TAV 2002 Comp5421_1
35
Designing Class Vector
(cont.)
• Assignment operator is conventional, and we
return a reference to the result.
Vector & Vector::operator= (Vector & other)
{
cpts[0] = other[0];
cpts[1] = other[1];
cpts[2] = other[2];
return *this;
}
Vector & Vector::operator+= (Vector & other)
{
cpts[0] += other[0];
cpts[1] += other[1]
cpts[2] += other[2];
return *this;
}
Concordia TAV 2002 Comp5421_1
36
Designing Class Vector
(cont.)
• we can define operators both binary minus (as in u –
v ), and unary minus (as in –v ).
Vector Vector::operator- (Vector & other)
{
return Vector ( cpts[0] - other[0], cpts[1] - other[1],
cpts[2] - other[2]);
}
Vector Vector::operator- ()
{
return Vector (-cpts[0], -cpts[1], -cpts[2] );
}
Concordia TAV 2002 Comp5421_1
37
Designing Class Vector
(cont.)
• Below are vector multiplication / division by a scalar.
Vector Vector::operator* (double scalar)
{
return Vector (cpts[0]*scalar, cpts[1]*scalar, cpts[2]*scalar);
}
Vector Vector::operator/ (double scalar)
{
return Vector (cpts[0]/scalar, cpts[1]/scalar, cpts[2]/scalar) ;
}
Concordia TAV 2002 Comp5421_1
38
Designing Class Vector
(cont.)
• Methods for length and unit.
double Vector::length ()
{
return sqrt (sqr(cpts[0]) + sqr(cpts[1]) + sqr(cpts[2]));
Vector Vector::unit ()
{
return (*this) / length();
}
}
• Method to write a vector to a stream, it is useful.
ostream & operator<< (ostream & os, Vector v)
{
os << '(' << v[0] ,<< ', ' << v[1]<< ',‘<< v[2] << ')';
return os;
}
Note: vector argument v is passed by reference
Concordia TAV 2002 Comp5421_1
39
Discussion
• Results of design process is a collection of
classes.
For each class, we know:
1. interface of the class - the set of methods that
the class provides;
2. implementation of the class - the attributes of
the class and how the methods affect them.
For the whole system, we also know:
how the classes interact, that is, what messages
they send to one another and when they send
them.
Concordia TAV 2002 Comp5421_1
40
Discussion
(cont.)
Distinguish carefully:
• A class is a static, compile-time entity.
• An object is a dynamic, run-time entity.
• There may be zero, or one, or more instances of a
class.
• The instances are objects.
• All instances of a class behave in the same way
because they have the same methods.
• Each instance of a class has its own, unique data.
Concordia TAV 2002 Comp5421_1
41