1. CSE 1301 Lecture 6 Writing Classes Figures from Lewis, “C# Software Solutions”, Addison Wesley Richard Gesick

2. CSE 1301 Topics Methods Return Parameters Constructors Overloading Constructors Scope

3. CSE 1301 Method Declarations Let’s now examine method declarations in more detail A method declaration specifies the code that will be executed when the method is invoked (called) When a method is invoked, the flow of control jumps to the method and executes its code When complete, the flow returns to the place where the method was called and continues The invocation may or may not return a value, depending on how the method is defined

4. CSE 1301 Methods Used to group a set of instructions Given a name (so we can refer to it later) This name represents the instructions Methods can be public or private – Public if someone outside the class should access/invoke them – Private if used internal to the class

5. CSE 1301 myMethod(); myMethodcompute Method Control Flow If the called method is in the same class, only the method name is needed

6. CSE 1301 doIt helpMe helpMe(); obj.doIt(); main Method Control Flow The called method is often part of another class or object

7. CSE 1301 A Method Returns When the method is done, control returns to where we “left off” in the caller As in math, functions/methods can evaluate to something – We should be able to “return” a value The return statement halts execution within the method and (optionally) returns a value

8. CSE 1301 Return Example int Sum(int a, int b) { return a + b; Console.Writeline("This will never be displayed"); }

9. CSE 1301 Method Header A method declaration begins with a method header char calc (int num1, int num2, string message) method name return type parameter list The parameter list specifies the type and name of each parameter The name of a parameter in the method declaration is called a formal parameter

10. CSE 1301 Method Body The method header is followed by the method body char calc (int num1, int num2, string message) { int sum = num1 + num2; char result = message.charAt(sum); return result; } The return expression must be consistent with the return type sum and result are local data They are created each time the method is called, and are destroyed when it finishes executing

11. CSE 1301 Method Body The code that performs the method's function is written between the beginning and ending curly braces. In the method body, a method can declare variables, call other methods, and use other program structures (if/else statements, while loops, for loops, switch statements, and do/while loops)

12. CSE 1301 The return Statement The return type of a method indicates the type of value that the method sends back to the calling location A method that does not return a value has a void return type A return statement specifies the value that will be returned return expression; Its expression must conform to the return type

13. CSE 1301 Parameters & Scope Because variables are only visible within the scope in which they are declared, no one else can “see” them This is a good thing for protection/encapsulation But we need a way of moving data within our program – Making everything “global” is a bad idea – There are times when we need to pass on some data to the method for it to work on that data

14. CSE 1301 Parameters A method is defined by its – Name – Return type – PARAMETERS (the stuff in the parenthesis) When we call a method, we need to pass the correct number and type of parameters – “Speak the language” of the method

15. CSE 1301 Parameters When a method is called, the actual parameters in the invocation are copied into the formal parameters in the method header char calc (int num1, int num2, string message) { int sum = num1 + num2; char result = message.charAt(sum); return result; } ch = obj.calc (25, count, "Hello");

16. CSE 1301 Constructors Special methods that are called when an object is instantiated using the new keyword. A class can have several constructors. The job of the class constructors is to initialize the instance variables of the new object.

17. CSE 1301 Constructors So far, we’ve seen attributes and methods Constructor is a unique method – Named same as the class name – Automatically called when class is instantiated – Useful for setting attributes & initializing the instance – No return type (not even void) – Must be public Default constructor is used unless you specify a constructor For each attribute in the class, assign something to it in the constructor (initialize)

18. CSE 1301 class BMW_Z4 { private int modelYear; private string licensePlate; private bool topUp; public BMW_Z4 () { ModelYear = 2004; TopUp = false; LicensePlate = "DEALER"; }... } Constructor Example

19. CSE 1301 Multiple Constructors (overloading) Constructors are used to initialize our objects We can use parameters to the constructor to customize the initialization Sometimes we have more or less data to use in the customization We’d like to be able to pass in only what we know 1-19

20. CSE 1301 Overloading Overloading involves using the same method/function name – Vary the number of parameters – Vary the type of parameters – Cannot just change return type (ambiguity in invocation) Useful to keep things simple – Squaring a number…

21. CSE 1301 Overloading Example int Square (int i) { return i * i; } float Square (float i) { return i * i; } static void Main() {... float x = Square(5.3f); int y = Square(9);... }

