Java Fundamentals

Main Method: Entry point of any Java application.

public static void main(String[] args) {
    // code
}

Data Types:
- Primitive: int, char, double, boolean.
- Non-primitive: String, Arrays, Classes, Interfaces.

Conditional Statements: if, else if, else, switch.
Loops:
- for, while, do-while.
- Enhanced for loop for arrays and collections.

Try-Catch Blocks: Handle exceptions without crashing.

try {
    // code that may throw an exception
} catch (ExceptionType e) {
    // exception handler
}

Interfaces:
- List, Set, Map.
Common Implementations:
- ArrayList, LinkedList, HashSet, TreeSet, HashMap, TreeMap.
Iterators: For traversing collections.

JDK: Java Development Kit - includes JRE and development tools.
IDE: Integrated Development Environment (e.g., Eclipse, IntelliJ IDEA, NetBeans).
Build Tools: Maven and Gradle for project management.

Streams:
- Input and output streams for reading/writing data.
File Handling: FileReader, FileWriter, BufferedReader, BufferedWriter.

Use meaningful variable names.
Keep methods short and focused (Single Responsibility Principle).
Follow consistent naming conventions (CamelCase for classes, lower_case for variables).
Document code with comments and JavaDoc.

Garbage Collection: Automatic memory management.
Java APIs: Rich set of libraries for various functionalities (e.g., networking, XML parsing).
Java 8 Features:
- Lambda expressions, Streams API, Optional class.

This summary condenses essential Java fundamentals for quick reference and study.

Object-oriented programming language designed for flexibility and reusability.
Achieves platform independence through the Java Virtual Machine (JVM).
Syntax is derived from C and C++, facilitating easier learning for those familiar with these languages.

Main Method:
- Entry point for Java applications defined using public static void main(String[] args).
Data Types:
- Primitive Types: Include int (integer), char (character), double (floating-point number), and boolean (true/false).
- Non-primitive Types: Include String (a sequence of characters), Arrays, Classes, and Interfaces.

Conditional Statements: Used for decision-making with constructs like if, else if, else, and switch.
Loops:
- for, while, and do-while loops facilitate repeated execution.
- Enhanced for loop specifically designed for iterating through arrays and collections.

Classes and Objects: A class serves as a blueprint, while an object is an instance created from that blueprint.
Encapsulation: Achieved through access modifiers: private (restricted access), public (accessible from everywhere), and protected (limited access).
Inheritance: Allows a new class to inherit properties from an existing class using the extends keyword.
Polymorphism: Illustrated through method overloading (same method name with different parameters) and method overriding (subclass redefining a superclass method).
Abstraction: Implemented via abstract classes and interfaces to hide complex implementation details.

Try-Catch Blocks: Mechanism for handling exceptions to prevent application crashes.
Finally Block: Executes after try-catch regardless of exception occurrence, useful for cleanup.
Throw and Throws Keywords: Facilitate throwing exceptions explicitly in code.

Interfaces: Foundation includes List, Set, and Map for data structure types.
Common Implementations: Specific classes such as ArrayList, LinkedList, HashSet, TreeSet, HashMap, and TreeMap that realize these interfaces.
Iterators: Tools to traverse collections efficiently.

JDK: The Java Development Kit combines the Java Runtime Environment (JRE) and development tools for building Java applications.
IDE: Integrated Development Environments like Eclipse, IntelliJ IDEA, and NetBeans enhance code writing and debugging.
Build Tools: Tools such as Maven and Gradle assist in project management, dependency resolution, and automation.

Streams: Fundamental components for input and output operations, allowing data reading and writing.
File Handling: Employs classes like FileReader, FileWriter, BufferedReader, and BufferedWriter to manage file operations.

Threads: Concurrent execution modeled through the Thread class and Runnable interface.
Synchronization: Controls access to shared resources using the synchronized keyword to prevent data inconsistencies.
Executor Service: A framework for managing multiple concurrent threads efficiently using thread pools.

Use descriptive variable names for better code readability and maintainability.
Keep methods concise and focused (Single Responsibility Principle) to enhance clarity.
Maintain consistent naming conventions: CamelCase for classes, lower_case for variables.
Document code with comments and JavaDoc for future reference and ease of understanding.

Garbage Collection: Automatic memory management that reclaims memory from objects no longer in use.
Java APIs: Extensive set of libraries offering various functionalities including networking and XML processing.
Java 8 Features: Introduced enhancements like lambda expressions, the Streams API for functional programming, and the Optional class for better null handling.