Post on 12-Jan-2016
CSE 1302
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
public static int triple (int num){ int result; result = num * 3; return result;}
class Helper
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 Bookwrites
CSE 1302
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
+ ToString() : String
1 2Student
- firstName : String- lastName : String- homeAddress : Address- schoolAddress : Address
+ ToString() : String
- streetAddress : String
- city : String- state : String
- zipCode : long
Address
CSE 1302
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
num1
5
num2
12
After
num1
5
num2
5
CSE 1302
Reference Assignment
• For object references, assignment copies the memory location:
bishop2 = bishop1;
Before
bishop1 bishop2
After
bishop1 bishop2
CSE 1302
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
ParametersThere 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
float tryMe (int x){ return x + .375;}
Version 1
float tryMe (int x, float y){ return x*y;}
Version 2
result = tryMe (25, 4.32f)
Invocation
CSE 1302
Overloading Operators
• In C#, not only can methods be overloaded, operators can be overloaded as well.
CSE 1302
CSE 1302
• 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
•Operator overloading
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 // Class that overloads operators for adding, subtracting
3 // and multiplying complex numbers.
4 using System;
5
6 public class ComplexNumber
7 {
8 // read-only property that gets the real component
9 public double Real { get; private set; }
10
11 // read-only property that gets the imaginary component
12 public double Imaginary { get; private set; }
13
14 // constructor
15 public ComplexNumber( double a, double b )
16 {
17 Real = a;
18 Imaginary = b;
19 } // end constructor
CSE 1302
20
21 // return string representation of ComplexNumber
22 public override string ToString()
23 {
24 return string.Format( "({0} {1} {2}i)",
25 Real, ( Imaginary < 0 ? "-" : "+" ), Math.Abs( Imaginary ) );
26 } // end method ToString
27
28 // overload the addition operator
29 public static ComplexNumber operator +(
30 ComplexNumber x, ComplexNumber y )
31 {
32 return new ComplexNumber( x.Real + y.Real,
33 x.Imaginary + y.Imaginary );
34 } // end operator +
35
Overload the plus operator (+) to perform addition of ComplexNumbers