Difference between revisions of "Misc"

From Suhrid.net Wiki
Jump to navigationJump to search
 
(31 intermediate revisions by the same user not shown)
Line 1: Line 1:
This covers Objective 1.3
+
== Legal Identifiers ==
 
 
<u> Legal Identifiers </u>
 
 
* Can be composed of characters, numbers, currency-symbols and connecting chars such as underscore.
 
* Can be composed of characters, numbers, currency-symbols and connecting chars such as underscore.
 
* Definition of characters are interpreted according to the charset.
 
* Definition of characters are interpreted according to the charset.
Line 17: Line 15:
 
* String $;
 
* String $;
  
== Literals ==  
+
== Comments ==  
  
* Default type of an integer literal is int.
+
* Comment start sequences like //, /*. /** are ignored within comment blocks.
* Long can be specified by adding l or L
+
* So trying to nest multiple-line comments will result in an error
* Octal prefix with 0
 
* Hex prefix with 0x or 0X
 
  
 +
<syntaxhighlight lang="java5">
  
* Floating point literals default type is double.
+
/* This is the foo algorithm
 +
  /* which takes foo's and sort's bars */
 +
*/
  
<syntaxhighlight lang="java5">
 
float pi = 3.14; // This will be a compiler error, because 3.14 is a fp literal which is double by default
 
double pi = 3.14; //OK
 
float pi = 3.14f; //OK
 
 
</syntaxhighlight>
 
</syntaxhighlight>
  
* Double can also be explicitly by adding the suffix d or D
+
== Final, Transient, Volatile ==
* Float is denoted by suffix f or F
 
  
* Integers are stored in 2 complements's notation
+
<u> Final </u>
* Leftmost bit is the sign bit, the remaining bits are used to store the value
+
* Variables marked as final and once initialized, cannot be reinitialized.
e.g. of Byte
+
* Marking primitives as final is equivalent to making them a constant.
* Byte - 1 byte = 8 bits.
+
* For object references, final only prevents the reference from being assigned to another object.
* Leftmost bit is to store the sign. So 7 bits are available for the value, so 2^7 = 128 values
+
* The object however can still be modified.
* Negative range is -128 to -1 (128 numbers)
+
* There are no final objects, only final references.
* Positive range is 0 to 127 (128 numbers, 0 is stored as a positive number)
+
* A local final variable must be initialized before it is used. If the variable is never used (blank final) then it wont cause a compiler error.
* So a byte's range is -2^7 to (2^7 - 1)
 
  
* char's take up 2 bytes
+
* Final variables can be passed to non-final arguments
* they are stored as '''unsigned''' 16-bit integers. This means they will represent a total of 2^16 positive values (0 to 65535 (2^16-1) )
 
* contrast with short which also uses 2 bytes. But it's max positive range is 2^15 -1. (Since 1 bit is to used to represent the sign)
 
 
<u> Comments </u>
 
* Comment start sequences like //, /*. /** are ignored within comment blocks.
 
* So trying to nest multiple-line comments will result in an error
 
  
 
<syntaxhighlight lang="java5">
 
<syntaxhighlight lang="java5">
/* This is the foo algorithm
+
 
  /* which takes foo's and sort's bars */
+
public static void main(String[] args) {
*/
+
final int x = 5;
 +
System.out.println(go(x)); //6
 +
System.out.println(x); //5
 +
}
 +
 +
private static int go(int y) {
 +
return ++y;
 +
}
 +
 
 
</syntaxhighlight>
 
</syntaxhighlight>
  
 +
<u> Transient </u>
 +
* Applies only to instance variables.
 +
* Tells the JVM to skip this variable when serializing the object it is part of.
 +
 +
<u> Volatile </u>
 +
* Applies only to instance variables.
 +
* Tells the JVM that a thread accessing the variable must synchronize its private cache copy of the variable with the master copy in main memory.
 +
* This is rarely used. Synchronization is used, rather than volatile to keep data thread-safe.
  
 
== Local variables ==
 
== Local variables ==
  
 +
* No access modifier is applicable to local variables.
 +
* The '''only''' modifier that can be applied to local variables is final.
 
