Chapter 1 Language Fundamentals

1. Source file’s elements (in order)

a. Package declaration
b. Import statements
c. Class definitions
2. Importing packages doesn’t recursively import sub-packages.
3. Sub-packages are really different packages, happen to live within an enclosing package. Classes in sub-
packages cannot access classes in enclosing package with default access.
4. Comments can appear anywhere. Can’t be nested.(No matter what type of comments)
5. At most one public class definition per file. This class name should match the file name. If there are more than
one public class definitions, compiler will accept the class with the file’s name and give an error at the line
where the other class is defined.
6. It’s not required having a public class definition in a file. Strange, but true.  In this case, the file’s name
should be different from the names of classes and interfaces (not public obviously).
7. Even an empty file is a valid source file.
8. An identifier must begin with a letter, dollar sign ($) or underscore (_). Subsequent characters may be letters, $,
_ or digits.
9. An identifier cannot have a name of a Java keyword. Embedded keywords are OK. true, false and null are
literals (not keywords), but they can’t be used as identifiers as well.
10. const and goto are reserved words, but not used.
11. Unicode characters can appear anywhere in the source code. The following code is valid.
ch\u0061r a = 'a';
char \u0062 = 'b';
char c = '\u0063';
12. Java has 8 primitive data types.

Data Type Size Initial Min Value Max Value

(bits) Value
boolean 1 false false true
byte 8 0 -128 (-27) 127 (27 – 1)
short 16 0 -215 215 - 1
char 16 ‘\u0000’ ‘\u0000’ (0) ‘\uFFFF’ (216 – 1)
int 32 0 -231 231 - 1
long 64 0L -263 263 - 1
float 32 0.0F 1.4E-45 3.4028235E38
double 64 0.0 4.9E-324 1.7976931348623157E308

13. All numeric data types are signed. char is the only unsigned integral type.
14. Object reference variables are initialized to null.
15. Octal literals begin with zero. Hex literals begin with 0X or 0x.
16. Char literals are single quoted characters or unicode values (begin with \u).
17. A number is by default an int literal, a decimal number is by default a double literal.
18. 1E-5d is a valid double literal, E2d is not (since it starts with a letter, compiler thinks that it’s an identifier)
19. Two types of variables.
1. Member variables
 Accessible anywhere in the class.
 Automatically initialized before invoking any constructor.
 Static variables are initialized at class load time.
 Can have the same name as the class.
2. Automatic variables(method local)
 Must be initialized explicitly. (Or, compiler will catch it.) Object references can be initialized to null to
make the compiler happy. The following code won’t compile. Specify else part or initialize the local
variable explicitly.

public String testMethod ( int a) {

 String tmp;
if ( a > 0 ) tmp = “Positive”;
return tmp;
}
 Can have the same name as a member variable, resolution is based on scope.
20. Arrays are Java objects. If you create an array of 5 Strings, there will be 6 objects created.
21. Arrays should be
1. Declared. (int[] a; String b[]; Object []c; Size should not be specified now)
2. Allocated (constructed). ( a = new int[10]; c = new String[arraysize] )
3. Initialized. for (int i = 0; i < a.length; a[i++] = 0)
22. The above three can be done in one step.
int a[] = { 1, 2, 3 }; (or )
int a[] = new int[] { 1, 2, 3 }; But never specify the size with the new statement.
23. Java arrays are static arrays. Size has to be specified at compile time. Array.length returns array’s size. (Use
Vectors for dynamic purposes).
24. Array size is never specified with the reference variable, it is always maintained with the array object. It is
maintained in array.length, which is a final instance variable.
25. Anonymous arrays can be created and used like this: new int[] {1,2,3} or new int[10]
26. Arrays with zero elements can be created. args array to the main method will be a zero element array if no
command parameters are specified. In this case args.length is 0.
27. Comma after the last initializer in array declaration is ignored.

int[] i = new int[2] { 5, 10}; // Wrong

int i[5] = { 1, 2, 3, 4, 5}; // Wrong
int[] i[] = {{}, new int[] {} }; // Correct
int i[][] = { {1,2}, new int[2] }; // Correct
int i[] = { 1, 2, 3, 4, } ; // Correct

28. Array indexes start with 0. Index is an int data type.

