Additional Java Syntax 23-Nov-18

Odd corners We have already covered all of the commonly used Java syntax Some Java features are seldom used, because: They are needed in only a few specialized situations, or It’s just as easy to do without them, or Few people know about them You should be at least aware of these features, because: You may encounter them in someone else’s code They may do something you will need someday There are also a few useful features that we just didn’t get around to, or didn’t discuss in sufficient detail

Reserved words A reserved word, or keyword, is one that has a special meaning, and you may not use it as a name Examples: if, while, class, package There are also important keywords that we have not talked about: native, strictfp, transient, volatile And there are keywords that are not used (but you still can’t use them as names): const, goto

Unused keywords const is used in some languages to declare constants Java has this keyword, but used final instead A final variable does not have to be given a value when it is assigned, but it can be given a value only once: final int lesser; if (x < y) lesser = x; else lesser = y; // legal! The keyword final is also used to indicate that: A class cannot be subclassed A method cannot be overridden It does not indicate that a variable cannot be shadowed Some languages allow you to put a label on a statement, and to goto (jump to) that statement from elsewhere in the program Java reserves the goto keyword but does not use it

native Sometimes you may wish to use a method that is defined in some other language (such as C or C++) The method modifier native tells Java to link to this “native” method To do this, you need to look into the JNI (Java Native Interface) API Drawbacks: You lose platform independence For security reasons, you cannot use native code in an applet

strictfp While Java is extremely platform independent, it isn’t perfect Due to differing machine implementations of floating-point arithmetic, floating-point results may be off by a couple of the least significant bits There is a standard, IEEE 754, that specifies exactly how floating-point arithmetic should be carried out It is computationally much less efficient to meet this standard if the hardware does not already meet it If this degree of platform independence is required, you can use strictfp in front of any class, interface, or method declaration A constructor cannot be declared FP-strict; to do this, you should designate the entire class as FP-strict A method in an interface cannot be declared FP-strict, because that’s implementation information, not an interface property native methods cannot be declared FP-strict Every compile-time constant expression is automatically FP-strict

transient You can serialize an object (turn it into a linear sequence of bytes) to write it to an output stream, then de-serialize it to read it in again Every field in the object must itself be Serializable If an object has fields that are not Serializable, and you don’t care that much about them anyway, you can declare them as transient transient variables don’t get serialized or de-serialized

volatile When the compiler optimizes your program, it may keep a variable in a register for several steps in a computation If another Thread might modify that variable, and you want to always get the current value (as set by some other Thread) of that variable, you can mark it as volatile Local variables never need to be marked volatile

The for loop The form of a for loop is: for (initialization; condition; step) body The initialization may be a declaration or expression, or a comma-separated list of expressions Recall that = is an operator, so var = expr is an expression The step may be an expression or a comma-separated list of expressions The initialization, condition, and step may be empty--but the semicolons may not be omitted An empty condition is equivalent to true Hence, for(;;); is an infinite loop Example: for (i = 0, j = a.length - 1; j > i; i++, j--) swap(a, i, j);

synchronized You need synchronized whenever you may have multiple Threads accessing the same object at the same time A Thread gets a lock on a synchronized object before it uses it, and releases the lock (so another Thread can use the data) when it is done You can synchronize various ways: synchronized(object) statement; synchronized instanceMethod(parameters) {body} is equivalent to instanceMethod(parameters) {synchronized(this) {body}} synchronized staticMethod(parameters) {body} is equivalent to staticMethod(parameters) {synchronized(class) {body}} Constructors and initializers cannot be synchronized Non-synchronized methods can execute at the same time as synchronized methods, on the same object

Labeled statements A labeled statement has the syntax label : statement The label has the same syntax as a variable name The scope of the label is the statement A break statement is only legal within a loop or switch statement and has one of the forms break; // exit innermost enclosing loop or switch break label; // exit labeled enclosing loop or switch A continue statement is only legal within a loop, and has one of the forms: continue; // resume from test of innermost loop continue label; // resume from test of labeled loop Any statement may be labeled, but it only makes sense on a loop or switch statement

Array initialization and literals Array initialization and array literals are very convenient, and are less well-known than they ought to be Initialization examples: int primes[ ] = {2, 3, 5, 7, 11, 13, 19}; String languages[ ] = { "Java", "C", "C++" }; int game[ ][ ] = { {3, 7}, {5, 4} }; Examples of array literals: myPrintArray(new int[] {2, 3, 5, 7, 11}); int foo[ ]; foo = new int[ ]{42, 83}; Person people[ ] = { new Person("Alice"), new Person("Bob"), new Person("Carla"), new Person("Don") };

