Transcript Uncommon Syntax

Additional Java Syntax
7-Apr-16
Odd corners


We have already covered all of the commonly used Java syntax
Some Java features are seldom used, because:




You should be at least aware of these features, 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 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
2
Reserved words

A reserved word, or keyword, is one that has a special
meaning, and you may not use it as a name


There are also important keywords that we have not
talked about:


Examples: if, while, class, package
native, strictfp, transient, volatile
And there are keywords that are not used (but you still
can’t use them as names):

const, goto
3
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
4
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
5
strictfp

While Java is extremely platform independent, it isn’t perfect


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




Due to differing machine implementations of floating-point arithmetic,
floating-point results may be off by a couple of the least significant bits
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
6
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
7
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
8
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);
9
Bit manipulation

The bit manipulation operations are designed to work
on int variables







& bitwise “and”
| bitwise “inclusive or”
^ bitwise “exclusive or”
~ bitwise complement
<< left shift, zero fill
>> right shift, sign bit extension
>>> right shift, zero fill
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



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:



The label has the same syntax as a variable name
The scope of the label is the statement
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


They may also be declared in an initialization block, which can
contain statements as well as declarations



class Example {
int x = 5; // done before constructor
int y;
Example(int n) { x = y = n; }
}
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


Object creation expressions


You can call a method that returns a value and just ignore that value
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
Formatted output


Java 5 has a printf method, similar to that of C
Each format code is % width code

The width is the number of characters that are output (with
blank fill)



Some values for the code are s for strings, d for integers, f
for floating point numbers, b for booleans


By default, output is right-justified
A negative width means to left-justify the output
For floating point numbers, the width has the form total.right, where
total is the total width and right is the number of digits to the right of
the decimal point
There are a huge number of options for formatting dates,
which we won’t cover
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 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
24
Things that aren’t always obvious

You can shadow a field...


...but you can’t shadow a local variable or parameter:




class Foo {...{int i; ... {int i; ...} } } // illegal
In a conditional expression, e1 ? e2 : e3,


class Foo {int i; ... {int i; ...} }
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
26