29. Square brackets can come after datatype or before/after variable name. White spaces are fine. Compiler just
ignores them.
30. Arrays declared even as member variables also need to be allocated memory explicitly.
static int a[];
static int b[] = {1,2,3};
public static void main(String s[]) {
System.out.println(a[0]); // Throws a null pointer exception
System.out.println(b[0]); // This code runs fine
System.out.println(a); // Prints ‘null’
System.out.println(b); // Prints a string which is returned by toString
}
31. Once declared and allocated (even for local arrays inside methods), array elements are automatically initialized
to the default values.
32. If only declared (not constructed), member array variables default to null, but local array variables will not
default to null.
33. Java doesn’t support multidimensional arrays formally, but it supports arrays of arrays. From the specification -
“The number of bracket pairs indicates the depth of array nesting.” So this can perform as a multidimensional
array. (no limit to levels of array nesting)
34. In order to be run by JVM, a class should have a main method with the following signature.
public static void main(String args[])
static public void main(String[] s)
35. args array’s name is not important. args[0] is the first argument. args.length gives no. of arguments.
36. main method can be overloaded.
37. main method can be final.
38. A class with a different main signature or w/o main method will compile. But throws a runtime error.
39. A class without a main method can be run by JVM, if its ancestor class has a main method. (main is just a
method and is inherited)
40. Primitives are passed by value.
41. Objects (references) are passed by reference. The object reference itself is passed by value. So, it can’t be
changed. But, the object can be changed via the reference.
42. Garbage collection is a mechanism for reclaiming memory from objects that are no longer in use, and making
the memory available for new objects.
43. An object being no longer in use means that it can’t be referenced by any ‘active’ part of the program.
44. Garbage collection runs in a low priority thread. It may kick in when memory is too low. No guarantee.
45. It’s not possible to force garbage collection. Invoking System.gc may start garbage collection process.
46. The automatic garbage collection scheme guarantees that a reference to an object is always valid while the
object is in use, i.e. the object will not be deleted leaving the reference “dangling”.
47. There are no guarantees that the objects no longer in use will be garbage collected and their finalizers executed
at all. gc might not even be run if the program execution does not warrant it. Thus any memory allocated during
program execution might remain allocated after program termination, unless reclaimed by the OS or by other
means.
48. There are also no guarantees on the order in which the objects will be garbage collected or on the order in which
the finalizers are called. Therefore, the program should not make any decisions based on these assumptions.
49. An object is only eligible for garbage collection, if the only references to the object are from other objects that
are also eligible for garbage collection. That is, an object can become eligible for garbage collection even if
there are references pointing to the object, as long as the objects with the references are also eligible for garbage
collection.
50. Circular references do not prevent objects from being garbage collected.
51. We can set the reference variables to null, hinting the gc to garbage collect the objects referred by the variables.
Even if we do that, the object may not be gc-ed if it’s attached to a listener. (Typical in case of AWT
components) Remember to remove the listener first.
52. All objects have a finalize method. It is inherited from the Object class.
53. finalize method is used to release system resources other than memory. (such as file handles and network
connections) The order in which finalize methods are called may not reflect the order in which objects are
created. Don’t rely on it. This is the signature of the finalize method.
protected void finalize() throws Throwable { }
In the descendents this method can be protected or public. Descendents can restrict the exception list that can be
thrown by this method.
54. finalize is called only once for an object. If any exception is thrown in finalize, the object is still eligible for
garbage collection (at the discretion of gc)
55. gc keeps track of unreachable objects and garbage-collects them, but an unreachable object can become
reachable again by letting know other objects of its existence from its finalize method (when called by gc). This
‘resurrection’ can be done only once, since finalize is called only one for an object.
56. finalize can be called explicitly, but it does not garbage collect the object.
57. finalize can be overloaded, but only the method with original finalize signature will be called by gc.
58. finalize is not implicitly chained. A finalize method in sub-class should call finalize in super class explicitly as
its last action for proper functioning. But compiler doesn’t enforce this check.
59. System.runFinalization can be used to run the finalizers (which have not been executed before) for the objects
eligible for garbage collection.
60. The following table specifies the color coding of javadoc standard. (May be not applicable to 1.2)

Member Color
Instance method Red
Static method Green
Final variable Blue
Constructor Yellow
 Chapter 2 Operators and assignments

