Methods: Declaration and Usage

What are Methods

• Objects are real-world entities interacting with their environment by performing services on demand
• Objects of the same class:
  • Have same characteristics, storing the same type of data
  • Have the same behavior, providing the same services
• Methods refer to the services that objects provide

Why Methods

• Information hiding prevents direct data access by outsiders
• Encapsulation contains objects with appropriate operations for data
• Objects that store data would be accessed through suitable operations only

Method Declaration

• Method declaration consists of:
  • Method header
  • Method body
• <method header> { <method body> }
• <modifiers> <return type> <method name> ( <parameters> ){ <method body> }

Method Header

• <modifiers> <return type> <method name> ( <parameters> ){ <method body> }
• Modifiers specify how the method is accessed
• Return type specifies the type of returned value
  • If a method returns a value, its type must be declared
  • Return values can be used by the calling method
  • Any method can return only one value
  • If the method returns nothing, the keyword void is used as the return type
• Parameters are a list of variables whose values will be passed to the method
  • Methods can have no parameters, declared using empty parentheses

Types of Methods

• Three criteria define types of methods:
  • Modifiers:
    • Visibility (public or private)
    • Whether shared between instances, i.e., class member (static) or instance method
    • Whether override-able or not (final)
  • Return type: with or without void
  • Parameters: with or without parameters

Message Passing/Method Invocation

• Message passing allows objects to communicate by exchanging messages
• Passing a message conveys an order to execute a specific method
• Passing messages to objects refers to method invocation
• Invoking a method of a given object use:
  • The instance variable referring to the object
  • The dot (.) operator
• instanceVariable.methodName(arguments)

Method Invocation Execution Schema

• Client invokes method, and relevant parameters are passed
• Results in the method being actioned

Returning a Value from a Method

• A method returns to the code that invoked it when:
  • All statements are completed
  • A return statement is reached
  • An exception is thrown
• If a method returns a value:
  • The caller must declare a same-type variable of the return value
  • Value assignment example: variableName = instanceVariable.methodName(args);

The Return Keyword

• A method's return type is declared in its method declaration
• The return statement is used within the method's body to return the value
• Any method declared void does not return a value
  • It may use a return statement to branch out of a control flow block, but a value is forbidden
• Any method not declared void must contain a return statement with a corresponding return value
  • The return value's data type must match the method's declared type
  • Returning an integer value from a method declared to return a boolean is disallowed

Passing Information

• A method declaration defines:
  • Number of data items to be passed
  • Type of data to be passed
• Parameters refer to the list of variables in the method declaration
• Arguments are the actual values that are passed when the method is invoked
  • When invoking, the arguments used must match the declaration's parameters in type and order

Arguments and Parameters

• Argument is a value being passed
• Parameter is a placeholder holding the argument

Matching Arguments and Parameters

• The number of arguments and parameters must match
• Arguments and parameters are paired from left to right
• The matched pair must be assignment compatible

Parameter Passing

• When a method is called:
  • Parameters are created
  • Values of arguments are copied into the parameters' variables
  • Variables declared in the method body (local variables) are created
  • Method body is executed using the parameters and local variables
• When the method finishes:
  • Parameters and local variables are destroyed

Passing Objects to a Method

• Object references can be passed similarly to data types using instance variables
• Passing an instance variable to a method passes a reference
  • The passed parameter mechanism copies the argument's value (object reference) into the parameter
  • The argument and its corresponding parameter refer to the same object
    • Objects are not duplicated during passing
    • There are typically two instance variables (the argument and parameter) referring to the object

How Private Attributes Could be Accessed

• Private attributes are not accessible from outside
• Private attributes are accessible from inside: - Same object holding the data - Objects of the same class
  • Private attributes are accessible using accessor operations
    • Setters
    • Getters

Getters

• Object point of view: operations performed by the object to return data to outsiders
• User point of view: services called from outside to allow retrieving data from an object
• Getters are usually public, have no parameters, and have a return value

Setters

• Object POV: operations for data being received, allowing outsiders to provide data to the object
• User POV: allow outsiders to provide data that should be stored in the object
• Setters are public, take one parameter and have no return type

Class Constructors

• A class is a blueprint from which objects of the same type are created
• Constructors define the initial states of those objects when created
• ClassName x = new ClassName();
• A class contains at least one constructor, and may contain more

The Default Class Constructor

• If no constructors are defined explicitly, a default constructor is added by the compiler at compile time
• The default constructor takes no parameters, creating an object with empty states
• Ex. ClassName x = new ClassName();

Class Constructors Declaration

• public <constructor name> (<parameters>){ <constructor body> }
• Constructor name: same name as the class
• Parameters: passed to initialize the object state
• Constructor declarations look like method ones, with the same class name and no return type

Overloading

• A method signature is determined by :
  • Name
  • Parameter types
• Overloading methods allows implementing different versions of the same method with method signatures
• Methods share the same name with different parameter lists
  • Ex. Kasree() vs. Kasree(int, int)

Overloading (cont.)

• Overloaded methods are differentiated by the:
  • Number
  • Type of the arguments passed
• It is not possible to declare more than one method with:
  • The same name
  • The same number and type of parameters
• The return type is not considered when differentiating methods; methods must maintain same signature, even with different return types