Teach Yourself Java in 21 Days tyjxax.htm

- A

- Language Summary

- Reserved Words
- Comments
- Operators
- Objects
- Arrays
- Loops and Conditionals
- Class Definitions
- Method and Constructor Definitions
- Packages, Interfaces, and Importing
- Exceptions and Guarding

#
A

## Language Summary

by Laura Lemay

This appendix contains a summary or quick reference for the Java language, as described in this book.

Technical Note: This is not a grammar overview, nor is it a technical overview of the language itself. It's a quick reference to be used after you already know the basics of how the language works. If you need a technical description of the language, your best bet is to visit the Java Web site (http://java.sun.com) and download the actual specification, which includes a full BNF grammar.

Language keywords and symbols are shown in a monospace font. Arguments and other parts to be substituted are in italic monospace.

Optional parts are indicated by brackets (except in the array syntax section). If there are several options that are mutually exclusive, they are shown separated by pipes ([|]) like this:

    [ public | private | protected ] type varname

### Reserved Words

The following words are reserved for use by the Java language itself (some of them are reserved but not currently used). You cannot use these words to refer to classes, methods, or variable names:

### Comments

/* this is a multiline comment */

// this is a single-line comment

/** Javadoc comment */

number | Type int
number[l | L] | Type long
0xhex | Hex integer
0Xhex | Hex integer
0octal | Octal integer
[ number ].number | Type double
number[ f | f] | Type float
number[ d | D] | Type double
[ + | - ] number | Signed
numberenumber | Exponent
numberEnumber | Exponent
'character' | Single character
"characters" | String
"" | Empty string
\b | Backspace
\t | Tab
\n | Line feed
\f | Form feed
\r | Carriage return
\" | Double quote
\' | Single quote
\\ | Backslash
\uNNNN | Unicode escape (NNNN is hex)
true | Boolean
false | Boolean
[ byte | short | int | long ] varname | Integers (pick one type)
[ float | double ] varname | Floats (pick one type)
char varname | Characters
boolean varname | Boolean
classname varname | Class types
interfacename varname | Interface types
type varname, varname, varname | Multiple variables

The following options are available only for class and instance variables. Any of these options can be used with a variable declaration:

[ static ] variableDeclaration | Class variable
[ final ] variableDeclaration | Constants
[ public | private | protected ] variableDeclaration | Access control
[volatile] varname | Modified asynchronously
[transient] varname | Not persistent (not yet implemented)
variable = value | Assignment
variable++ | Postfix Increment
++variable | Prefix Increment
variable—— | Postfix Decrement
——variable | Prefix Decrement
variable += value | Add and assign
variable —= value | Subtract and assign
variable /= value | Multiply and assign
variable –= value | Divide and assign
variable %= value | Modulus and assign
variable &= value | AND and assign
variable |= value | OR and assign
variable ^= value | XOR and assign
variable <<= value | Left-shift and assign
variable >>= value | Right-shift and assign
variable >>>= value | Zero-fill right-shift and assign

### Operators

arg + arg | Addition
arg — arg | Subtraction
arg * arg | Multiplication
arg / arg | Division
arg % arg | Modulus
arg < arg | Less than
arg > arg | Greater than
arg <= arg | Less than or equal to
arg >= arg | Greater than or equal to
arg == arg | Equal
arg != arg | Not equal
arg && arg | Logical AND
arg || arg | Logical OR
! arg | Logical NOT
arg & arg | AND
arg | arg | OR
arg ^ arg | XOR
arg << arg | Left-shift
arg >> arg | Right-shift
arg >>> arg | Zero-fill right-shift
~ arg | Complement
(type)thing | Casting
arg instanceof class | Instance of
test ? trueOp : falseOp | Tenary (if) operator

### Objects

new class() | Create new instance
new class(arg,arg,arg...) | New instance with parameters
object.variable | Instance variable
object.classvar | Class variable
Class.classvar | Class variable
object.method() | Instance method (no args)
object.method(arg,arg,arg...) | Instance method
object.classmethod() | Class method (no args)
object.classmethod(arg,arg,arg...) | Class method
Class.classmethod() | Class method (no args)
Class.classmethod(arg,arg,arg...) | Class method

### Arrays

Note: The brackets in this section are parts of the array creation or access statements. They do not denote optional parts as they do in other parts of this appendix.

type varname[] | Array variable
type[] varname | Array variable
new type[numElements] | New array object
array[index] | Element access
array.length | Length of array

### Loops and Conditionals

if ( test) block | Conditional
<tb rule>if ( test ) block |
<tb rule>else block | Conditional with else
switch (test) { | switch (only with integer or char types)
case value : statements |
case value : statements |
... |
default : statement |
<tb rule>} |
<tb rule>for (initializer; | for loop
test; change ) block |
<tb rule>while ( test ) block | while loop
do block | do loop
<tb rule>while (test) |
<tb rule>break [ label ] | break from loop or switch
<tb rule>continue [ label ] | continue loops
<tb rule>label: | Labeled loops

### Class Definitions

class classname block | Simple Class definition

Any of the following optional modifiers can be added to the class definition:

[ final ] class classname block | Cannot be subclassed
[ abstract ] class classname block | Cannot be instantiated
[ public ] class classname block | Accessible outside package
class classname [ extends Superclass ] block | Define superclass
class classname [ implements interfaces ] block | Implement one or more interfaces

### Method and Constructor Definitions

The basic method looks like this, where returnType is a type name, a class name, or void.

returnType methodName() block | Basic method
returnType methodName(parameter, parameter, ...) block | Method with parameters

Method parameters look like this:

type parameterName

Method variations can include any of the following optional keywords:

[ abstract ] returnType methodName() block | Abstract method
[ static ] returnType methodName() block | Class method
[ native ] returnType methodName() block | Native method
[ final ] returnType methodName() block | final method
[ synchronized ] returnType methodName() block | Thread lock before executing
[ public | private | protected ] | Access control
returnType methodName() |

Constructors look like this:

classname() block | basic constructor
classname(parameter, parameter, parameter...) block | constructor with parameters
[ public | private | protected] classname() block | Access control

In the method/constructor body you can use these references and methods:

this | Refers to current object
super | Refers to superclass
super.methodName() | Call a superclass's method
this(...) | Calls class's constructor
super(...) | Calls superclass's constructor
return [ value ] | Returns a value

### Packages, Interfaces, and Importing

import package.className | Imports specific class name
import package.* | Imports all public classes in package
package packagename | Classes in this file belong
| to this package
interface interfaceName [ extends anotherInterface ] block |
[ public ] interface interfaceName block |
[ abstract ] interface interfaceName block |

### Exceptions and Guarding

synchronized ( object ) block | Waits for lock on object
try block | Guarded statements
catch ( exception ) block | Executed if exception is thrown
[ finally block ] | Cleanup code
try block | Same as previous example (can
[ catch ( exception ) block ] | use optional catch or finally,
finally block | but not both)

abstract

boolean

break

byte

case

catch

char

class

const

continue

do

double

else

extends

final

finally

float

for

goto

if

implements

import

instanceof

int

interface

long

native

new

null

package

private

protected

public

return

short

static

super

switch

synchronized

this

throw

throws

transient

try

void

volatile

while