1. Unary operators.
1.1 Increment and Decrement operators ++ --
We have postfix and prefix notation. In post-fix notation value of the variable/expression is modified
after the value is taken for the execution of statement. In prefix notation, value of the
variable/expression is modified before the value is taken for the execution of statement.

x = 5; y = 0; y = x++; Result will be x = 6, y = 5

x = 5; y = 0; y = ++x; Result will be x = 6, y = 6

Implicit narrowing conversion is done, when applied to byte, short or char.

1.2 Unary minus and unary plus + -

+ has no effect than to stress positivity.
- negates an expression’s value. (2’s complement for integral expressions)
1.3 Negation !
Inverts the value of a boolean expression.
1.4 Complement ~
Inverts the bit pattern of an integral expression. (1’s complement – 0s to 1s and 1s to 0s)
Cannot be applied to non-integral types.
1.5 Cast ()
Persuades compiler to allow certain assignments. Extensive checking is done at compile and runtime to
ensure type-safety.
2. Arithmetic operators - *, /, %, +, -
 Can be applied to all numeric types.
 Can be applied to only the numeric types, except ‘+’ – it can be applied to Strings as well.
 All arithmetic operations are done at least with ‘int’. (If types are smaller, promotion happens. Result will
be of a type at least as wide as the wide type of operands)
 Accuracy is lost silently when arithmetic overflow/error occurs. Result is a nonsense value.
 Integer division by zero throws an exception.
 % - reduce the magnitude of LHS by the magnitude of RHS. (continuous subtraction)
 % - sign of the result entirely determined by sign of LHS
 5 % 0 throws an ArithmeticException.
 Floating point calculations can produce NaN (square root of a negative no) or Infinity ( division by zero).
Float and Double wrapper classes have named constants for NaN and infinities.
 NaN’s are non-ordinal for comparisons. x == Float.NaN won’t work. Use Float.IsNaN(x) But equals
method on wrapper objects(Double or Float) with NaN values compares Nan’s correctly.
 Infinities are ordinal. X == Double.POSITIVE_INFINITY will give expected result.
 + also performs String concatenation (when any operand in an expression is a String). The language itself
overloads this operator. toString method of non-String object operands are called to perform concatenation.
In case of primitives, a wrapper object is created with the primitive value and toString method of that object
is called. (“Vel” + 3 will work.)
 Be aware of associativity when multiple operands are involved.
System.out.println( 1 + 2 + “3” ); // Prints 33
System.out.println( “1” + 2 + 3 ); // Prints 123
3. Shift operators - <<, >>, >>>
 << performs a signed left shift. 0 bits are brought in from the right. Sign bit (MSB) is preserved. Value
