JAVA

1. Basic Features

a. Data Types
 Version: Java 1.0 (1996)
 Part of: JDK
 Explanation: Java has two categories of data types: primitive (like
int, char) and reference types (like arrays, objects).
 Use Case: Storing different types of data.
 Sub-Concepts:
o Primitive Data Types: int, char, double, boolean.
o Reference Data Types: Strings, Arrays, Objects.
 Code Snippet:
java
Copy code
int number = 10;
char letter = 'A';
String greeting = "Hello, World!";

b. Control Statements
 Version: Java 1.0 (1996)
 Part of: JDK
 Explanation: Control statements dictate the flow of the program
based on conditions.
 Use Case: Making decisions in the code.
 Sub-Concepts:
o Conditional Statements: if, switch.
o Looping Statements: for, while, do-while.
 Code Snippet:
java
Copy code
if (number > 0) {
System.out.println("Positive");
} else {
System.out.println("Not positive");
}

for (int i = 0; i < 5; i++) {

System.out.println(i);
}

c. Methods
 Version: Java 1.0 (1996)
 Part of: JDK
 Explanation: Methods define reusable blocks of code that can take
parameters and return values.
 Use Case: Encapsulating functionality for reuse.
 Sub-Concepts:
o Static Methods: Methods that belong to the class rather than
instances.
o Instance Methods: Methods that belong to an instance of a
class.
o Abstract Methods: Declared in abstract classes and must be
implemented in derived classes.
o Virtual Methods: Methods that can be overridden in
subclasses.
 Code Snippet:
java
Copy code
public class MathOperations {
public int add(int a, int b) {
return a + b; // Instance Method
}

public static int multiply(int a, int b) {

return a * b; // Static Method
}
}
abstract class Shape {
abstract void draw(); // Abstract Method
}

class Circle extends Shape {

void draw() {
System.out.println("Drawing a circle");
}
}

d. Classes and Objects

 Version: Java 1.0 (1996)
 Part of: JDK
 Explanation: Classes are blueprints for creating objects,
encapsulating data and behavior.
 Use Case: Modeling real-world entities in a program.
 Sub-Concepts:
o Constructors: Special methods for initializing objects.
o Destructors: Java uses garbage collection, so explicit
destructors are not present, but you can override finalize().
 Code Snippet:
java
Copy code
public class Dog {
private String name;

public Dog(String name) {

this.name = name; // Constructor
}

public String getName() {

return name;
}
}
2. Medium Features

a. Inheritance
 Version: Java 1.0 (1996)
 Part of: JDK
 Explanation: Inheritance allows a class to inherit properties and
methods from another class, promoting code reusability.
 Use Case: Creating a class hierarchy (e.g., Animal and Dog classes).
 Sub-Concepts:
o Superclass: The class being inherited from.
o Subclass: The class that inherits from another class.
 Code Snippet:
java
Copy code
class Animal {
void sound() { System.out.println("Animal sound"); }
}

class Dog extends Animal {

void sound() { System.out.println("Bark"); } // Method overriding
}

b. Polymorphism
 Version: Java 1.0 (1996)
 Part of: JDK
 Explanation: Polymorphism allows methods to do different things
based on the object that it is acting upon.
 Use Case: Handling multiple types of objects through a common
interface.
 Sub-Concepts:
o Method Overloading: Same method name with different
parameters.
o Method Overriding: Redefining a base class method in a
derived class.
 Code Snippet:
java
Copy code
class MathOperations {
int add(int a, int b) {
return a + b; // Method Overloading
}

double add(double a, double b) {

return a + b;
}
}

c. Interfaces
 Version: Java 1.0 (1996)
 Part of: JDK
 Explanation: Interfaces define a contract that classes must
implement, allowing for multiple inheritance.
 Use Case: Defining common behavior for different classes (e.g.,
IAnimal interface).
 Code Snippet:
java
Copy code
interface IAnimal {
void speak(); // Abstract method
}

class Dog implements IAnimal {

public void speak() {
System.out.println("Bark");
}
}

