Difference between revisions of "Misc"
From Suhrid.net Wiki
Jump to navigationJump to searchLine 27: | Line 27: | ||
* A final class cannot be overriden (e.g. String) | * A final class cannot be overriden (e.g. String) | ||
* An abstract class cannot be instantiated (e.g. DateFormat) | * An abstract class cannot be instantiated (e.g. DateFormat) | ||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
== Class Members == | == Class Members == |
Revision as of 00:25, 22 August 2011
Contents
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 $;
Classes and Interfaces
Class Modifiers
Regular Classes:
- Access Modifiers: public and default only
- Non access: strictfp, abstract and final only
- Adding any other modifier will result in a compiler error.
- A final class cannot be overriden (e.g. String)
- An abstract class cannot be instantiated (e.g. DateFormat)
Class Members
- Members can use all the access modifiers: public, private, default(package), protected
- Private members are not inherited.
- This means private members can be redeclared in subclasses.
- Instance level variables cannot be synchronized, abstract, strictfp, native.
Protected
- Only accessible through inheritance in the subclass.
- The subclass cannot use a reference to super to access the protected member.
package pkg1;
public class Foo {
protected String str = "Hello";
}
package pkg2;
public class Bar extends Foo {
public void go() {
Foo f = new Foo();
String s = f.str; //Won't work ! Compiler error
System.out.println(str); //Will work - through inheritance
}
}
package pkg2;
public class Fubar {
public void goo() {
Bar b = new Bar();
System.out.println(b.str); //wont'w work - str only accessible through inheritance
}
}
Abstract Methods
As they go against the logic of overriding :
- abstract methods cannot be static.
- abstract methods cannot be private.
Constructors
- NO return type.
- Can have all the access modifiers.
- Can't be marked as abstract or final or static.
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 final variable can only be initialized once, either via an initializer or an assignment statement. If a final instance variable is not assigned a value - there will be a compiler error !
- It need not be initialized at the point of declaration: this is called a 'blank final' variable.
- A blank final instance variable of a class must be definitely assigned at the end of every constructor of the class in which it is declared or an instance initializer block can be used.
- Similarly, a blank final static variable must be definitely assigned in a static initializer of the class in which it is declared.
- Instance Init Blocks or constructors cannot assign values to final static variables - this will be a compiler error.
- 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.
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.
Literals
- Default type of an integer literal is int.
- Long can be specified by adding l or L
- Octal prefix with 0
- Hex prefix with 0x or 0X
- Floating point literals default type is double.
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
- Double can also be explicitly by adding the suffix d or D
- Float is denoted by suffix f or F
- Integers are stored in 2 complements's notation
- Leftmost bit is the sign bit, the remaining bits are used to store the value
e.g. of Byte
- Byte - 1 byte = 8 bits.
- Leftmost bit is to store the sign. So 7 bits are available for the value, so 2^7 = 128 values
- Negative range is -128 to -1 (128 numbers)
- Positive range is 0 to 127 (128 numbers, 0 is stored as a positive number)
- So a byte's range is -2^7 to (2^7 - 1)
- char's take up 2 bytes
- 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)
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 */
*/
Assignments
Watch out!
float f = 2; //This is legal. 2 is an int which fits in a float.
float f = 2.0; //Illegal. 2.0 is a double which by default won't fit in a float.
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;
}
}