Lecture 7

1. Lecture 7 Object Oriented Programming Review Richard Gesick

2. Topics Identifying Classes & Objects Static Members Class Relationships “this” Parameters Revisited Overloading Methods Operators Testing

3. Identifying Classes & Objects Identify potential classes within the specification Nouns

5. In Gaming… How do you identify the classes within a game? What have you seen so far in labs and assignments?

6. What Goes in the Class How do you decide what should be in the class Data Methods Not easy, but must be done

7. Static Members Static methods can be invoked via the class name Static variables are stored at the class level (one copy for all instances)

8. 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

9. 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

10. 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);

11. 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

12. Class Relationships Classes can have various relationships to one another. Most common are: Dependency (“uses”) Aggregation (“has a”) Inheritance (“is a”)

13. 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 writes Author Book

14. 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?

15. Aggregation One class is “made up” of other classes “has a” relationship Gameboard has a marble Deck has a card

16. 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

17. Aggregation in UML An aggregation association is shown in a UML class diagram using an open diamond at the aggregate end StudentBody Student 1 2 - firstName : String - lastName : String - homeAddress : Address - schoolAddress : Address + Main (args : String[]) : void + ToString() : String Address - streetAddress : String - city : String - state : String - zipCode : long + ToString() : String

18. 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();

19. 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; }

20. Assignment Revisited The act of assignment takes a copy of a value and stores it in a variable For primitive types: num2 = num1; Before After num1 num1 num2 num2 5 5 12 5

21. Reference Assignment For object references, assignment copies the memory location: bishop2 = bishop1; After Before bishop1 bishop2 bishop1 bishop2

22. 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

23. Parameters There are three main types of parameters: Value - passes a copy (value) of the variable to the method.  This is the default. 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 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)

24. Example 1 and the output is ?cse1302_Lecture7_Sample static void Main() { int a = 42; Console.WriteLine (a); B (a); Console.WriteLine (a); } static void B (int x) { x += 9; Console.WriteLine (x); }

25. 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); }

26. 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); }

27. 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); }

28. 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); }

29. 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.

30. 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

31. Overloading Methods Version 1 Version 2 float tryMe (int x, float y) { return x*y; } float tryMe (int x) { return x + .375; } Invocation result = tryMe (25, 4.32)

32. Overloading Operators In C#, not only can methods be overloaded, operators can be overloaded as well.