CS1S467 GUI Programming LECTURE 15 Methods (2 of 2)

Recap: METHODS METHODS are used whenever: a problem can be broken down into sub-problems similar or identical code is required at several places in the program Consequences of using METHODS: less typing re-using of code produces better quality and easier to maintain programs

Recap: Structure of a METHOD To call a method: Returned stuff = Method name ( List of stuff to pass into method ); The method itself: Scope Returned stuff Method name (List of stuff passed in) body of the method where computations are made return statement (if anything gets returned) { } // end of method

Recap: Parameter Lists The formal parameter list static int MaxOf( int x, int y ) { if ( x>y ) return x; else return y; } // end of method 'MaxOf' The 'MaxOf' method may be called using 'actual parameter lists' variables as parameters: MaxOf( a, b ); // a and b are int variables actual figures as parameters: MaxOf( 7, 100 ); // 7 and 100 also int or a mixture of both: MaxOf( a, 100 ); // a and 100 are int The actual parameter list

Recap: Parameter Lists Formal and Actual parameter lists must match static int MaxOf( int x, int y ) { if ( x>y ) return x; else return y; } // end of method 'MaxOf' The 'MaxOf' method may NOT be called using unsuitable parameters types: MaxOf( a, 7.5 ); // 7.5 is a float the wrong amount of parameters: MaxOf( 7, 100, 200 ); // 3 parameters MaxOf( 100 ); // only 1 parameter

Recap: Methods and Classes To call a method in the same class use just the name of the method MaxOf(4, 5); If the method is located in another class call it using the format: ClassName.MethodName( formal parameter list ) Console.ReadLine(); Console.WriteLine( "bla" );

Summary So Far The structure of a method call is: Returned parameter = Class.Method name (Actual parameter list) ; Single parameter, must match in type (void if none) Parameters must match in: number type order The structure of a method is: Scope Returned type Method name (Formal parameter list) body of the method where computations are made return statement (if anything gets returned) { } // end of method

New Stuff ! Scope of Methods Public and Private Scope of Variables Local and Global Overloading Methods

Scope of Methods (1 of 4) Scope Access to Method Scope Returned type Method name (Formal parameter list) body of the method where computations are made return statement (if anything gets returned) { } // end of method public from ALL other classes and the same class private from inside the same class only protected like ‘private’ but also from derived classes friend from inside project only - none - ‘private’ is the DEFAULT Scope Access to Method

Scope of Methods (2 of 4) Scope Access to Method public public static void LoginError () { Console.PrintLine(“Your username and password do not match”); //nothing to return } // end of method public from ALL other classes and the same class private from inside the same class only protected like ‘private’ but also from derived classes friend from inside project only - none - ‘private’ is the DEFAULT Scope Access to Method

Scope of Methods (3 of 4) Why different Method Scopes ? Preventing full ("public") access to Methods: allows only certain 'safe and tested' parts of classes to be used elsewhere hides away unimportant detail (e.g. 'helper' methods)

Scope of Methods (4 of 4) An Example Scenario public class Car { private static int speed = 0; public const int FOR=0, BACK=1; public static void SetSpeed( int newSpeed ) speed=newSpeed; if(speed > 70) speed =70; if(speed < 0) speed = 0; } public static int GetSpeed( ) return speed; } // end of Car class class Driver { static void Main(string [ ] argStr) int direction, spd; direction = Car.BACK; // this works Car.speed = 20; // this won't work Car.SetSpeed( 50000 ); spd = Car.GetSpeed( ); Console.WriteLine ("Speed is: " + spd); } //end of Main } //end of Driver class

Full Example Code in Visual Studio using System;   namespace ScopeDemo1 { public class Car private static int speed = 0; public const int FOR = 0, BACK = 1; public static void SetSpeed(int newSpeed) speed = newSpeed; if (speed > 70) speed = 70; if (speed < 0) speed = 0; } public static int GetSpeed() return speed; } // end of Car class    class Driver static void Main(String[] argStr) int direction, spd; direction = Car.BACK; // this works // Car.speed = 20; // this won't work Car.SetSpeed(50000); spd = Car.GetSpeed(); Console.WriteLine("Speed is: " + spd); Console.ReadLine(); } //end main } //end of Driver class } // end of namespace Full Example Code in Visual Studio

New Stuff ! Scope of Methods Public and Private Scope of Variables Local and Global Overloading Methods

