Understanding Sequences and Context

Java is a high-level, object-oriented programming language, designed for portability, simplicity, and security.
Created in the mid-1990s by James Gosling at Sun Microsystems (now Oracle).
Platform independent, meaning programs run on any system with a Java Virtual Machine (JVM) installed.

Platform Independence: Java programs are compiled into bytecode, which can run on any platform with a JVM.
Object-Oriented Programming (OOP): Everything in Java is an object, promoting reusable code and managing complex applications effectively.
Robust and Secure: Java has built-in security features, including a security manager, to ensure safe execution even in untrusted environments.

The JVM is a critical component of the Java platform.
It interprets Java bytecode and translates it to machine language, enabling execution on any computer.
Java bytecode is a highly optimized set of instructions.

Console Programs: Text-based programs that operate in a command-line interface (CLI).
Desktop Applications: Programs with graphical user interfaces (GUIs) for tasks like image manipulation.
Web Applications: Server-side applications that provide services through web browsers.
Mobile Applications: Programs running on mobile devices (e.g., smartphones).
Applets: Small Java programs running within a web browser.
Enterprise Applications: Large-scale programs for corporate environments (e.g., customer relationship management).

Encapsulation: Bundling data and code that manipulates the data into a single unit.
Inheritance: Creating new classes (subclasses) by inheriting properties and methods from existing classes (superclasses).
Polymorphism: An object taking on multiple forms, exhibiting different behaviors depending on the context.
Abstraction: Hiding the implementation details of a class, showing only essential functionalities to the user.

Arithmetic: Perform basic mathematical operations (e.g., +, -, *, /, %).
Assignment: Assign values to variables (e.g., =, +=, -=).
Comparison: Compare two values (e.g., ==, !=, <, >, <=, >=).
Logical: Combine boolean values (e.g., &&, ||, !).
Bitwise: Operate on the binary representations of numerical values (e.g., &, |, ^).
Conditional: Short hand for if-else statements (e.g., condition ? value1 : value2).
Increment/Decrement: Increment or Decrement a variable (e.g.,++, --).

Decision Making: if/else, switch statements for conditional execution.
Looping: for, while, do-while statements for repeated execution of statements..

Single Dimensional: A linear collection of elements of the same datatype.
Multidimensional: (e.g., 2D arrays) Arrays of arrays (representing matrices).

Java automatically reclaims memory occupied by objects no longer in use to improve program efficiency.

Class: A blueprint or template for creating objects, that defines their attributes (data) and methods (functionality).
Object: An instance or realization of a class, possessing specific values for the data (attributes) defined in the class.

Default Constructors: Automatically included if not explicitly defined, initializing objects with default values
Parameterized Constructors: Initialize objects with specific values provided as parameters.

Method: A collection of statements that perform a specific task.
Method Overloading: Defining multiple methods with the same name but different parameters in a class. Enables polymorphism and reusability of code.

Inheritance: Creating new classes (child classes) that inherit properties and methods from existing classes (parent classes).
Single Inheritance: A child class inherits from one parent class.
Multilevel Inheritance: A class inherits from another class, which in turn inherits from another (and so on).
Hierarchical Inheritance: Multiple child classes inherit from one common parent class.
Multiple Inheritance (Interfaces): A class can implement multiple interfaces to achieve multiple inheritance (not of classes.)

Method Overriding: Creating methods in child classes with the same name and parameters as methods in a parent class, to provide a different implementation.

'this' keyword: A reference to the currently executing object.
Used for accessing instance variables when there's a name conflict. Creating a new object using the copy constructor.

Static variables: Shared among all objects of a class, with only one copy.
Static methods: Belong to the class, not any specific object; accessible without creating an object.
Static blocks: Code blocks executed when the class is loaded into memory, useful for initializing static variables or performing class-level initialization.

String: Represents a sequence of characters.
Methods: Numerous methods for manipulating strings (e.g., concatenation, substring, comparison, conversion);

Compile-time Errors: Problems detected during compilation (e.g., syntax errors, type mismatches).
Run-time Errors: Errors occurring during program execution (e.g., division by zero, array index out of bounds).
Logical Errors: Errors in the program's logic or algorithms (not typically reported by the compiler or JVM).
Exception Handling (try-catch): Mechanism for handling exceptions to prevent abrupt program termination when errors occur.
Checked Exceptions: Require explicit handling (e.g., file I/O exceptions, input/output exceptions).
Unchecked Exceptions: Runtime exceptions; do not need explicit handling (e.g., arithmetic exceptions, null pointer exceptions).

Threads: Light-weight processes allowing concurrent execution within a single program.
Multithreading: Using multiple threads to improve program responsiveness;
Thread lifecycle stages: New, Runnable, Running, Blocked, Waiting, Timed Waiting, Terminated.