Skip to main content
This browser is no longer supported.
Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.
Return Type
- Article
- 08/03/2021
- 2 minutes to read
In this article
The return type of a function establishes the size and type of the value returned by the function and corresponds to the type-specifier in the syntax below:
Syntax
function-definition:
declaration-specifiersopt attribute-seqopt declarator declaration-listopt compound-statement
/* attribute-seq is Microsoft-specific */
declaration-specifiers:
storage-class-specifier
declaration-specifiersopt
type-specifier declaration-specifiersopt
type-qualifier declaration-specifiersopt
type-specifier:
void
char
short
int
__int8
/* Microsoft-specific */
__int16
/* Microsoft-specific */
__int32
/* Microsoft-specific */
__int64
/* Microsoft-specific */
long
float
double
signed
unsigned
struct-or-union-specifier
enum-specifier
typedef-name
The type-specifier can specify any fundamental, structure, or union type. If you do not include type-specifier, the return type int
is assumed.
The return type given in the function definition must match the return type in declarations of the function elsewhere in the program. A
function returns a value when a return
statement containing an expression is executed. The expression is evaluated, converted to the return value type if necessary, and returned to the point at which the function was called. If a function is declared with return type void
, a return statement containing an expression generates a warning and the expression is not evaluated.
The following examples illustrate function return values.
typedef struct
{
char name[20];
int id;
long class;
} STUDENT;
/* Return type is STUDENT: */
STUDENT sortstu[ STUDENT a, STUDENT b ]
{
return [ [a.id < b.id] ? a : b ];
}
This
example defines the STUDENT
type with a typedef
declaration and defines the function sortstu
to have STUDENT
return type. The function selects and returns one of its two structure arguments. In subsequent calls to the function, the compiler checks to make sure the argument types are STUDENT
.
Note
Efficiency would be enhanced by passing pointers to the structure, rather than the entire structure.
char *smallstr[ char s1[], char s2[] ]
{
int i;
i = 0;
while [ s1[i] != '\0' && s2[i] != '\0' ]
i++;
if [ s1[i] == '\0' ]
return [ s1 ];
else
return [ s2 ];
}
This example defines a function returning a
pointer to an array of characters. The function takes two character arrays [strings] as arguments and returns a pointer to the shorter of the two strings. A pointer to an array points to the first of the array elements and has its type; thus, the return type of the function is a pointer to type char
.
You need not declare functions with int
return type before you call them, although prototypes are recommended so that correct type checking for
arguments and return values is enabled.
See also
C Function Definitions
Feedback
Submit and view feedback for
A method's declaration provides a lot of information about the method to the compiler, to the runtime system, and to other classes and objects. Included is not only the name of the method, but also such information as the return type of the method, the number and type of the arguments required by the method, and which other classes and objects can call the method.
While this may sound like writing a novel rather than simply declaring a method, most method attributes can be declared implicitly. The only required elements of a method declaration are the method's name, its return type, and a pair of parentheses [ ]. This figure shows the elements of a method declaration.
Each element of a method declaration is further defined below: accessLevel As with member variables, you control which other classes have access to a method using one of four access levels: public, protected, package, and private. Controlling Access to Members of a Class covers access levels in detail.static
As with member variables, static
declares this method as a class method rather than an instance method.
Understanding Instance and Class Members talks about declaring instance and class methods. abstract
An abstract method has no implementation and must be a member of an abstract class. Refer to Writing Abstract Classes and Methods for information about why you might want to
write an abstract method and how such methods affect subclasses. final
A final method cannot be overridden by subclasses. Writing Final Classes and Methods discusses why you might want to write final
methods, how they affect subclasses, and whether you might want to write a final
class instead. native
If you have a significant library of functions
written in another language such as C, you may wish to preserve that investment and use those functions from Java. Methods implemented in a language other than Java are called native methods and are declared as such using the native keyword. Check out our LINKFILE
../../native1.1/index.html ] trail for information about writing native methods. synchronized
Concurrently running threads often invoke methods that operate on the same data. These methods may be declared synchronized to ensure that the threads access information in a thread-safe manner. Synchronizing method calls is covered in Doing Two or More Tasks at Once:
Threads. Take particular note of the section entitled Synchronizing
Threads. returnType Java requires that a method declare the data type of the value that it returns. If your method does not return a value, use the keyword void
for the return type.
Returning a Value from a Method talks about the issues related to returning values from a method. methodName A method name can be any legal Java identifier. You need to consider several issues in regards to Java method names. These are covered in
Method Names. [ paramlist ]
You pass information into a method through its arguments. See the next section, Passing Information into a Method. [throws exceptions]
If your method throws any checked exceptions, your method declaration must indicate the type
of those exceptions. See Handling Errors with Exceptionsfor information. In particular, refer to
Specifying the Exceptions Thrown by a Method. Returning a Value from a Method
You declare a method's return type in its method declaration. Within the body of the method, you use theNow suppose you have a method declared to return areturn
operator to return the value. Any method that is not declaredvoid
must contain areturn
statement. TheStack
class declares theisEmpty
method, which returns aboolean
:The data type of the return value must match the method's return type; you can't return anpublic boolean isEmpty[] { if [items.size[] == 0] return true; else return false; }Object
type from a method declared to return an integer. TheisEmpty
method returns either the boolean valuetrue
orfalse
, depending on the outcome of a test. A compiler error results if you try to write a method in which the return value doesn't match the return type.The
isEmpty
method returns a primitive type. Methods also can return a reference type. For example,Stack
declares thepop
method that returns theObject
reference type:When a method returns an object such aspublic synchronized Object pop[] { int len = items.size[]; Object obj = null; if [len == 0] throw new EmptyStackException[]; obj = items.elementAt[len - 1]; items.removeElementAt[len - 1]; return obj; }pop
does, the class of the returned object must be either a subclass of or the exact class of the return type. This can be a source of confusion, so let's look at this more closely. Suppose you have a class hierarchy whereImaginaryNumber
is a subclass ofjava.lang.Number
, which is, in turn, a subclass ofObject
, as illustrated here:
Number
: Thepublic Number returnANumber[] { . . . }
returnANumber
method can return an ImaginaryNumber
but not an Object
. ImaginaryNumber
"is a" Number
because it's a subclass of Number
. However, an Object
is not necessarily a Number
--it could be a String
or some other type. You also can use interface names as return types. In this case, the object returned must implement the specified interface. Java supports method name overloading so that multiple methods
can share the same name. For example, suppose you are writing a class that can render various types of data [strings, integers, and so on] to its drawing area. You need to write a method that knows how to render each data type. In other languages, you have to think of a new name for each method, for example, drawString
, drawInteger
, drawFloat
, and so on. In Java, you can use the same name for all of the drawing methods but pass a different type of parameter to each method. So, in your data rendering
class, you can declare three methods named draw, each of which takes a different type of parameter:
Overloaded methods are differentiated by the number and type of the arguments passed into the method. In the code sample,class DataRenderer { void draw[String s] { . . . } void draw[int i] { . . . } void draw[float f] { . . . } }
draw[String s]
and draw[int i]
are distinct and unique methods because they require different argument types. You cannot declare more than one method with the same name and the same number and type of arguments because the compiler cannot differentiate
them. So, draw[String s]
and draw[String t]
are identical and result in a compiler error. A class may override a method in its superclass. The overriding method must have the same name, return type, and parameter list as the method it overrides. Overriding Methods shows you how to override methods.