Numeric overflow occurs when a calculation exceeds the maximum value for a data type, wrapping around to the minimum value (and vice versa for underflow). Java doesn't automatically detect these conditions. They should be handled by: using larger data types, checking bounds before operations, using Math.addExact() for checked arithmetic, or BigInteger/BigDecimal for precise calculations.
Floating-point arithmetic in Java can lead to precision issues due to binary representation limitations. Issues include: inexact decimal representations, rounding errors accumulation, and comparison problems. For precise decimal calculations, use BigDecimal. Special values like NaN and Infinity need careful handling. Understanding IEEE 754 standard helps in managing these issues.
Compile-time constants (static final primitives/strings initialized with constant expressions) are inlined by the compiler, improving performance by eliminating field access. They must be initialized at declaration and can't be changed. This optimization affects class loading and versioning - changes require recompilation of dependent classes.
The '==' operator compares object references (memory addresses) for reference types and actual values for primitive types. The '.equals()' method compares the content/values of objects. For proper object comparison, classes should override the equals() method inherited from Object class to provide meaningful value comparison.
Variables can be initialized through: 1) Direct initialization at declaration (int x = 10), 2) Static initialization blocks for static variables, 3) Instance initialization blocks for instance variables, 4) Constructor initialization, 5) Lazy initialization (first time use), 6) Default initialization (automatically by Java). The choice depends on requirements like timing and initialization complexity.
Traditional switch statements work with byte, short, int, char, enum, and String (Java 7+), requiring break to prevent fallthrough. Modern Java (12+) introduced switch expressions with arrow syntax (->), multiple case labels, yield keyword, and pattern matching. These enhancements make switch more concise and safer by eliminating accidental fallthrough.
Type inference (var keyword, introduced in Java 10) allows local variable types to be inferred by the compiler based on the initialization value. Limitations include: must be initialized at declaration, can't be used for fields/parameters/return types, can't be initialized to null, and type must be clearly inferrable. It improves code readability while maintaining type safety.
The enhanced for-loop (for-each) internally uses Iterator/Array indexing. It's syntactic sugar that simplifies iteration but has limitations: can't modify collection size during iteration, can't track index position, can't iterate multiple collections simultaneously, and requires Iterable implementation. Understanding these limitations helps choose between traditional and enhanced for-loops.
Type promotion occurs when mixing different data types in expressions. Java automatically promotes smaller types to larger ones following rules: byte/short/char are promoted to int, if one operand is long/float/double, the other is promoted to match. The final result type is the promoted type. This ensures accurate calculations without data loss.
String interning is the process of storing only one copy of each distinct string value in a pool. When strings are interned (using String.intern()), identical string literals reference the same memory location. It's useful for memory optimization when dealing with many duplicate strings, but should be used carefully as interning has overhead and can impact garbage collection.
Labeled statements allow targeting specific outer loops/blocks with break/continue statements. While useful for breaking out of nested loops or controlling complex flow, they should be used sparingly as they can make code harder to understand. Better alternatives often include extracting methods or restructuring logic to avoid deep nesting.
Java is a high-level, class-based, object-oriented programming language. Its key features include platform independence (Write Once Run Anywhere), object-oriented nature, automatic memory management (garbage collection), rich standard library, security features, and multithreading support. It compiles to bytecode that runs on the Java Virtual Machine (JVM).
Primitive data types (byte, short, int, long, float, double, boolean, char) are basic data types that store actual values in stack memory. Reference types (classes, interfaces, arrays) store references to objects in heap memory. Primitives have fixed sizes and can't be null, while reference types can be null and have methods associated with them.
Type casting is converting one data type to another. There are two types: 1) Implicit casting (widening) happens automatically when converting smaller to larger data types (int to long). 2) Explicit casting (narrowing) requires manual conversion for larger to smaller types (long to int) and may result in data loss. Reference type casting involves inheritance relationships.
Variable scope defines where a variable is accessible in code. Class variables (static) have class scope, instance variables have object scope, local variables have method scope, and block variables are only accessible within their block. Variable lifetime refers to how long they exist in memory - class variables exist for program duration, instance variables for object lifetime, and local variables until method/block execution ends.
break terminates the current loop or switch statement, continue skips the rest of the current iteration and starts the next one, while return exits the entire method with or without a value. break and continue affect control flow within loops, while return affects method execution. break can also include labels to break outer loops.
Method overloading occurs in the same class with methods having the same name but different parameters (number, type, or order). Method overriding occurs in inheritance relationships where a subclass provides a specific implementation of a method defined in its superclass, requiring the same signature and compatible return type.
Variable shadowing occurs when a variable declared within a narrower scope has the same name as a variable in a wider scope, temporarily hiding the outer variable. This can happen with local variables shadowing instance variables, or parameters shadowing class fields. It can lead to confusion and bugs if not properly managed using 'this' keyword or better naming.
Bitwise operators (&, |, ^, ~, <<, >>, >>>) manipulate individual bits in integer types. Common uses include: flags and permissions (using bitmasks), optimization for multiplication/division by powers of 2, low-level data manipulation, and memory-efficient data storage. Understanding two's complement representation is crucial for proper usage.
Java offers multiple string formatting options: concatenation (+), StringBuilder, String.format(), printf(), and text blocks (Java 15+). Each has trade-offs: concatenation is simple but inefficient for multiple operations, StringBuilder is efficient but verbose, String.format() is flexible but slower, text blocks improve multiline string readability but are limited to literal text.
