Java Class Syntax CSIS 3701: Advanced Object Oriented Programming.
20-Jun-15 Additional Java Syntax. 2 Odd corners We have already covered all of the commonly used...
-
date post
20-Dec-2015 -
Category
Documents
-
view
229 -
download
2
Transcript of 20-Jun-15 Additional Java Syntax. 2 Odd corners We have already covered all of the commonly used...
Apr 18, 2023
Additional Java Syntax
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
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)
By default, output is right-justified A negative width means to left-justify the output
Some values for the code are s for strings, d for integers, f for floating point numbers, b for booleans
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):@Overridepublic 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...
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