Java Methods

By J. W. Rider

Java Methods

ModularityDeclaring methods– Header, signature, prototype

StaticVoidLocal variables– this

ReturnReentrancyMethod-like structures– Constructors, static initializers

Modularity in Java

Packages are composed of one or more classes or interfaces.Classes and interfaces are composed of one more members; either data members (fields) or function members (methods).Methods are composed of statements; either declarations (local variables) or executable statements.

Object-oriented methods

Methods define the kinds of messages (and parameters) which objects of a particular class may receive.All object-oriented behavior is implemented through methods.

General method declarations

Headerqualifiers return-type method-name

( formal-parameters ) throws-clause

Body{

Statements;

}

Application main() example

public static void main(String[] args)

{

System.out.println(“Hello, world!”);

}

Signature

Method-name (formal-parameter-types)Does not include the return-typeWithin any class definition, the signature must be unique

Prototype

Return-type method-name (formal-parameter-types)The prototype defines the kinds of messages to which the class or its instances respond.

Qualifiers

Scope (external visibility)– public, protected, private

static

Miscellaneous– final, abstract, native

The static qualifier

The static qualifier divides class members into two groups:– Those members which are shared by all instances of

the class and exist whether or not any instances exist.

– Those members which exist in individual objects and are independent from the same named members in other instances of the same class

Static constraints

A static field defines a single variable shared by all instances of the class.A non-static field defines a variable that is replicated whenever a new instances of the class is constructed.A static method may not make an unqualified reference to any static member (field or method).A non-static method may make unqualified references to both static and non-static members. – May also use the reserved this variable.

The this variable

Within each non-static method, Java automatically creates a reference variable named this that references the “current” instance of the class for which the method has been invoked.Whenever a non-static member is referenced within a non-static method, this is understood to be the target of the message.

Every reference in Java must be handled through either a class (for static references) or through an object.

Return types

The return type of a method may be any type used for a variable declaration.– These methods may be invoked wherever an

expression is permitted in an executable statement or declaration.

The return type of a method may also be void.– These methods may be invoked only by an

executable statement.

The void type

May only be used as a return-type for a method.– Do not try to use void as a variable type.

Void indicates that the method does not return a value.– Such methods are used for their “side-effects,” such

as output and state variable changes.

The return statement

For void methods:– The return; statement is optional

For other methods:– The method must terminate by a statement of the

form “return expression;”– The expression must evaluate to the same type as

the return-type of the method

Formal parameters

Variable declarations within the header of a method:– Enclosed by parentheses– Separated by commas– May not be initialized (no “default” parameter values in Java)– The types of the variables are used to identify the method– The names of the variables may only be used within the

method bodyEven if no arguments are to be passed to a method, empty parentheses are used to distinguish between a field and method.

Method references

Method declarations represent potential behavior. This behavior does not occur until the method is referenced elsewhere.

methodname( actual-arguments )

Actual arguments

Expressions, enclosed within parentheses and separated by commas.Java uses the expression types to determine which one of several overloaded methods of the same name should be invoked.Java uses the expression values as initializations for the formal parameters.

Invocation examples

Void methods– doHello();– object1.setInit(5);

Return-value methods– x=object4.getInit();– setInit(object2.getStatus()); // nesting– object3.getBase().doHello(); // chaining

Static methods– obj5.method(); // implicit– MyClass.method(); // explicit

Multiple invocations

At any given point in time, a single method may have been invoked through multiple locations in a program.Every invocation gets its own copy of the methods local variables (including the formal parameters)A method may even call invoke itself. This is called recursion.

Related structures

Two other places where executable statements may be located:– Constructors– Static initializers

Constructors

A constructor is invoked every time an instance of an object is created (e.g., with the new operator.)Constructor declarations are like ordinary method declarations with two important exceptions:– There is no return type; not even void– The name of the constructor is always the name of the class

Static initializers (Advanced!)

Static initializers are invoked when a class is loaded into memory (before creating a single instance of the class)The header of a static initializer consists of the reserved word staticMultiple static initializers may be declared within a class