becomes old value * 2 ^ x where x is no of bits shifted.
 >> performs a signed right shift. Sign bit is brought in from the left. (0 if positive, 1 if negative. Value
becomes old value / 2 ^ x where x is no of bits shifted. Also called arithmetic right shift.
 >>> performs an unsigned logical right shift. 0 bits are brought in from the left. This operator exists since
Java doesn’t provide an unsigned data type (except char). >>> changes the sign of a negative number to be
positive. So don’t use it with negative numbers, if you want to preserve the sign. Also don’t use it with
 types smaller than int. (Since types smaller than int are promoted to an int before any shift operation and
the result is cast down again, so the end result is unpredictable.)
 Shift operators can be applied to only integral types.
 -1 >> 1 is –1, not 0. This differs from simple division by 2. We can think of it as shift operation rounding
down.
 1 << 31 will become the minimum value that an int can represent. (Value becomes negative, after this
operation, if you do a signed right shift sign bit is brought in from the left and the value remains negative.)
 Negative numbers are represented in two’s complement notation. (Take one’s complement and add 1 to get
two’s complement)
 Shift operators never shift more than the number of bits the type of result can have. ( i.e. int 32, long 64)
RHS operand is reduced to RHS % x where x is no of bits in type of result.
int x;
x = x >> 33; // Here actually what happens is x >> 1
4. Comparison operators – all return boolean type.
4.1 Ordinal comparisons - <, <=, > , >=
 Only operate on numeric types. Test the relative value of the numeric operands.
 Arithmetic promotions apply. char can be compared to float.
4.2 Object type comparison – instanceof
 Tests the class of an object at runtime. Checking is done at compile and runtime same as the cast
operator.
 Returns true if the object denoted by LHS reference can be cast to RHS type.
 LHS should be an object reference expression, variable or an array reference.
 RHS should be a class (abstract classes are fine), an interface or an array type, castable to LHS
object reference. Compiler error if LHS & RHS are unrelated.
 Can’t use java.lang.Class or its String name as RHS.
 Returns true if LHS is a class or subclass of RHS class
 Returns true if LHS implements RHS interface.
 Returns true if LHS is an array reference and of type RHS.
 x instanceof Component[] – legal.
 x instanceof [] – illegal. Can’t test for ‘any array of any type’
 Returns false if LHS is null, no exceptions are thrown.
 If x instanceof Y is not allowed by compiler, then Y y = (Y) x is not a valid cast expression. If x
instanceof Y is allowed and returns false, the above cast is valid but throws a ClassCastException
at runtime. If x instanceof Y returns true, the above cast is valid and runs fine.
4.3 Equality comparisons - ==, !=
 For primitives it’s a straightforward value comparison. (promotions apply)
 For object references, this doesn’t make much sense. Use equals method for meaningful
comparisons. (Make sure that the class implements equals in a meaningful way, like for
X.equals(Y) to be true, Y instance of X must be true as well)
 For String literals, == will return true, this is because of compiler optimization.
5. Bit-wise operators - &, ^, |
 Operate on numeric and boolean operands.
 & - AND operator, both bits must be 1 to produce 1.
 | - OR operator, any one bit can be 1 to produce 1.
 ^ - XOR operator, any one bit can be 1, but not both, to produce 1.
 In case of booleans true is 1, false is 0.
 Can’t cast any other type to boolean.
6. Short-circuit logical operators - &&, ||
 Operate only on boolean types.
 RHS might not be evaluated (hence the name short-circuit), if the result can be determined only by looking
at LHS.
 false && X is always false.
 true || X is always true.
 RHS is evaluated only if the result is not certain from the LHS.
  That’s why there’s no logical XOR operator. Both bits need to be known to calculate the result.
 Short-circuiting doesn’t change the result of the operation. But side effects might be changed. (i.e. some
statements in RHS might not be executed, if short-circuit happens. Be careful)
7. Ternary operator
 Format a = x ? b : c ;
 x should be a boolean expression.
 Based on x, either b or c is evaluated. Both are never evaluated.
 b will be assigned to a if x is true, else c is assigned to a.
 b and c should be assignment compatible to a.
 b and c are made identical during the operation according to promotions.
8. Assignment operators.
 Simple assignment =.
 op= calculate and assign operators(extended assignment operators)
 *=, /=, %=, +=, -=
 x += y means x = x + y. But x is evaluated only once. Be aware.
 Assignment of reference variables copies the reference value, not the object body.
 Assignment has value, value of LHS after assignment. So a = b = c = 0 is legal. c = 0 is executed first, and
the value of the assignment (0) assigned to b, then the value of that assignment (again 0) is assigned to a.
 Extended assignment operators do an implicit cast. (Useful when applied to byte, short or char)
byte b = 10;
b = b + 10; // Won’t compile, explicit cast required since the expression
evaluates to an int
b += 10; // OK, += does an implicit cast from int to byte

9. General
 In Java, No overflow or underflow of integers happens. i.e. The values wrap around. Adding 1 to the
maximum int value results in the minimum value.
 Always keep in mind that operands are evaluated from left to right, and the operations are executed in the
order of precedence and associativity.
 Unary Postfix operators and all binary operators (except assignment operators) have left to right
assoiciativity.
 All unary operators (except postfix operators), assignment operators, ternary operator, object creation and
cast operators have right to left assoiciativity.
 Inspect the following code.
public class Precedence {
final public static void main(String args[]) {
int i = 0;
i = i++;
i = i++;
i = i++;
System.out.println(i); // prints 0, since = operator has the lowest
precedence.

int array[] = new int[5];

int index = 0;
array[index] = index = 3; // 1st element gets assigned to 3, not
the 4th element

for (int c = 0; c < array.length; c++)

System.out.println(array[c]);
System.out.println("index is " + index); // prints 3
}
}

Type of Operators Operators Associativity

Postfix operators [] . (parameters) ++ -- Left to Right
Prefix Unary operators ++ -- + - ~ ! Right to Left
Object creation and cast new (type) Right to Left
Multiplication/Division/Modulus */% Left to Right
Addition/Subtraction +- Left to Right
Shift >> >>> << Left to Right
Relational < <= > >= instanceof Left to Right
Equality == != Left to Right
Bit-wise/Boolean AND & Left to Right
Bit-wise/Boolean XOR ^ Left to Right
Bit-wise/Boolean OR | Left to Right
Logical AND (Short-circuit or && Left to Right
Conditional)
Logical OR (Short-circuit or || Left to Right
Conditional)
Ternary ?: Right to Left
Assignment = += -= *= /= %= <<= >>= >>>= &= ^= |= Right to Left
 Chapter 3 Modifiers

1. Modifiers are Java keywords that provide information to compiler about the nature of the code, data and classes.
2. Access modifiers – public, protected, private
 Only applied to class level variables. Method variables are visible only inside the method.
 Can be applied to class itself (only to inner classes declared at class level, no such thing as protected or
private top level class)
 Can be applied to methods and constructors.
 If a class is accessible, it doesn’t mean, the members are also accessible. Members’ accessibility determines
what is accessible and what is not. But if the class is not accessible, the members are not accessible, even
though they are declared public.
 If no access modifier is specified, then the accessibility is default package visibility. All classes in the same
package can access the feature. It’s called as friendly access. But friendly is not a Java keyword. Same
directory is same package in Java’s consideration.
 ‘private’ means only the class can access it, not even sub-classes. So, it’ll cause access denial to a sub-
class’s own variable/method.
 These modifiers dictate, which classes can access the features. An instance of a class can access the private
features of another instance of the same class.
 ‘protected’ means all classes in the same package (like default) and sub-classes in any package can access
the features. But a subclass in another package can access the protected members in the super-class via only
the references of subclass or its subclasses. A subclass in the same package doesn’t have this restriction.
This ensures that classes from other packages are accessing only the members that are part of their
inheritance hierarchy.
 Methods cannot be overridden to be more private. Only the direction shown in following figure is permitted
from parent classes to sub-classes.

private  friendly (default)  protected  public

Parent classes Sub-classes

3. final
 final features cannot be changed.
 final classes cannot be sub-classed.
 final variables cannot be changed. (Either a value has to be specified at declaration or an assignment
statement can appear only once).
 final methods cannot be overridden.
 Method arguments marked final are read-only. Compiler error, if trying to assign values to final arguments
inside the method.
 Member variables marked final are not initialized by default. They have to be explicitly assigned a value at
declaration or in an initializer block. Static finals must be assigned to a value in a static initializer block,
instance finals must be assigned a value in an instance initializer or in every constructor. Otherwise the
compiler will complain.
 Final variables that are not assigned a value at the declaration and method arguments that are marked final
are called blank final variables. They can be assigned a value at most once.
 Local variables can be declared final as well.
4. abstract
 Can be applied to classes and methods.
 For deferring implementation to sub-classes.
 Opposite of final, final can’t be sub-classed, abstract must be sub-classed.
 A class should be declared abstract,
1. if it has any abstract methods.
2. if it doesn’t provide implementation to any of the abstract methods it inherited
3. if it doesn’t provide implementation to any of the methods in an interface that it says implementing.
 Just terminate the abstract method signature with a ‘;’, curly braces will give a compiler error.
  A class can be abstract even if it doesn’t have any abstract methods.
5. static
 Can be applied to nested classes, methods, variables, free floating code-block (static initializer)
 Static variables are initialized at class load time. A class has only one copy of these variables.
 Static methods can access only static variables. (They have no this)
 Access by class name is a recommended way to access static methods/variables.
 Static initializer code is run at class load time.
 Static methods may not be overridden to be non-static.
 Non-static methods may not be overridden to be static.
 Abstract methods may not be static.
 Local variables cannot be declared as static.
 Actually, static methods are not participating in the usual overriding mechanism of invoking the methods
based on the class of the object at runtime. Static method binding is done at compile time, so the method to
be invoked is determined by the type of reference variable rather than the actual type of the object it holds
at runtime.

Let’s say a sub-class has a static method which ‘overrides’ a static method in a parent class. If you have a
reference variable of parent class type and you assign a child class object to that variable and invoke the
static method, the method invoked will be the parent class method, not the child class method. The
following code explains this.

public class StaticOverridingTest {

public static void main(String s[]) {
Child c = new Child();
c.doStuff(); // This will invoke Child.doStuff()

Parent p = new Parent();

p.doStuff(); // This will invoke Parent.doStuff()

p = c;
p.doStuff(); // This will invoke Parent.doStuff(), rather than
Child.doStuff()
}
}

class Parent {
static int x = 100;
public static void doStuff() {
System.out.println("In Parent..doStuff");
System.out.println(x);
}
}

class Child extends Parent {

static int x = 200;
public static void doStuff() {
System.out.println("In Child..doStuff");
System.out.println(x);
}
}
6. native
 Can be applied to methods only. (static methods also)
 Written in a non-Java language, compiled for a single machine target type.
 Java classes use lot of native methods for performance and for accessing hardware Java is not aware of.
 Native method signature should be terminated by a ‘;’, curly braces will provide a compiler error.
 native doesn’t affect access qualifiers. Native methods can be private.
 Can pass/return Java objects from native methods.
 System.loadLibrary is used in static initializer code to load native libraries. If the library is not loaded when
the static method is called, an UnsatisfiedLinkError is thrown.
7. transient
 Can be applied to class level variables only.(Local variables cannot be declared transient)
 Transient variables may not be final or static.(But compiler allows the declaration, since it doesn’t do any
harm. Variables marked transient are never serialized. Static variables are not serialized anyway.)
  Not stored as part of object’s persistent state, i.e. not written out during serialization.
 Can be used for security.
8. synchronized
 Can be applied to methods or parts of methods only.
 Used to control access to critical code in multi-threaded programs.
9. volatile
 Can be applied to variables only.
 Can be applied to static variables.
 Cannot be applied to final variables.
 Declaring a variable volatile indicates that it might be modified asynchronously, so that all threads will get
the correct value of the variable.
 Used in multi-processor environments.

Modifier Class Inner classes Variable Method Constructor Free floating Code block
(Except local and
anonymous
classes)
public Y Y Y Y Y N
protected N Y Y Y Y N
(friendly) Y Y (OK for all) Y Y Y N
No access
modifier
private N Y Y Y Y N
final Y Y (Except Y Y N N
anonymous
classes)
abstract Y Y (Except N Y N N
anonymous
classes)
static N Y Y Y N Y (static initializer)
native N N N Y N N
transient N N Y N N N
synchronized N N N Y N Y (part of method, also
need to specify an
object on which a lock
should be obtained)
volatile N N Y N N N
 Chapter 4 Converting and Casting
Unary Numeric Promotion
Contexts:
 Operand of the unary arithmetic operators + and –
 Operand of the unary integer bit-wise complement operator ~
 During array creation, for example new int[x], where the dimension expression x must evaluate to an
int value.
 Indexing array elements, for example table[‘a’], where the index expression must evaluate to an int
value.
 Individual operands of the shift operators.

Binary numeric promotion

Contexts:
 Operands of arithmetic operators *, / , %, + and –
 Operands of relational operators <, <= , > and >=
 Numeric Operands of equality operators == and !=
 Integer Operands of bit-wise operators &, ^ and |

Conversion of Primitives
1. 3 types of conversion – assignment conversion, method call conversion and arithmetic promotion
2. boolean may not be converted to/from any non-boolean type.
3. Widening conversions accepted. Narrowing conversions rejected.
4. byte, short can’t be converted to char and vice versa.
5. Arithmetic promotion
5.1 Unary operators
 if the operand is byte, short or char {
convert it to int;
}
else {
do nothing; no conversion needed;
}
5.2 Binary operators
 if one operand is double {
all double; convert the other operand to double;
}
else if one operand is float {
all float; convert the other operand to float;
}
else if one operand is long {
all long; convert the other operand to long;
}
else {
all int; convert all to int;
}
6. When assigning a literal value to a variable, the range of the variable’s data type is checked against the value of
the literal and assignment is allowed or compiler will produce an error.
char c = 3; // this will compile, even though a numeric literal is by default an int since the range of char
will accept the value
int a = 3;
char d = a; // this won’t compile, since we’re assigning an int to char
char e = -1; // this also won’t compile, since the value is not in the range of char
float f = 1.3; // this won’t compile, even though the value is within float range. Here range is not
important, but precision is. 1.3 is by default a double, so a specific cast or f = 1.3f will work.
float f = 1/3; // this will compile, since RHS evaluates to an int.
Float f = 1.0 / 3.0; // this won’t compile, since RHS evaluates to a double.
7. Also when assigning a final variable to a variable, even if the final variable’s data type is wider than the
variable, if the value is within the range of the variable an implicit conversion is done.
byte b;
final int a = 10;
b = a; // Legal, since value of ‘a’ is determinable and within range of b
final int x = a;
b = x; // Legal, since value of ‘x’ is determinable and within range of b
int y;
final int z = y;
b = z; // Illegal, since value of ‘z’ is not determinable

8. Method call conversions always look for the exact data type or a wider one in the method signatures. They will
not do narrowing conversions to resolve methods, instead we will get a compile error.

Here is the figure of allowable primitive conversion.

byte  short  int  long  float  double


char

Casting of Primitives
9. Needed with narrowing conversions. Use with care – radical information loss. Also can be used with widening
conversions, to improve the clarity of the code.
10. Can cast any non-boolean type to another non-boolean type.
11. Cannot cast a boolean or to a boolean type.

Conversion of Object references

12. Three types of reference variables to denote objects - class, interface or array type.
13. Two kinds of objects can be created – class or array.
14. Two types of conversion – assignment and method call.
15. Permitted if the direction of the conversion is ‘up’ the inheritance hierarchy. Means that types can be
assigned/substituted to only super-types – super-classes or interfaces. Not the other way around, explicit casting
is needed for that.
16. Interfaces can be used as types when declaring variables, so they participate in the object reference conversion.
But we cannot instantiate an interface, since it is abstract and doesn’t provide any implementation. These
variables can be used to hold objects of classes that implement the interface. The reason for having interfaces as
types may be, I think, several unrelated classes may implement the same interface and if there’s a need to deal
with them collectively one way of treating them may be an array of the interface type that they implement.
17. Primitive arrays can be converted to only the arrays of the same primitive type. They cannot be converted to
another type of primitive array. Only object reference arrays can be converted / cast.
18. Primitive arrays can be converted to an Object reference, but not to an Object[] reference. This is because all
arrays (primitive arrays and Object[]) are extended from Object.

Casting of Object references

19. Allows super-types to be assigned to subtypes. Extensive checks done both at compile and runtime. At compile
time, class of the object may not be known, so at runtime if checks fail, a ClassCastException is thrown.
20. Cast operator, instanceof operator and the == operator behave the same way in allowing references to be the
operands of them. You cannot cast or apply instanceof or compare unrelated references, sibling references or
any incompatible references.

Compile-time Rules
  When old and new types are classes, one class must be the sub-class of the other.
 When old and new types are arrays, both must contain reference types and it must be legal to cast
between those types (primitive arrays cannot be cast, conversion possible only between same type of
primitive arrays).
 We can always cast between an interface and a non-final object.

Run-time rules
 If new type is a class, the class of the expression being converted must be new type or extend new
type.
 If new type is an interface, the class of the expression being converted must implement the interface.

An Object reference can be converted to: (java.lang.Object)

 an Object reference
 a Cloneable interface reference, with casting, with runtime check
 any class reference, with casting, with runtime check
 any array referenece, with casting, with runtime check
 any interface reference, with casting, with runtime check

A Class type reference can be converted to:

 any super-class type reference, (including Object)
 any sub-class type reference, with casting, with runtime check
 an interface reference, if the class implements that interface
 any interface reference, with casting, with runtime check (except if the class is final and doesn’t
implement the interface)

An Interface reference can be converted to:

 an Object reference
 a super-interface reference
 any interface/class reference with casting, with runtime check (except if the class is final and doesn’t
implement the interface)

A Primitive Array reference can be converted to:

 an Object reference
 a Cloneable interface reference
 a primitive array reference of the same type

An Object Array reference can be converted to:

 an Object reference
 a Cloneable interface reference
 a super-class Array reference, including an Object Array reference
 any sub-class Array reference with casting, with runtime check