d. Exception Handling
 Version: Java 1.0 (1996)
 Part of: JDK
 Explanation: Exception handling is a mechanism to respond to the
occurrence of exceptions during program execution.
 Use Case: Preventing application crashes and handling errors
gracefully.
  Sub-Concepts:
o try-catch: Catching exceptions.
o finally: Code that runs regardless of whether an exception
occurred.
 Code Snippet:
java
Copy code
try {
int result = 10 / 0; // This will throw an exception
} catch (ArithmeticException ex) {
System.out.println("Cannot divide by zero");
} finally {
System.out.println("Cleanup code here.");
}

e. Collections Framework
 Version: Java 1.2 (1998)
 Part of: JDK
 Explanation: The Collections Framework provides data structures for
storing and manipulating groups of objects.
 Use Case: Managing collections of objects efficiently.
 Sub-Concepts:
o List: ArrayList, LinkedList.
o Set: HashSet, TreeSet.
o Map: HashMap, TreeMap.
 Code Snippet:
java
Copy code
import java.util.ArrayList;
import java.util.HashMap;

ArrayList<String> list = new ArrayList<>();

list.add("Hello");

HashMap<String, Integer> map = new HashMap<>();

map.put("One", 1);
3. Advanced Features

a. Java Streams
 Version: Java 8 (2014)
 Part of: JDK
 Explanation: The Streams API allows functional-style operations on
streams of elements.
 Use Case: Processing collections of data in a declarative way.
 Sub-Concepts:
o Stream Operations: Filter, map, reduce.
 Code Snippet:
java
Copy code
List<String> names = Arrays.asList("John", "Jane", "Jack");
names.stream()
.filter(name -> name.startsWith("J"))
.forEach(System.out::println);

b. Lambda Expressions
 Version: Java 8 (2014)
 Part of: JDK
 Explanation: Lambda expressions provide a clear and concise way to
represent a single method interface using an expression.
 Use Case: Simplifying code for functional interfaces.
 Sub-Concepts:
o Functional Interfaces: An interface with a single abstract
method.
 Code Snippet:
java
Copy code
List<String> names = Arrays.asList("John", "Jane", "Jack");
names.forEach(name -> System.out.println(name)); // Lambda expression

c. Optional Class
 Version: Java 8 (2014)
 Part of: JDK
  Explanation: The Optional class is a container object which may or
may not contain a value, helping to avoid NullPointerExceptions.
 Use Case: Handling optional values more gracefully.
 Code Snippet:
java
Copy code
Optional<String> optionalName = Optional.ofNullable(getName());
optionalName.ifPresent(name -> System.out.println(name));

d. Java Modules
 Version: Java 9 (2017)
 Part of: JDK
 Explanation: The module system allows you to group related
packages and manage dependencies.
 Use Case: Enhancing modularity and encapsulation in large
applications.
 Code Snippet:
java
Copy code
module my.module {
exports com.example;
}

e. Annotations
 Version: Java 5 (2004)
 Part of: JDK
 Explanation: Annotations provide metadata about the program, which
can be used by the compiler or at runtime.
 Use Case: Improving code readability and enabling frameworks to
process annotations.
 Code Snippet:
java
Copy code
@Override
public void method() {
// Implementation
}
4. Extra (Cutting Edge) Features

a. Records

 Version: Java 14 (2020)

 Part of: JDK
 Explanation: Records are a special kind of class in Java designed to
act as transparent carriers for immutable data. They provide a
compact syntax for declaring data-carrying classes without boilerplate
code.
 Use Case: Reducing boilerplate code for data classes, enhancing code
readability, and providing a clear intent of data storage.
 Sub-Concepts:
o Implicitly Final: Records cannot be subclassed.
o Canonical Constructor: Automatically generated constructor
based on declared fields.
o equals() and hashCode(): Automatically generated based on
fields.
 Code Snippet:
java
Copy code
public record Person(String name, int age) {}

public class Main {

public static void main(String[] args) {
Person alice = new Person("Alice", 30);
System.out.println(alice.name()); // Outputs: Alice
System.out.println(alice.age()); // Outputs: 30
}
}
b. Pattern Matching for instanceof

 Version: Java 16 (2021)

 Part of: JDK
 Explanation: Pattern matching simplifies the use of the instanceof
