Editing Java syntax (section)

====Methods====
All the statements in Java must reside within [[Method (computer programming)|methods]]. Methods are similar to functions except they belong to classes. A method has a return value, a name and usually some parameters initialized when it is called with some arguments. Similar to C++, methods returning nothing have return type declared as <code>void</code>. Unlike in C++, methods in Java are not allowed to have [[default argument]] values and methods are usually overloaded instead.

<syntaxhighlight lang="java">
class Foo {
    int bar(int a, int b) {
        return (a*2) + b;
    }

    /* Overloaded method with the same name but different set of arguments */
    int bar(int a) {
        return a*2;
    }
}
</syntaxhighlight>

A method is called using <code>.</code> notation on an object, or in the case of a static method, also on the name of a class.

<syntaxhighlight lang="java">
Foo foo = new Foo();
int result = foo.bar(7, 2); // Non-static method is called on foo

int finalResult = Math.abs(result); // Static method call
</syntaxhighlight>

The <code>throws</code> keyword indicates that a method throws an exception. All checked exceptions must be listed in a comma-separated list.
<syntaxhighlight lang="java">
void openStream() throws IOException, myException { // Indicates that IOException may be thrown
}
</syntaxhighlight>

=====Modifiers=====
* '''<code>abstract</code>''' - [[Abstract method]]s can be present only in [[abstract class]]es, such methods have no body and must be overridden in a subclass unless it is abstract itself.
* '''<code>static</code>''' - Makes the method static and accessible without creation of a class instance. However static methods cannot access non-static members in the same class.
* '''<code>final</code>''' - Declares that the method cannot be overridden in a subclass.
* '''<code>native</code>''' - Indicates that this method is implemented through [[JNI]] in platform-dependent code. Actual implementation happens outside Java code, and such methods have no body.
* '''<code>strictfp</code>''' - Declares strict conformance to [[IEEE 754]] in carrying out floating-point operations.
* '''<code>synchronized</code>''' - Declares that a thread executing this method must acquire monitor. For <code>synchronized</code> methods the monitor is the class instance or <code>java.lang.Class</code> if the method is static.
* Access modifiers - Identical to those used with classes.

======Final methods======
{{Excerpt|final (Java)#Final methods}}

=====Varargs=====
{{Main|Variadic function#In Java}}

This language feature was introduced in [[J2SE 5.0]]. The last argument of the method may be declared as a variable arity parameter, in which case the method becomes a variable arity method (as opposed to fixed arity methods) or simply [[variadic function|varargs]] method. This allows one to pass a variable number of values, of the declared type, to the method as parameters - including no parameters. These values will be available inside the method as an array.

<syntaxhighlight lang="java">
void printReport(String header, int... numbers) { //numbers represents varargs
    System.out.println(header);
    for (int num : numbers) {
        System.out.println(num);
    }
}

// Calling varargs method
printReport("Report data", 74, 83, 25, 96);
</syntaxhighlight>