Methods, arguments and return values

and
return values

Up

until now, the term

has been used to describe a named subroutine. The term that is more commonly

used in Java is

as in “a way to do something.” If you want, you can continue

thinking in terms of functions. It’s really only a syntactic difference,

but from now on “method” will be used in this book rather than

“function.”

Methods

in Java determine the messages an object can receive. In this section you will

learn how simple it is to define a method.

The

fundamental parts of a method are the name, the arguments, the return type, and

the body. Here is the basic form:

/* Method body */

}

The

return type is the type of the value that pops out of the method after you call

it. The method name, as you might imagine, identifies the method. The argument

list gives the types and names for the information you want to pass into the

method.

Methods

in Java can be created only as part of a class. A method can be called only for

an object,

and that object must be able to perform that method call. If you try to call

the wrong method for an object, you’ll get an error message at compile

time. You call a method for an object by naming the object followed by a period

(dot), followed by the name of the method and its argument list, like this:

.

For example, suppose you have a method

that takes no arguments and returns a value of type

.

Then, if you have an object called

for which

can be called, you can say this:

The

type of the return value must be compatible with the type of

.

This

act of calling a method is commonly referred to as

.

In the above example, the message is

and the object is

.

Object-oriented programming is often summarized as simply “sending

messages to objects.”

The
argument list

The

method argument list specifies what information you pass into the method. As

you might guess, this information – like everything else in Java –

takes the form of objects. So, what you must specify in the argument list are

the types of the objects to pass in and the name to use for each one. As in any

situation in Java where you seem to be handing objects around, you are actually

passing handles.

The type of the handle must be correct, however. If the argument is supposed to

be a

,

what you pass in must be a string.

Consider

a method that takes a string as its argument. Here is the definition, which

must be placed within a class definition for it to compile:

return s.length() * 2;

}

This

method tells you how many bytes are required to hold the information in a

particular

(Each

in

a

is

16 bits, or two bytes, long, to support Unicode characters.) The argument is of

type

and is called

.

Once

is passed into the method, you can treat it just like any other object. (You

can send messages to it.) Here, the

method is called, which is one of the methods for

s;

it returns the number of characters in a string.

You

can also see the use of the

keyword, which does two things. First, it means “leave the method,

I’m done.” Second, if the method produces a value, that value is

placed right after the

statement. In this case, the return value is produced by evaluating the

expression

.

You

can return any type you want, but if you don’t want to return anything at

all, you do so by indicating that the method returns

.

Here are some examples:

boolean flag() { return true; }
float naturalLogBase() { return 2.718; }
void nothing() { return; }
void nothing2() {}

When

the return type is

,

then the

keyword is used only to exit the method, and is therefore unnecessary when you

reach the end of the method. You can return from a method at any point, but if

you’ve given a non-

return

type then the compiler will ensure that you return the appropriate type of

value regardless of where you return.

At

this point, it can look like a program is just a bunch of objects with methods

that take other objects as arguments and send messages to those other objects.

That is indeed much of what goes on, but in the following chapter you’ll

learn how to do the detailed low-level work by making decisions within a

method. For this chapter, sending messages will suffice.

methods, which you’ll learn about soon, can be called

,

without an object.

With the usual exception of the aforementioned “special” data types

,

,

,

,

,

and

.

In general, though, you pass objects, which really means you pass handles to

objects.

|

|