Java Programming 4U | Keywords

goto

admin — Mon, 27 Sep 2010 13:52:24 +0000

goto keyword

Although reserved as a keyword in Java, goto is not used and has no function.

true

admin — Mon, 27 Sep 2010 08:22:33 +0000

true keyword

A boolean literal value.

Example:

   1:  private boolean isTrue = true;

null

admin — Mon, 27 Sep 2010 08:20:10 +0000

null keyword

A reference literal value.

Example:

1:

   2:         private Object object = null;

false

admin — Mon, 27 Sep 2010 08:16:34 +0000

false keyword

A boolean literal value.

Example:

   1:         private boolean isTrue = false;

while

admin — Sat, 25 Sep 2010 15:26:42 +0000

while keyword

is used to create a while loop, which tests a boolean expression and executes the block of statements associated with the loop if the expression evaluates to true; this continues until the expression evaluates to false. This keyword can also be used to create a do-while loop ; see do.

   1:    public void testWhileLoop () {

   2:          int x = 0;

3:

   4:          while (x < 3) {

   5:              System.out.println(x);

   6:              x++;

   7:          }

   8:          //output: 0

   9:          //        1

  10:          //        2

  11:      }

volatile

admin — Sat, 25 Sep 2010 13:27:13 +0000

volatile keyword

Used in field declarations to specify that the variable is modified asynchronously by concurrently running threads. Methods, classes and interfaces thus cannot be declared volatile.

Some resources states that volatile field can be used instead of synchronized block or method in case only one field needed to be accessed from several threads.

And some resources states that many (all?) current JVM implementations do not guarantee that using of volatile keyword will make any effect.

The next code examples demonstrates that using of volatile keyword doesn’t make any difference: code produce the same output regardless declared isStopped as volatile or not. (jdk1.6_20 Windows).

   1:      class StoppableThread extends Thread {

2:

   3:          private volatile boolean isStopped;

   4:          private int i;

5:

   6:          public StoppableThread(String name){

   7:              super(name);

   8:          }

   9:          public void run() {

  10:              while (!isStopped) {

  11:                  i++;

  12:                  System.out.println("thread" + getName() + " : " + i);

  13:              }

  14:          }

15:

  16:          public void stopNow() {

  17:              isStopped = true;

  18:          }

  19:      }

20:

  21:      public void testVolatile () {

  22:          StoppableThread stoppableTask1 = new StoppableThread("1");

  23:          stoppableTask1.start();

  24:          StoppableThread stoppableTask2 = new StoppableThread("2");

  25:          stoppableTask2.start();

  26:          StoppableThread stoppableTask3 = new StoppableThread("3");

  27:          stoppableTask3.start();

  28:  //        try {

  29:  //            Thread.sleep(1000);

  30:  //        } catch (InterruptedException ex) {

  31:  //

  32:  //        }

  33:          stoppableTask1.stopNow();

  34:          stoppableTask2.stopNow();

  35:          stoppableTask3.stopNow();

36:

  37:      }

void

admin — Fri, 24 Sep 2010 12:00:28 +0000

void keyword

The void keyword is used to declare that a method does not return any value.

1:

   2:      void voidExample () {

   3:          // return 0; //trying to return any value including 0 and null cause compiler error

   4:      }

try

admin — Fri, 24 Sep 2010 11:46:39 +0000

try keyword

Defines a block of statements that have exception handling. If an exception is thrown inside the try block, an optional catch block can handle declared exception types. Also, an optional finally block can be declared that will be executed when execution exits the try block and catch clauses, regardless of whether an exception is thrown or not. A try block must have at least one catch clause or a finally block.

   1:      void tryExample () {

   2:          try {

   3:              //...

   4:          } catch (Exception e){

   5:              log.error(e);

   6:          } finally {

   7:              //free resources: close streams etc.

   8:          }

   9:      }

transient

admin — Fri, 24 Sep 2010 11:41:21 +0000

transient keyword

Declares that an instance field is not part of the default serialized form of an object. When an object is serialized, only the values of its non-transient instance fields are included in the default serial representation. When an object is deserialized, transient fields are initialized only to their default value. If the default form is not used, e.g. when a serialPersistentFields table is declared in the class hierarchy, all ‘transient’ keywords are ignored.

   1:      class ToBeSerialized implements Serializable {

2:

   3:          int x = 5;

   4:          transient int y = 10;

   5:      }

6:

   7:      void testObjectSerialization() throws FileNotFoundException, IOException, ClassNotFoundException {

   8:          FileOutputStream fileOut = new FileOutputStream("ToBeSerialized.ser");

   9:          ObjectOutputStream out = new ObjectOutputStream(fileOut);

  10:          try {

  11:              out.writeObject(new ToBeSerialized());

  12:          } finally {

  13:              out.close();

  14:              fileOut.close();

  15:          }

16:

  17:          FileInputStream fileIn = new FileInputStream("ToBeSerialized.ser");

  18:          ObjectInputStream in = new ObjectInputStream(fileIn);

  19:          try {

20:

  21:              ToBeSerialized loadedObject = (ToBeSerialized) in.readObject();

22:

  23:              System.out.println("   common field x: " + loadedObject.x);

  24:              System.out.println("transient field y: " + loadedObject.y);

25:

  26:              //output: common field x: 5

  27:              //     transient field y: 0

28:

  29:              //transient field was not  serialized and got default value.

30:

  31:          } finally {

  32:              in.close();

  33:              fileIn.close();

  34:          }

  35:      }

throws

admin — Fri, 24 Sep 2010 08:45:06 +0000

throws keyword

Used in method declarations to specify which exceptions are not handled within the method but rather passed to the next higher level of the program. All uncaught exceptions in a method that are not instances of RuntimeException must be declared using the throws keyword.

   1:     public void enclosingTrowingMethod () throws IOException {

   2:          enclosedThrowingMethod();

   3:      }

4:

   5:      public void enclosedThrowingMethod () throws FileNotFoundException{

   6:          throw new FileNotFoundException ();

   7:      }