22. CSE 1301 Constructor Overloading class BMW_Z4 {... public BMW_Z4 () { Initialize(0, 2004, false); } public BMW_Z4 (int my) { Initialize(0, my, false); } private Initialize(int cs, int my, bool tu) { currentSpeed = cs; ModelYear = my; TopUp = tu; }... } Place common initialization in a separate function Notice same method name, different parameters

23. CSE 1301 Which is Called? BMW_Z4 myCar = new BMW_Z4(); BMW_Z4 yourCar = new BMW_Z4(2007); BMW_Z4 herCar = new BMW_Z4(2008); The constructor with the matching parameter definition will be called – If no parameters, the () constructor – If one parameter, the (int) constructor 2-23 Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison- Wesley

24. CSE 1301 Defining a Constructor Syntax: public ClassName( parameter list ) { // constructor body } Note: no return value, not even void! Each constructor must have a different number of parameters or parameters of different types Default constructor: a constructor that takes no arguments.

25. CSE 1301 Constructor Examples public class Card { private int value; private string suit; //default constructor public Card ( ) { value = 1; suit = “Spades”; } // specific constructor public Card (int initValue, string initSuit) { value = initValue; suit = initSuit; }

26. CSE 1301 Class Scope Instance variables have class scope – Any constructor or method of a class can directly refer to instance variables. Methods also have class scope – Any method or constructor of a class can call any other method of a class (without using an object reference).

27. CSE 1301 Local Scope A method's parameters have local scope, meaning that: – a method can directly access its parameters. – a method's parameters cannot be accessed by other methods. A method can define local variables which also have local scope, meaning that: – a method can access its local variables. – a method's local variables cannot be accessed by other methods.

28. CSE 1301 Summary of Scope A method in a class can access: – the instance variables of its class – any parameters sent to the method – any variable the method declares from the point of declaration until the end of the method or until the end of the block in which the variable is declared, whichever comes first – any methods in the class

29. CSE 1301 Accessor Methods Clients cannot directly access private instance variables, so classes provide public accessor methods with this standard form: public returnType getInstanceVariable( ) { return instanceVariable; } (returnType is the same data type as the instance variable) This is the same as the “get” property.

30. CSE 1301 Accessor Methods Example: the accessor method for model from the Auto class public string getModel( ) { return model; }

31. CSE 1301 Mutator Methods Allow client to change the values of instance variables public void setInstanceVariable( dataType newValue ) { // validate newValue, // then assign to instance variable } This is the same as the “set” property.

32. CSE 1301 Software Engineering Tip Write the validation code for the instance variable in the mutator method and have the constructor call the mutator method to validate and set initial values This eliminates duplicate code and makes the program easier to maintain

33. CSE 1301 Common Error Trap Do not declare method parameters. – Parameters are defined already and are assigned the values sent by the client to the method. Do not give the parameter the same name as the instance variable. – The parameter has name precedence so it "hides" the instance variable. Do not declare a local variable with the same name as the instance variable. – Local variables have name precedence and hide the instance variable.

34. CSE 1301 The Object Reference this How does a method know which object's data to use? this is an implicit parameter sent to methods and is an object reference to the object for which the method was called. When a method refers to an instance variable name, this is implied Thus: variableName model is understood to be is understood to be this.variableName this.model

35. CSE 1301 Using this in a Mutator Method public void setInstanceVariable( dataType instanceVariableName ) { this.instanceVariableName = instanceVariableName; } Example: public void setModel( string model ) { this.model = model; } this.model refers to the instance variable. model refers to the parameter.

36. CSE 1301 Another Example Suppose we wanted a new object to represent a day of the year. What data should we store? What operations are available? What should be public? What should be private?

37. CSE 1301 static Variables Also called class variables One copy of a static variable is created per class static variables are not associated with an object static constants are often declared as public To define a static variable, include the keyword static in its definition: Syntax: accessSpecifier static dataType variableName; Example: public static int countAutos = 0;

38. CSE 1301 static Methods Also called class methods Often defined to access and change static variables static methods cannot access instance variables: – static methods are associated with the class, not with any object. – static methods can be called before any object is instantiated, so it is possible that there will be no instance variables to access.

39. CSE 1301 Rules for static and Non-static Methods static Method Non-static Method Access instance variables?noyes Access static class variables? yes Call static class methods?yes Call non-static instance methods? noyes Use the object reference this? noyes