1. Additional Java Syntax
23-Nov-18

2. 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

3. 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

4. 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

5. 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

6. 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

7. 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

8. 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

9. 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);

10. 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

11. 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

12. 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") };

13. 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

14. 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(); } } }

15. 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

16. 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)

17. 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)

18. 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

19. 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);

20. 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 }

21. 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

22. 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

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

24. 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...

25. 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