Scope of Variables (1 of 4) Variables declared INSIDE a method ("method variables") are only 'known' and accessible INSIDE that method. public class Test { private static float AddThem( float x, float y ) { Console.WriteLine("a is " +a); return x+y; } // end of method 'AddThem' public static void Main ( string [ ] argStr ) { float a=4, b=5, c; c = AddThem ( a, b ); // calling the 'addThem' method Console.WriteLine("The sum of " +a+ " and " +b+ " is " +c); Console.WriteLine("x is " +x+ " and y is " +y); } // end of Main } // end of class Test What is the problem here? And here?

Scope of Variables (2 of 4) Variables inside different methods can even have the same name, but they are different !! public class Test { private static float AddThem( float a, float b ) { float sum =a+b; a=2000; // this affects only the variable a in the AddThem method return sum; } // end of method 'AddThem' public static void Main ( string [ ] argStr ) { float a=4, b=5, c; c = AddThem ( a, b ); // calling the 'AddThem' method Console.WriteLine("The sum of " +a+ " and " +b+ " is " +c); } // end of Main } // end of class Test "The sum of 4 and 5 is 9" (NOT: "The sum of 2000 …")

Scope of Variables (3 of 4) If you really need access to the same variable inside all or most methods of a class use "class variables" public class Test { private static float a=4; // declaration of "class variable" a (keyword ‘static’) private static float AddThem( float x, float y ) { a=2000; // this now does affect the class variable a return x+y; } // end of method 'AddThem' public static void Main ( string [ ] argStr ) { float b=5, c; c = AddThem ( a, b ); // calling the 'AddThem' method Console.WriteLine("The sum of " +a+ " and " +b+ " is " +c); } // end of Main } // end of class Test "The sum of 2000 and 5 is 9" (NOT: "The sum of 4 …")

Scope of Variables (4 of 4) Class variables and Method variables can have the same name but "local beats global" public class Test { private static float a=4; // declaration of "class variable" a (keyword ‘static’) private static float AddThem( float a, float x ) { a=2000; // this does NOT affect the class variable a return a+x; } // end of method 'AddThem' public static void Main ( string [ ] argStr ) { float b=5, c; c = AddThem ( a, b ); // calling the 'AddThem' method Console.WriteLine("The sum of " +a+ " and " +b+ " is " +c); } // end of Main } // end of class Test "The sum of 4 and 5 is 2005" (well, ……..)

Summary: Scope of Variables Variables declared INSIDE a method ("method variables") are only 'known' and accessible INSIDE that method. Variables inside different methods can even have the same name, but they are different !! If you need access to the same variable inside all or most methods of a class use "class variables" Class variables and method variables can have the same name but "local beats global"

Check your knowledge now: Spot the mistakes and figure out the printout: public class ScopeTest { private float x=5.0; private int AddToX( a ) { return x + a; } // end of method 'addThem' public static void Main ( argStr[ ] ) { float x, y=6.0, z; z = addToX( x, y ); x = addToX( z ); Console.WriteLine("z is "+z+" and x is "+x); // what gets printed? } // end of main } // end of class private static float x=5.0; private static float addToX( float a) { (string [ ] argStr ); float x = 0.0, y=6.0, z; z = addToX( y ); z is 11.0 and x is 16.0

Naming Conventions Quick reminder: Variable names lowerUpperUpper (e.g. myVariable, theLongVariable) Class name UpperUpperUpper (e.g. CurrencyInput, TheTestClass ) Method names UpperUpperUpper( ) (e.g. ReadLine( ), AddToX( ) ) Constant names ALL_UPPER (e.g. PI, INCHES )

Naming Conventions

New Stuff ! Scope of Methods Public and Private Scope of Variables Local and Global Overloading Methods

Overloading Methods Consider this method: private static int AddThem( int a, int b ) { return a+b; } What do you do if you want to add floats but don't want to invest into different names, e.g. addInts(…), addFloats(…), addLongs(…) ? You OVERLOAD the method i.e. use the same name but different return types and/or formal parameter lists: private static int AddThem( int a, int b ) { return a+b; } private static float AddThem( float a, float b ) {

Overloading Example Results 7 12 4.0 public class OverLoadingTest { private static int AddThem( int a, int b ) return a+b; } private static int AddThem( int a, int b, int c ) return a+b+c; private static float AddThem( float a, float b ) public static void Main(string [ ] argStr) int x=3, y=4, z=5, iRes; float n=1.5f, m=2.5f, fRes; iRes = addThem( x, y ); iRes = addThem( x, y, z ); fRes = addThem( n, m ); Overloading Example Results 7 12 4.0

Summary: METHODS Why: maintenance, usability, readability, safety Parameter list: formal - actual, match (amount, order, type) Return types: void, int, float, String, …. Method scope: private, public, (friendly) Variable scope: class variables, method variables --> "safety" Accessing methods: ClassName.methodName Overloading methods: same name, different parameter lists

END OF LECTURE 15