Added content to Core Java

Updated myanswers,

Author: DeepakVadgama

topics/core/core-java.md

@@ -1,31 +1,82 @@
 ## Core Java
 
+This page focuses on oddities of Core Java from an interview perspective. For basic 
+topics like inheritance, interfaces, etc. please read the book mentioned below. 
+
 ### Resources
 
-- 
+- [OCA/OCP Java SE 7 Programmer I & II Study Guide](http://www.amazon.in/Programmer-Study-1Z0-803-1Z0-804-Certification/dp/0071772006)
+
+### Default init values
+
+- For fields (class level variables), values are auto assigned default values. 
+- Method local variables should be manually assigned. 
+- Default values (references = null, primitives = 0, boolean = false)
+- Arrays initialize its elements: int[] numbers = new int[10]; will assign all ints in the array to 0.
+
+### String pool
+
+- String constants are placed in a memory pool 
+- When retrieved, returns reference to string in the pool. 
+- Pool saves memory. New string constants with same value share same instance in the pool.
+- String is immutable thus these values are never changed. For any updates, new string constant is created.  
+- String s = "abc" will place "abc" in pool and return its reference.
+- String s = new String("abc") will also place "abc" in pool, as well as allocate new memory
+- [implementation details](jvm-internals.md#string-interning)
+
+### Wrapper class pool
 
-### Singleton
+- Boolean
+- Byte
+- Character from \u0000 to \u007f (7f is 127 in decimal)
+- Short and Integer from –128 to 127
 
-- static final variable (init guarantee)
-- Lazy loading (double checked) 
-- Enums (by default lazy, and init guarantee)
+### Singleton options
+
+- Using: static final variable (init guarantee)
+- Using: Lazy loading (double checked) 
+- Using: Enums (by default lazy, and init guarantee)
 
 ### Override method rules
 
 - Same method name and parameter types
 - Same or a subset of super methods' checked exceptions
 - Any number of runtime exceptions
-- Same or covariant return type
+- Same or covariant return type 
+
+### Covariant variables
 
-### Varargs, boxing, upcast
+- Variable types which are compatible. 
+- Eg: an int is covariant of long
+- Eg: an Lion class is covariant of Animal class (only if Lion extends Animal)
+- Can be used in parameters, return types or assignments
 
-- 
-- 
-- 
+### Varargs, boxing, widening
 
+- Primitive Widening > Boxing > Varargs [example](http://stackoverflow.com/a/2128068/3494368) 
+- Widening then Boxing not allowed. 
+- Boxing then Widening allowed.   
+- Widening between wrapper classes not allowed (eg: Long n = new Integer(10); not allowed)
+ 
 ### Inner classes
 
-- Static inner class
-- Inner class
-- Method local inner class
-- 
+Personally I find this part of Java to be super annoying, unnecessary and hardly ever used in real-life (especially after Java 8). 
+Also, this topic does not come up a lot in interviews, so just skimp through. 
+
+- Inner class: Can access enclosing class's variables (even private ones)
+- Method local inner class: Same as above. Plus, it can access final variables in encapsulating method. 
+- Anonymous inner class: Just no name, otherwise same as above. 
+- Static inner class: No special relationship with outer class. 
+
+### Reference types
+
+- **Weak reference** - Eligible for GC if object not referenced by any other variables. Good for caches. Are enqueued in ReferenceQueue just before GC (object can be resurrected in finalize). Returns null once object is eligible for GC, even if object is resurrected, the weak-reference still is dead, and will return null. 
+- **Soft reference** - Same as above, but its GC’ed only when memory is low. Excellent for caches.
+- **Phantom reference** - Even after GC, it references the object, until the memory is reclaimed. Enqueued in ReferenceQueue after complete reclamation. Always returns null, so that you cannot resurrect it. Can be helpful to check when memory is reclaimed so that you can load next large object. 
+- **WeakHashMap** - Weak keys. Removes entry once key is GC’ed.
+ 
+### Cloning  
+
+- clone method (protected) of Object class returns shallow copy. Need to be explicitly cast back.
+- Requires class to implement Cloneable marker interface. Else returns CloneNotSupportedException
+- [More details](effective-java.md#clone)

topics/opinion/myanswers.md

@@ -4,6 +4,8 @@
 - In JIT - code is converted at runtime, just before 
 - Advantage: it can check availability of resources (RAM, CPU etc) and decide on corresponding optimizations 
 - Advantage: it can keep running for a while a find hot snippets of code, and optimize them even further. Eg: Android 7
+- Disadvantage: introduces latency during startup (for conversion)
+- Disadvantage: have to perform conversion every time during application start (cannot save and re-use the best optimization results)
 
 ## What do you like about Java
 
@@ -16,11 +18,11 @@
 ## What do you not like about Java
 
 - Verbosity - It is very difficult to write succinct code in Java. Too much boilerplate. Slightly subsidised by lambdas.
-- Threads could be less expensive akin to Go
+- Threads could be less expensive akin to Go channels or Kotlin co-routines.
 - Message passing and Immutability are not baked-in.
-- Thread communication by sharing memory is brittle (that is why so many locks are introduced), difficult to developers at all skill level to write correct code.
+- Thread communication by sharing memory is brittle (that is why so many locks are introduced), difficult to developers at all skill levels to write correct code.
 - I wish primitives could be directly added to collections and used as list
-- Null (?.) (Kotlin fix … i have spent so much time fixing NPE and wrote so much code to avoid it). Especially in finance world where POJOs have deeply nested structure. Doing a.getB().getC().getD() cannot be written. Every object needs to be null checked.
+- Null-checks (no ?. operator). Lot of boilerplate code and time wasted in checking for nulls. Especially in finance industry where POJOs have deeply nested structure. Doing a.getB().getC().getD() cannot be written. Every object needs to be null checked.
 - No tuples (especially helpful in multiple return types which currently have to be put in HashMap)
 - In fact, just check the kotlin language list
 - All pojos have to write getter, setter, equals, hash, clone/copy… kotlin fixes this