* Local variables are not automatically initialized, unlike instance and static variables.
 
* Local variables are not automatically initialized, unlike instance and static variables.
 
* Compiler will complain when uninitialized local variable is first USED. If you don't try to use an uninitialized variable, it will be OK.
 
* Compiler will complain when uninitialized local variable is first USED. If you don't try to use an uninitialized variable, it will be OK.
Line 90: Line 95:
 
</syntaxhighlight>
 
</syntaxhighlight>
  
 +
== Shadowing ==
  
 +
* The more local variable will always mask the instance level variable with the same name.
 +
* "this" can be used to qualify the variable.
 +
 +
<syntaxhighlight lang="java5">
 +
 +
class Bar {
 +
  private int i = 10;
 +
 +
  public void go() {
 +
      foo(20);
 +
  }
 +
 
 +
  private void foo(int i) {
 +
        System.out.println(i); //local i - shadows instance i. Will print 20;
 +
        System.out.println(this.i); //Refers to instance i, will print 10;
 +
  }
 +
 +
}
 +
 +
</syntaxhighlight>
  
 
[[Category:OCPJP]]
 
[[Category:OCPJP]]

Latest revision as of 11:27, 6 September 2011

Legal Identifiers

  • Can be composed of characters, numbers, currency-symbols and connecting chars such as underscore.
  • Definition of characters are interpreted according to the charset.
  • NO special chars such as #, :, ;, @, -, etc...
  • Must start with letter, currency char, underscore but CANNOT start with a digit !
  • Java identifiers are case-sensitive.

Illegal identifiers:

  • int 23age;
  • String em@iladd;
  • List all-accounts;

These are legal!:

  • int __;
  • String $;

Comments

  • Comment start sequences like //, /*. /** are ignored within comment blocks.
  • So trying to nest multiple-line comments will result in an error
/* This is the foo algorithm
   /* which takes foo's and sort's bars */
*/

Final, Transient, Volatile

Final

  • Variables marked as final and once initialized, cannot be reinitialized.
  • Marking primitives as final is equivalent to making them a constant.
  • For object references, final only prevents the reference from being assigned to another object.
  • The object however can still be modified.
  • There are no final objects, only final references.
  • A local final variable must be initialized before it is used. If the variable is never used (blank final) then it wont cause a compiler error.
  • Final variables can be passed to non-final arguments
public static void main(String[] args) {
		final int x = 5;
		System.out.println(go(x)); //6
		System.out.println(x); //5
}
	
private static int go(int y) {
		return ++y;
}

Transient

  • Applies only to instance variables.
  • Tells the JVM to skip this variable when serializing the object it is part of.

Volatile

  • Applies only to instance variables.
  • Tells the JVM that a thread accessing the variable must synchronize its private cache copy of the variable with the master copy in main memory.
  • This is rarely used. Synchronization is used, rather than volatile to keep data thread-safe.

Local variables

  • No access modifier is applicable to local variables.
  • The only modifier that can be applied to local variables is final.
  • Local variables are not automatically initialized, unlike instance and static variables.
  • Compiler will complain when uninitialized local variable is first USED. If you don't try to use an uninitialized variable, it will be OK.
  • Compiler can however detect in very simple conditional cases, that a local variable will be initialized, but will complain in complex cases.

e.g.

private void foo() {
   int i;
   System.out.println("i : " + i); //Compiler error

   if(true) {
      i = 10;
   } else {
      i = 20;
   }
   System.out.println("i : " + i); //OK. Compiler can figure out i will be definitely initialized.

   int j;
   boolean b = true;
   if(b) {
     j = 10;
   } 
   System.out.println("j : " + j); //Compiler error - can't figure out if j will be initialized or not.
}

Shadowing

  • The more local variable will always mask the instance level variable with the same name.
  • "this" can be used to qualify the variable.
class Bar {
  private int i = 10;

  public void go() {
       foo(20);
  }
  
  private void foo(int i) {
        System.out.println(i); //local i - shadows instance i. Will print 20;
        System.out.println(this.i); //Refers to instance i, will print 10;
  }

}