| Click here to support our advertisers

SHOPPING
JOB BANK
CLASSIFIEDS
DIRECTORIES
REFERENCE Online Library
LEARNING CENTER
JOURNAL
NEWS CENTRAL
DOWNLOADS
COMMUNITY
CALENDAR
ABOUT US
Journal:
Get the weekly email highlights from the most popular journal for developers! Current issue
> developer.com developerdirect.com htmlgoodies.com javagoodies.com jars.com intranetjournal.com javascripts.com | All Categories : Java — Appendix B —JavaScript and Java Language Reference Reserved Words Comments Literals Variable Declaration Variable Assignment Operators Objects Arrays Loops and Conditionals Class Definitions Method and Constructor Definitions Packages, Interfaces, and Importing Exceptions and Guarding # — Appendix B — JavaScript and Java Language Reference by John J Kottler This appendix contains a summary or quick reference for the Java language. Note: This is not a grammar, 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 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
> abstract | do | implements | package | throw
> boolean | double | import | private | throws
> break | else | inner | protected | transient
> byte | extends | instanceof | public | try
> case | final | int | rest | var
> cast | finally | interface | return | void
> catch | float | long | short | volatile
> char | for | native | static | while
> class | future | new | sure |
> const | generic | null | switch |
> continue | goto | operator | synchronized |
> default | if | outer | this |
> ### Comments
>     /* this is a multiline cpmment */

>     // this is a single-line comment

>     /** Javadoc comment */
> ### Literals
> 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
> ### Variable Declaration
> [ 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
> 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
> ### Variable Assignment
> 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
> if (test ) block |
> else block | Conditional with else
> switch (test) { | switch (only with integer or char types)
> case value : block |
> ... |
> default : block |
> } |
> for (initializer, test, change ) block | for loop
> while ( test ) block | while loop
> do block | do loop
> while (test) |
> break [ label ] | break from loop or switch
> continue [ label ] | continue loops
> 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 | No subclasses
> [ 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 parameter | Name
> 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 ] returnType methodName() | Block access control
> 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 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 ] | Always executed
> try block | Same as previous example (can use optional)
> [ catch ( exception ) block ] | catch or finally, but not both)
> finally block |
Contact reference@developer.com with questions or comments. Copyright 1998 EarthWeb Inc., All rights reserved. PLEASE READ THE ACCEPTABLE USAGE STATEMENT. Copyright 1998 Macmillan Computer Publishing. All rights reserved. |