operator by allowing you to test an object’s type and cast it in a single
operation. This reduces boilerplate code and enhances readability.
 Use Case: Making type checks and casts cleaner and more expressive.
 Sub-Concepts:
o Type Guarding: The variable is automatically cast to the
specified type within the scope of the pattern.
 Code Snippet:
java
Copy code
public static void printLength(Object obj) {
if (obj instanceof String s) {
System.out.println("String length: " + s.length());
} else {
System.out.println("Not a string");
}
}

public class Main {

public static void main(String[] args) {
printLength("Hello, World!"); // Outputs: String length: 13
printLength(100); // Outputs: Not a string
}
}

c. Sealed Classes

 Version: Java 17 (2021)

 Part of: JDK
 Explanation: Sealed classes allow you to control which classes can
extend or implement them. This feature helps in defining a more
controlled class hierarchy.
 Use Case: Enforcing a specific structure in class hierarchies,
enhancing maintainability and security.
 Sub-Concepts:
 o Permits Clause: Specifies which classes are allowed to extend
the sealed class.
o Non-Sealed Classes: Classes that can be extended without
restriction.
 Code Snippet:
java
Copy code
public sealed class Shape permits Circle, Square {}

public final class Circle extends Shape {

// Circle implementation
}

public final class Square extends Shape {

// Square implementation
}

// Attempting to extend Shape in a non-permitted way will result in a

compile-time error.

d. Switch Expressions

 Version: Java 12 (2019)

 Part of: JDK
 Explanation: Switch expressions extend the traditional switch
statement to allow it to return a value, providing a more expressive
way to handle multiple conditions.
 Use Case: Simplifying the syntax for handling multiple cases and
returning values from a switch statement.
 Sub-Concepts:
o Arrow Syntax: Using -> to define case branches.
o Yield Statement: Returning a value from a switch expression.
 Code Snippet:
java
Copy code
public class Main {
public static void main(String[] args) {
int day = 2;
String dayName = switch (day) {
 case 1 -> "Monday";
case 2 -> "Tuesday";
case 3 -> "Wednesday";
default -> "Invalid day";
};
System.out.println(dayName); // Outputs: Tuesday
}
}

e. Foreign Function & Memory API (Incubator)

 Version: Java 17 (2021)

 Part of: JDK (Incubator)
 Explanation: This API allows Java programs to interoperate with code
and data outside of the Java runtime, enabling access to native
libraries and memory.
 Use Case: Accessing native libraries directly from Java code,
enhancing performance for certain operations.
 Sub-Concepts:
o Foreign Functions: Calling external C functions.
o Memory Access: Reading and writing to native memory.
 Code Snippet:
java
Copy code
import jdk.incubator.foreign.*;

public class Main {

public static void main(String[] args) {
// Example to access foreign functions will be available when the API is
stable.
}
}

f. JEP 411: Deprecate the Security Manager for Removal

 Version: Java 17 (2021)

 Part of: JDK
 Explanation: This JEP proposes to deprecate the Security Manager
and its associated API for removal in a future release.
  Use Case: Reflects a shift in Java's security model, encouraging
modern alternatives.

g. JEP 382: New macOS Rendering Pipeline

 Version: Java 17 (2021)

 Part of: JDK
 Explanation: A new rendering pipeline for macOS is introduced,
utilizing Apple’s Metal framework for better performance.
 Use Case: Improving graphics rendering performance on macOS.

h. Improved Pattern Matching for switch (Preview)

 Version: Java 17 (2021)

 Part of: JDK (Preview)
 Explanation: This feature enhances the switch statement to support
pattern matching, allowing for more flexible code.
 Use Case: Simplifying complex switch-case logic.
 Code Snippet:
java
Copy code
public void handleInput(Object input) {
switch (input) {
case String s -> System.out.println("String: " + s);
case Integer i -> System.out.println("Integer: " + i);
default -> System.out.println("Unknown type");
}
}