• what, why and how @ Java Programming

• Java development Kit JDK
• Java Runtime Environment JRE
• Java Virtual Machine JVM
• What is Java Source code(.java file) and ByteCode(.class file)
• ClassLoader, Linker and JIT compiler

• Binary, Decimal, Octal and Hexadecimal
• Conversion from binary to decimal and vice-versa

• Primary memory/Main Memory/ Random Access Memory
• Secondary memory/Disk/ Read Only Memory
• Cache and cache layering
• Stack, Heaps and Method Areas

• Primitive(8 primitive types and their wrapper classes)
• and Non-Primitive(classes and arrays)

• if , if-else and multiple if and if-else
• nested if and if-else

• Loops
  • for and for-each
  • while
  • and do-while

• Single line comment

     // hello single line comment

• Multiline comment

    /*
    Hello from
    multi line comment
    */

• Java Doc

   /**
    * This class {@code Shape} is an abstract class to demonstrate partial abstraction
    * and features of abstract class.
    *
    * @author Vikram Gupta
    */

1. Private
2. Default
3. Protected
4. Public

int to float and int to byte and other primitives

1. Rules
2. Types
3. Overloading
4. Chaining

1. Inheritance
   • Definition
   • Rule
   • Types
   • Upcasting and down-casting
2. Composition
   • what is composition and how to implement it
   • How composition and inheritance are different
3. Encapsulation
   • what is encapsulation and why do we need it
   • POJO and Beans and their differences
4. Polymorphism
   • Overloading/static polymorphism/ compile time polymorphism
   • Overriding/ dynamic polymorphism/ runtime polymorphism
5. Abstraction
   • Interfaces --> full abstraction
   • Abstract class --> partial abstraction
   • Diamond problem and solution

1. Make all fields private
2. Create all argument constructor
3. Remove All setters
4. Use deep clone for objects in the constructor and getter methods
5. Make class as final
6. Optional rule - make all fields as final

• Throwable - The Throwable class is the superclass of all errors and exceptions in the Java language. Only objects that are instances of this class (or one of its subclasses) are thrown by the Java Virtual Machine or can be thrown by the Java throw statement. Similarly, only this class or one of its subclasses can be the argument type in a catch clause. For the purposes of compile-time checking of exceptions, Throwable and any subclass of Throwable that is not also a subclass of either RuntimeException or Error are regarded as checked exceptions. Instances of two subclasses, Error and Exception, are conventionally used to indicate that exceptional situations have occurred. Typically, these instances are freshly created in the context of the exceptional situation so as to include relevant information (such as stack trace data)

• Error - An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch. Most such errors are abnormal conditions. The ThreadDeath error, though a "normal" condition, is also a subclass of Error because most applications should not try to catch it.

• Exception - The class Exception and its subclasses are a form of Throwable that indicates conditions that a reasonable application might want to catch. The class Exception and any subclasses that are not also subclasses of RuntimeException are checked exceptions. Checked exceptions need to be declared in a method or constructor's throws clause if they can be thrown by the execution of the method or constructor and propagate outside the method or constructor boundary.

• Generics avoid code duplication and with the help of Generics the same class or method can be reused for different data types.

1. Functional Interface and default and static methods

2. Lambda expression

3. Stream APIs and More Stream methods

4. Java Optional

   • The purpose of the Optional class is to provide a type-level solution for representing optional values instead of null references.

   • A container object which may or may not contain a non-null value. If a value is present, isPresent() returns true. If no value is present, the object is considered empty and isPresent() returns false.

   • To create an empty Optional object, we simply need to use its empty() static method: Optional<String> empty = Optional.empty(); assertFalse(empty.isPresent());

   • We can also create an Optional object with the static method of(): String name = "baeldung"; Optional<String> opt = Optional.of(name); assertTrue(opt.isPresent()); However, the argument passed to the of() method can't be null. Otherwise, we'll get a NullPointerException:

5. Method Reference