Lecture 7
Object Oriented Programming Review
Richard Gesick
CSE 1302
Topics
•
•
•
•
•
•
Identifying Classes & Objects
Static Members
Class Relationships
“this”
Parameters Revisited
Overloading
– Methods
– Operators
• Testing
CSE 1302
Identifying Classes & Objects
• Identify potential classes within the
specification
• Nouns
CSE 1302
In Gaming…
• How do you identify the classes within a
game?
• What have you seen so far in labs and
assignments?
CSE 1302
What Goes in the Class
• How do you decide what should be in the
class
– Data
– Methods
• Not easy, but must be done
CSE 1302
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 1302
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 1302
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 1302
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 1302
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 1302
Class Relationships
Classes can have various relationships to
one another. Most common are:
• Dependency (“uses”)
• Aggregation (“has a”)
• Inheritance (“is a”)
CSE 1302
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 1302
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 1302
Aggregation
• One class is “made up” of other classes
• “has a” relationship
– Gameboard has a marble
– Deck has a card
CSE 1302
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 1302
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 1302
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 1302
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 1302
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 1302
After
num1
num2
num1
num2
5
12
5
5
Reference Assignment
• For object references, assignment copies the memory location:
bishop2 = bishop1;
Before
bishop1
CSE 1302
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 1302
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 1302
Example 1 and the output is ?
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 1302
Example 2 and the output is ?
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 1302
Example 3 and the output is ?
static void Main()
{
int a;
B (out a);
Console.WriteLine (a);
}
static void B (out int x)
{
x = 9;
Console.WriteLine (x);
}
CSE 1302
Example 4 and the output is ?
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 1302
Example 5 and the output is ?
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 1302
• 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 1302
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 1302
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 1302
Overloading Operators
• In C#, not only can methods be overloaded,
operators can be overloaded as well.
CSE 1302
CSE 1302
•Operator overloading
• C# enables you to overload most operators to make
them sensitive to the context in which they are used.
• Use operator overloading when it makes an
application clearer than accomplishing the same
operations with explicit method calls.
• Class ComplexNumber overloads the plus (+),
minus (-) and multiplication (*) operators to enable
programs to add, subtract and multiply instances of
class ComplexNumber using common mathematical
notation
CSE 1302
Operator Overloading
• Keyword operator, followed by an operator
symbol, indicates that a method overloads the
specified operator.
• Methods that overload binary operators must
take two arguments—the first argument is the
left operand, and the second argument is the
right operand.
• Overloaded operator methods must be
public and static.
CSE 1302
1
// Fig. 12.17: ComplexNumber.cs
2
3
// Class that overloads operators for adding, subtracting
// and multiplying complex numbers.
4
5
6
7
using System;
public class ComplexNumber
{
8
9
10
11
// read-only property that gets the real component
public double Real { get; private set; }
12
13
14
15
16
public double Imaginary { get; private set; }
17
18
19
Real = a;
Imaginary = b;
} // end constructor
// read-only property that gets the imaginary component
// constructor
public ComplexNumber( double a, double b )
{
CSE 1302
20
21
// return string representation of ComplexNumber
22
23
24
public override string ToString()
{
return string.Format( "({0} {1} {2}i)",
Real, ( Imaginary < 0 ? "-" : "+" ), Math.Abs( Imaginary ) );
25
26
27
} // end method ToString
28
29
// overload the addition operator
public static ComplexNumber operator +(
30
31
32
33
ComplexNumber x, ComplexNumber y )
34
35
{
return new ComplexNumber( x.Real + y.Real,
x.Imaginary + y.Imaginary );
} // end operator +
CSE 1302
Overload the plus
operator (+) to perform
addition of
ComplexNumbers