There are two basic kinds of methods in Java: static methods and instance methods. This sample shows how the two kinds can achieve comparable functionality.
package essentials;
class Point {
int x;
private int y;
Point(int , int pY) {
x = pX;
y = pY;
}
/* An instance method to move the current point. */
void move1(int deltaX, int deltaY) {
.x += deltaX;
this.y += deltaY;
}
/* A static method to move the point argument. */
void move2(Point point, int deltaX, int deltaY) {
deltaX;
point.y += deltaY;
}
/* An instance method that returns a new point at a different position
* from the current point. */
(int deltaX, int deltaY) {
return new Point(this.x + deltaX, this.y + deltaY);
}
}
/* This class serves as the client code calling various methods. */
public class Methods {
public static void main(String[] args) {
IO.println("Absolute value of -5 is " + (-5));
String hello = "Hello";
System.out.println("Length of Hello\" is " + );
Point point = new Point (3,4);
// Moving point with a static method.
Point.move2(, 2, 2);
// Moving point with an equivalent instance method
.move1(2, 2);
// Creating a new, moved point
Point point.copyAndMove(2, 2);
}
}
The fields in this class are private so that code in other classes must access them via methods.
The fields in this class are private so that code in other classes must access them via methods.
This example uses the simple naming convention to prefix parameter names with the letter p to
avoid a conflict with the field names.
This example uses the simple naming convention to prefix parameter names with the letter p to
avoid a conflict with the field names.
To include a quote character within a string, it is necessary to escape it by preceding it with a backslash character.
To include a quote character within a string, it is necessary to escape it by preceding it with a backslash character.
In this static method call, point is an explicit argument, placed in the list of arguments between
parentheses.
In this static method call, point is an explicit argument, placed in the list of arguments between
parentheses.
In this instance method call, point is an implicit argument, placed before the
method call.
In this instance method call, point is an implicit argument, placed before the
method call.
The copyAndMove method returns a value (a new Point instance). This instance
is then stored in the other variable.
The copyAndMove method returns a value (a new Point instance). This instance
is then stored in the other variable.
The declaration of a method includes, at a minimum, a return type
(or the keyword void if there's nothing to return),
a name (move1), a list of formal parameters, and a body comprising
the code between curly braces.
This method is an instance method because its signature is not prefixed with
the keyword static. In addition to the formal parameters, an instance
method has an additional parameter called the implicit parameter, which
is the object upon which the method is called. This parameter is available
through the keyword this in the body of the method.
The declaration of a method includes, at a minimum, a return type
(or the keyword void if there's nothing to return),
a name (move1), a list of formal parameters, and a body comprising
the code between curly braces.
This method is an instance method because its signature is not prefixed with
the keyword static. In addition to the formal parameters, an instance
method has an additional parameter called the implicit parameter, which
is the object upon which the method is called. This parameter is available
through the keyword this in the body of the method.
Although the keyword this is optional, it's used here
to emphasize than an instance method operated on an implicit
parameter (the "current" object), available through the this keyword.
Although the keyword this is optional, it's used here
to emphasize than an instance method operated on an implicit
parameter (the "current" object), available through the this keyword.
A static method is declared like an instance method, but with the keyword
static placed before the return type. A static method is not associated
with any object, so all the data is needs to access must be provided
through explicit parameters.
In this example, the current object is no longer available through
the this keyword, so we add it to the list of formal parameters.
A static method is declared like an instance method, but with the keyword
static placed before the return type. A static method is not associated
with any object, so all the data is needs to access must be provided
through explicit parameters.
In this example, the current object is no longer available through
the this keyword, so we add it to the list of formal parameters.
When placed before the return type of a method declaration, the static keyword
specifies that the method is a static method.
When placed before the return type of a method declaration, the static keyword
specifies that the method is a static method.
This method has a side effect on an explicit parameter. This is normally not a best practice because it can make the code harder to understand. In production code, the instance method would be a better choice.
This method has a side effect on an explicit parameter. This is normally not a best practice because it can make the code harder to understand. In production code, the instance method would be a better choice.
Because this method declaration includes a return type (as opposed to void),
the body of the method must include at least one return statement.
Because this method declaration includes a return type (as opposed to void),
the body of the method must include at least one return statement.
To avoid any ambiguity with move methods that have a side effect on the
input, this method's name makes it clear that the method creates a new
object different from the implicit parameter.
To avoid any ambiguity with move methods that have a side effect on the
input, this method's name makes it clear that the method creates a new
object different from the implicit parameter.
Math#abs is an example of a static method from the Java Development Kit (JDK). Notice how there
is no object provided to this method. Math is just the name of the
class in which the method is located.
Math contains methods for performing basic
numeric operations such as the elementary exponential, logarithm,
square root, and trigonometric functions.
int value.
If the argument is not negative, the argument is returned.
If the argument is negative, the negation of the argument is returned.
Math#abs is an example of a static method from the Java Development Kit (JDK). Notice how there
is no object provided to this method. Math is just the name of the
class in which the method is located.
Math contains methods for performing basic
numeric operations such as the elementary exponential, logarithm,
square root, and trigonometric functions.
Unlike some of the numeric methods of class
StrictMath, all implementations of the equivalent
functions of class Math are not defined to return the
bit-for-bit same results. This relaxation permits
better-performing implementations where strict reproducibility is
not required.
By default many of the Math methods simply call
the equivalent method in StrictMath for their
implementation. Code generators are encouraged to use
platform-specific native libraries or microprocessor instructions,
where available, to provide higher-performance implementations of
Math methods. Such higher-performance
implementations still must conform to the specification for
Math.
The quality of implementation specifications concern two
properties, accuracy of the returned result and monotonicity of the
method. Accuracy of the floating-point Math methods is
measured in terms of ulps, units in the last place. For a given floating-point format, an
ulp of a specific real number value is
the distance between the two floating-point values bracketing that
numerical value. When discussing the accuracy of a method as a
whole rather than at a specific argument, the number of ulps cited
is for the worst-case error at any argument. If a method always
has an error less than 0.5 ulps, the method always returns the
floating-point number nearest the exact result; such a method is
correctly rounded. A correctly rounded
method is generally the best a floating-point approximation can be;
however, it is impractical for many floating-point methods to be
correctly rounded. Instead, for the Math class, a larger
error bound of 1 or 2 ulps is allowed for certain methods.
Informally, with a 1 ulp error bound, when the exact result is a
representable number, the exact result should be returned as the
computed result; otherwise, either of the two floating-point values
which bracket the exact result may be returned. For exact results
large in magnitude, one of the endpoints of the bracket may be
infinite. Besides accuracy at individual arguments, maintaining
proper relations between the method at different arguments is also
important. Therefore, most methods with more than 0.5 ulp errors
are required to be semi-monotonic: whenever
the mathematical function is non-decreasing, so is the
floating-point approximation, likewise, whenever the mathematical
function is non-increasing, so is the floating-point approximation.
Not all approximations that have 1 ulp accuracy will automatically
meet the monotonicity requirements.
The platform uses signed two's complement integer arithmetic with
int and long primitive types. The developer should
choose the primitive type to ensure that arithmetic operations
consistently produce correct results, which in some cases means the
operations will not overflow the range of values of the
computation. The best practice is to choose the primitive type and
algorithm to avoid overflow. In cases where the size is int
or long and overflow errors need to be detected, the
methods whose names end with Exact throw an
ArithmeticException when the results overflow.
sin, cos, tan, asin, acos, atan, exp, expm1, log, log10, log1p,
sinh, cosh, tanh, hypot, and pow. (The sqrt
operation is a required part of IEEE 754 from a different section
of the standard.) The special case behavior of the recommended
operations generally follows the guidance of the IEEE 754
standard. However, the pow method defines different
behavior for some arguments, as noted in its specification. The IEEE 754 standard defines its operations to be
correctly rounded, which is a more stringent quality of
implementation condition than required for most of the methods in
question that are also included in this class.int value.
If the argument is not negative, the argument is returned.
If the argument is negative, the negation of the argument is returned.
Note that if the argument is equal to the value of Integer.MIN_VALUE, the most negative representable int
value, the result is that same value, which is negative. In
contrast, the absExact(int) method throws an
ArithmeticException for this value.
a - the argument whose absolute value is to be determinedString#length is an example of an instance method from the Java Development Kit (JDK).
Notice how we are calling it by using the dot operator on the object stored in the hello
variable. This is the implicit argument to the method. Inside the body of the method,
the object stored in variable hello becomes the object available through the this
keyword.
String#length is an example of an instance method from the Java Development Kit (JDK).
Notice how we are calling it by using the dot operator on the object stored in the hello
variable. This is the implicit argument to the method. Inside the body of the method,
the object stored in variable hello becomes the object available through the this
keyword.
length in interface CharSequenceSystem.in
and System.out for line-oriented input and output.
System.in
and System.out for line-oriented input and output.
The readln() and readln(String) methods decode bytes read from
System.in into characters. The charset used for decoding is specified by the
stdin.encoding property. If this property is not present,
or if the charset it names cannot be loaded, then UTF-8 is used instead. Decoding
always replaces malformed and unmappable byte sequences with the charset's default
replacement string.
Charset decoding is set up upon the first call to one of the readln methods.
Decoding may buffer additional bytes beyond those that have been decoded to characters
returned to the application. After the first call to one of the readln methods,
any subsequent use of System.in results in unspecified behavior.
readln
methods to read from the standard input, and they will not mix these calls with
other techniques for reading from System.in. The effect is as if println(obj)
had been called on System.out.
obj - the object to print, may be nullString class represents character strings. All
string literals in Java programs, such as "abc", are
implemented as instances of this class.
String class represents character strings. All
string literals in Java programs, such as "abc", are
implemented as instances of this class.
Strings are constant; their values cannot be changed after they are created. String buffers support mutable strings. Because String objects are immutable they can be shared. For example:
String str = "abc";
is equivalent to:
char data[] = {'a', 'b', 'c'};
String str = new String(data);
Here are some more examples of how strings can be used:
System.out.println("abc");
String cde = "cde";
System.out.println("abc" + cde);
String c = "abc".substring(2, 3);
String d = cde.substring(1, 2);
The class String includes methods for examining
individual characters of the sequence, for comparing strings, for
searching strings, for extracting substrings, and for creating a
copy of a string with all characters translated to uppercase or to
lowercase. Case mapping is based on the Unicode Standard version
specified by the Character class.
The Java language provides special support for the string concatenation operator ( + ), and for conversion of other objects to strings. For additional information on string concatenation and conversion, see The Java Language Specification.
Unless otherwise noted, passing a null argument to a constructor
or method in this class will cause a NullPointerException to be
thrown.
A String represents a string in the UTF-16 format
in which supplementary characters are represented by surrogate
pairs (see the section Unicode
Character Representations in the Character class for
more information).
Index values refer to char code units, so a supplementary
character uses two positions in a String.
The String class provides methods for dealing with
Unicode code points (i.e., characters), in addition to those for
dealing with Unicode code units (i.e., char values).
Unless otherwise noted, methods for comparing Strings do not take locale
into account. The Collator class provides methods for
finer-grain, locale-sensitive String comparison.
javac compiler
may implement the operator with StringBuffer, StringBuilder,
or java.lang.invoke.StringConcatFactory depending on the JDK version. The
implementation of string conversion is typically through the method toString,
defined by Object and inherited by all classes in Java.System class contains several useful class fields
and methods. It cannot be instantiated.
Among the facilities provided by the System class
are standard input, standard output, and error output streams;
access to externally defined properties and environment
variables; a means of loading files and libraries; and a utility
method for quickly copying a portion of an array.System class contains several useful class fields
and methods. It cannot be instantiated.
Among the facilities provided by the System class
are standard input, standard output, and error output streams;
access to externally defined properties and environment
variables; a means of loading files and libraries; and a utility
method for quickly copying a portion of an array.stdout.encoding.
stdout.encoding.
For simple stand-alone Java applications, a typical way to write a line of output data is:
System.out.println(data)
See the println methods in class PrintStream.
print(String) and then
println().print(String) and then
println().x - The String to be printed.