Initialization blocks The fields of an object may be initialized when they are declared, or in a constructor, or both class Example { int x = 5; // done before constructor int y; Example(int n) { x = y = n; } } They may also be declared in an initialization block, which can contain statements as well as declarations class Example { int f = 1; { for (int i = 2; i <= 10; i++) f = f * i; } } “Instance” initialization blocks are executed when an object is created They are executed in the order in which they occur

Static initialization blocks static initialization blocks are like ordinary initialization blocks, except that they are executed once only, when the class is first loaded Example: class UsesRandomNumbers { static double[ ] values = new double[100]; static { for (int i = 0; i < values.length; i++) { values[i] = Math.random(); } } ... }

Expression statements An expression statement is an expression followed by a semicolon Only certain expressions may be used this way: Assignment expressions, such as x = 0; Increment and decrement expressions, such as x++; Method call expressions You can call a method that returns a value and just ignore that value Object creation expressions As with a method, you can ignore the returned Object Other expression statements are flagged by Java as an error

Method call expressions A method call (which is an expression) must have one of these five forms: method(parameters) super.method(parameters) Class.method(parameters) Class.super.method(parameters) object.method(parameters)

Escape sequences An escape sequence is used to specify a particular character (in a char literal or String literal) You probably already know a few escape sequences, such as \n for newline and \" for double quote Escape sequences can also be written as three-digit octal numbers \ddd (ASCII) or four-digit hexadecimal numbers \udddd (Unicode)

Interfaces An interface declaration has the form modifier interface interfaceName extends-clause { field-descriptions; method-descriptions; class-declarations; interface-declaration; } At the top level, the modifier can be public or absent (but public is always understood) Within a class or interface, the modifier can be static or absent (but static is always understood) and can be public, protected, or private An interface can extend a class or another interface A field-description is always static, final, and public, and must have an initial value method-descriptions are always abstract and public class-declarations are always static and public

Static import facility import static org.iso.Physics.*; class Guacamole { public static void main(String[] args) { double molecules = AVOGADROS_NUMBER * moles; ... } } You no longer have to say Physics.AVOGADROS_NUMBER Are you tired of typing System.out.println(something); ? Do this instead: import static java.lang.System.out; out.println(something);

varargs You can create methods and constructors that take a variable number of arguments public void foo(int count, String... cards) { body } The “...” means zero or more arguments (here, zero or more Strings) Call with foo(13, "ace", "deuce", "trey"); Only the last argument can be a vararg To iterate over the variable arguments, use the new for loop: for (String card : cards) { loop body }

java.util.Scanner Java finally has a fairly simple way to read input Scanner sc = Scanner.create(System.in); boolean b = sc.nextBoolean(); byte by = sc.nextByte(); short sh = sc.nextShort(); int i = sc.nextInt(); long l = sc.nextLong(); float f = sc.nextFloat(); double d = sc.nextDouble(); String s = sc.nextLine(); By default, whitespace acts as a delimiter, but you can define other delimiters with regular expressions

java.util.Formatter Java now has a way to produce formatted output, based on the C printf statement String line; int i = 1; while ((line = reader.readLine()) != null) { System.out.printf("Line %d: %s%n", i++, line); } There are about 45 different format specifiers (such as %d and %s), most of them for dates and times

Annotations Annotations allow you to mark methods as overridden, or deprecated, or to turn off compiler warnings for a method Example (in the Item class): @Override public boolean equals(Item other) { ... } Gives a syntax error because the signature is wrong Other provided annotations are @Deprecated and @Suppresswarnings(type) You can create other kinds of annotations

Things that aren’t always obvious You can shadow a field... class Foo {int i; ... {int i; ...} } ...but you can’t shadow a local variable or parameter: class Foo {...{int i; ... {int i; ...} } } // illegal In a conditional expression, e1 ? e2 : e3, e2 and e3 do not have to have the same type e2 and e3 must both be numeric, or be compatible reference types When creating an anonymous inner class from an interface, new Interface() {class-body}, the argument list must be empty Other odds and ends...

The End “Perfection is achieved not when you have nothing more to add, but when you have nothing left to take away.” --Antoine de Saint-Exupery