Lecture 11
Object Oriented Programming
Richard Gesick
Figures from Lewis, “C# Software Solutions”, Addison Wesley
CSE 1301
Topics
•
•
•
•
•
•
•
Software Development
Identifying Classes & Objects
Static Members
Class Relationships
“this”
Parameters Revisited
Overloading
– Methods
– Operators
• Testing
CSE 1301
The Software Life Cycle
• The overall life cycle of a program includes use and
maintenance:
Development
Use
Maintenance
• A version of the software that is made available to user
is called a release
CSE 1301
Development vs. Maintenance
Development
Use and
Maintenance
CSE 1301
The Waterfall Model
Establish
requirements
Create
design
Implement
code
Test
system
CSE 1301
An Iterative Development Process
Establish
requirements
CSE 1301
Create
design
Implement
code
Test
system
Identifying Classes & Objects
• Identify potential classes within the
specification
• Nouns
CSE 1301
CSE 1301
In Gaming…
• How do you identify the classes within a
game?
• What have you seen so far in labs and
assignments?
CSE 1301
What Goes in the Class
• How do you decide what should be in the
class
– Data
– Methods
• Not easy, but must be done
CSE 1301
Static Members
• Static methods can be invoked via the class
name
• Static variables are stored at the class level
(one copy for all instances)
CSE 1301
The static Modifier
• Remember that static methods (also called class methods) that
can be invoked through the class name rather than through a
particular object
• For example, the methods of the Math class are static:
Math.sqrt (25)
• To write a static method, we apply the static modifier to the
method definition
• The static modifier can be applied to variables as well
• It associates a variable or method with the class rather than with
an object
CSE 1301
Static Variables
• Static variables are also called class variables
• Normally, each object has its own data space, but if a variable
is declared as static, only one copy of the variable exists
private static int count;
• Memory space for a static variable is created when the class in
which it is declared is loaded
• All objects created from the class share static variables
• Changing the value of a static variable in one object changes it
for all others
• Local variables cannot be static
CSE 1301
Static Methods
class Helper
public static int triple (int num)
{
int result;
result = num * 3;
return result;
}
Because it is static, the method can be invoked as:
value = Helper.triple (5);
CSE 1301
Static Methods
• Static methods cannot reference instance
variables, because instance variables don't
exist until an object exists
• However, a static method can reference static
variables or local variables
CSE 1301
Class Relationships
Classes can have various relationships to
one another. Most common are:
• Dependency (“uses”)
• Aggregation (“has a”)
• Inheritance (“is a”)
CSE 1301
Object Relationships
• Objects can have various types of relationships to each other
• A general association, as we've seen in UML diagrams, is
sometimes referred to as a use relationship
• A general association indicates that one object (or class) uses or
refers to another object (or class) in some way
• We could even annotate an association line in a UML diagram to
indicate the nature of the relationship
Author
CSE 1301
writes
Book
Dependency
• One class dependent (uses) another class
– Game uses ball, paddle
– Ship uses bullet
• Sometimes, a class depends on another
instance of itself
– Is one date equal to another date?
– Is one picture equal to another picture?
CSE 1301
Rational Class Design
• Let’s design a class that represents a rational
number (fraction)
• What data needs to be stored?
• What methods or operations are needed?
• Look at the following client code:
CSE 1301
Rational r1 = new Rational(6, 8);
Rational r2 = new Rational(1, 3);
Rational r3, r4, r5, r6, r7;
Console.Out.WriteLine("First rational number: " + r1);
Console.Out.WriteLine("Second rational number: " + r2);
if (r1.Equals(r2))
Console.Out.WriteLine("r1 and r2 are equal.");
else
Console.Out.WriteLine("r1 and r2 are NOT equal.");
r3 = r1.Reciprocal();
Console.Out.WriteLine("The reciprocal of r1 is: " + r3);
r4 = r1.Add(r2);
r5 = r1.Subtract(r2);
r6 = r1.Multiply(r2);
r7 = r1.Divide(r2);
Console.Out.WriteLine("r1 + r2: " + r4);
Console.Out.WriteLine("r1 - r2: " + r5);
Console.Out.WriteLine("r1 * r2: " + r6);
Console.Out.WriteLine("r1 / r2: " + r7);
Console.In.ReadLine(); // Wait for enter key
CSE 1301
CSE 1301
UML Design
Rational
CSE 1301
Constructor
public Rational (int numer, int denom)
{
}
CSE 1301
Reciprocal
public Rational Reciprocal ( )
{
}
CSE 1301
ToString
public override string ToString ( )
{
}
CSE 1301
Reduce
private void Reduce ( )
{
if (numerator != 0)
{
int common = Gcd(Math.Abs(numerator), denominator);
numerator = numerator / common;
denominator = denominator / common;
}
}
CSE 1301
Gcd
private int Gcd (int num1, int num2)
{
while (num1 != num2)
if (num1 > num2)
num1 = num1 - num2;
else
num2 = num2 - num1;
return num1;
}
CSE 1301
Add
public Rational Add (Rational op2)
{
}
CSE 1301
Subtract
public Rational Subtract (Rational op2)
{
}
CSE 1301
Multiply
public Rational Multiply (Rational op2)
{
}
CSE 1301
Divide
public Rational Divide (Rational op2)
{
}
CSE 1301
Equals
public bool Equals (Rational op2)
{
}
CSE 1301
Aggregation
• One class is “made up” of other classes
• “has a” relationship
– Gameboard has a marble
– Deck has a card
CSE 1301
Aggregation
• An aggregate object is an object that contains
references to other objects
• For example, an Account object contains a reference
to a String object (the owner's name)
• An aggregate object represents a has-a relationship
• A bank account has a name
• Likewise, a student may have one or more addresses
CSE 1301
Aggregation in UML
• An aggregation association is shown in a UML
class diagram using an open diamond at the
aggregate end
StudentBody
+ Main (args : String[])
: void
Address
- streetAddress : String
- city : String
- state : String
- zipCode : long
+ ToString() : String
CSE 1301
1
2
Student
- firstName : String
- lastName : String
- homeAddress : Address
- schoolAddress : Address
+ ToString() : String
The this Reference
• The this reference allows an object to refer to itself
• That is, the this reference, used inside a method, refers to
the object through which the method is being executed
• Suppose the this reference is used in a method called
tryMe
• If tryMe is invoked as follows, the this reference refers to
obj1:
obj1.tryMe();
• But in this case, the this reference refers to obj2:
obj2.tryMe();
CSE 1301
The this reference
• The this reference can also be used to
distinguish the parameters of a constructor
from the corresponding instance variables
with the same names
public Account (String name, long acctNumber,
double balance)
{
this.name = name;
this.acctNumber = acctNumber;
this.balance = balance;
}
CSE 1301
Assignment Revisited
• The act of assignment takes a copy of a value and stores
it in a variable
• For primitive types:
num2 = num1;
Before
CSE 1301
After
num1
num2
num1
num2
5
12
5
5
Reference Assignment
• For object references, assignment copies the memory location:
bishop2 = bishop1;
Before
bishop1
CSE 1301
bishop2
After
bishop1
bishop2
Aliases
• Two or more references that refer to the same
object are called aliases of each other
• One object (and its data) can be accessed using
different reference variables
• Aliases can be useful, but should be managed
carefully
• Changing the object’s state (its variables) through
one reference changes it for all of its aliases
CSE 1301
Parameters
There are three main types of parameters:
1. Value - passes a copy (value) of the variable to the
method. This is the default.
2. Reference - passes a reference to the actual
variable. Marked with "ref", use this when you want to
pass a value in and have any change to that value be
persistent when the method is complete
3. Out - passes a reference to the actual variable. Marked
with "out", use this when you want the method to
generate a value and place it for later use in the actual
variable (persists when the method is complete)
CSE 1301
using System;
namespace ParameterTester
{
public class Num
{
private int value;
public Num (int update)
{ value = update; }
public void SetValue (int update)
{ value = update; }
public override string ToString ( )
{ return value + ""; }
}
}
CSE 1301
using System;
namespace ParameterTester {
class ParameterPassing {
static void Main(string[] args) {
ParameterModifier modifier = new ParameterModifier();
int a1 = 111;
Num a2 = new Num(222);
Num a3 = new Num(333);
Console.Out.WriteLine("Before calling changeValues:");
Console.Out.WriteLine("a1\ta2\ta3");
Console.Out.WriteLine(a1 + "\t" + a2 + "\t" + a3 + "\n");
modifier.ChangeValues(a1, a2, a3);
Console.Out.WriteLine("After calling changeValues:");
Console.Out.WriteLine("a1\ta2\ta3");
Console.Out.WriteLine(a1 + "\t" + a2 + "\t" + a3 + "\n");
Console.In.ReadLine(); // Wait for enter key
}
}
}
CSE 1301
using System;
namespace ParameterTester {
public class ParameterModifier {
public void ChangeValues(int f1, Num f2, Num f3)
{
Console.Out.WriteLine("Before changing the values:");
Console.Out.WriteLine("f1\tf2\tf3");
Console.Out.WriteLine(f1 + "\t" + f2 + "\t" + f3 + "\n");
f1 = 999;
f2.SetValue(888);
f3 = new Num(777);
Console.Out.WriteLine("After changing the values:");
Console.Out.WriteLine("f1\tf2\tf3");
Console.Out.WriteLine(f1 + "\t" + f2 + "\t" + f3 + "\n");
Console.In.ReadLine();
}
}
}
CSE 1301
CSE 1301
CSE 1301
Example 1
static void Main()
{
int a = 42;
Console.WriteLine (a);
B (a);
Console.WriteLine (a);
}
static void B (int x)
{
x += 9;
Console.WriteLine (x);
}
CSE 1301
Example 2
static void Main()
{
int a = 42;
Console.WriteLine (a);
B (ref a);
Console.WriteLine (a);
}
static void B (ref int x)
{
x += 9;
Console.WriteLine (x);
}
CSE 1301
Example 3
static void Main()
{
int a;
B (out a);
Console.WriteLine (a);
}
static void B (out int x)
{
x = 9;
Console.WriteLine (x);
}
CSE 1301
Example 4
class Z
{ public int y; }
static void Main()
{
Z myZ = new Z();
myZ.y = 42; Console.WriteLine (myZ.y);
B (myZ);
Console.WriteLine (myZ.y);
}
static void B (Z x)
{
x.y += 9;
Console.WriteLine (x.y);
}
CSE 1301
Example 5
class Z
{ public int y; }
static void Main()
{
Z myZ = new Z();
myZ.y = 42; Console.WriteLine (myZ.y);
B (ref myZ);
Console.WriteLine (myZ.y);
}
static void B (ref Z x)
{
x = new Z();
x.y = 1;
Console.WriteLine (x.y);
}
CSE 1301
• Be careful to note the difference between a
pass-by-reference parameter and a parameter
of a reference type.
• Use the activation stack to track local variables
and how parameters of the above types affect
the variables from one stack frame to the
next.
CSE 1301
Overloading Methods
• Method overloading is the process of using the same method
name for multiple methods
• The signature of each overloaded method must be unique
• The signature includes the number, type, and order of the
parameters
• The compiler determines which version of the method is
being invoked by analyzing the parameters
• The return type of the method is not part of the signature
CSE 1301
Overloading Methods
Version 1
Version 2
float tryMe (int x)
{
return x + .375;
}
float tryMe (int x, float y)
{
return x*y;
}
Invocation
result = tryMe (25, 4.32f)
CSE 1301
Overloading Operators
• In C#, not only can methods be overloaded,
operators can be overloaded as well.
CSE 1301
CSE 1301