​Flow control statements in Java are essential for managing the execution flow of a program. They allow developers to make decisions, repeat actions, and control the sequence in which code is executed. By using flow control statements, you can create dynamic and flexible programs that respond to different conditions and inputs. <h2>Types of Flow Control Statements in Java </h2>Java flow control statements can be broadly categorized into three types:<ul><li style="background-color: transparent;font-size: 18px">Decision-Making Statements</li><li style="background-color: transparent;font-size: 18px">Looping Statements</li><li style="background-color: transparent;font-size: 18px">Branching Statements</li></ul><h3> </h3><h3>1. Decision-Making Statements </h3>​Decision-making statements allow the program to execute specific blocks of code based on certain conditions. These include: <h4>if Statement</h4>The <code>if</code> statement executes a block of code if a specified condition evaluates to <code>true</code>.<h4>Syntax</h4><pre>​​if (condition) { // Code to execute if condition is true } </pre><h4>Example:</h4><pre>int number = 10; if (number &gt; 0) { System.out.println("The number is positive."); } </pre><h3>if-else Statement </h3>​The <code>if-else</code> statement provides an alternative block of code to execute if the condition is <code>false</code>.<h4>Syntax:</h4><pre>​if (condition) { // Code to execute if condition is true } else { // Code to execute if condition is false } </pre><h4>Example:</h4><pre>​int number = -5; if (number &gt; 0) { System.out.println("The number is positive."); } else { System.out.println("The number is not positive."); } </pre><h3>if-else-if Ladder </h3>The <code>if-else-if</code> ladder is used to test multiple conditions sequentially.<h4>Syntax:</h4><pre>if (condition1) { // Code to execute if condition1 is true } else if (condition2) { // Code to execute if condition2 is true } else { // Code to execute if none of the conditions are true } </pre><h4>Example:</h4><pre>int number = 0; if (number &gt; 0) { System.out.println("The number is positive."); } else if (number &lt; 0) { System.out.println("The number is negative."); } else { System.out.println("The number is zero."); } </pre><h2>switch Statement </h2>​The <code>switch</code> statement is used to execute one block of code out of many based on the value of an expression.<h4>Syntax: </h4><pre>switch (expression) { case value1: // Code to execute if expression == value1 break; case value2: // Code to execute if expression == value2 break; // Additional cases default: // Code to execute if no case matches } </pre><h4>Example:</h4><pre>int day = 3; switch (day) { case 1: System.out.println("Monday"); break; case 2: System.out.println("Tuesday"); break; case 3: System.out.println("Wednesday"); break; default: System.out.println("Invalid day"); } </pre><h2 style="line-height: 1.2">Enhanced switch Statement</h2>​Java introduced the enhanced switch statement in Java 12 (as a preview feature) and officially finalized it in Java 14. This improvement makes switch statements more concise, readable, and expressive. <h3 class="">Key Enhancements:</h3><ol><li class="">Expression-Based Switch: <code>switch</code> can now return a value.</li><li class="" style="font-size: 18px">Multiple Labels (Comma-Separated Cases): One case can handle multiple values.</li><li class="" style="font-size: 18px">Arrow (<code>-&gt;</code>) Syntax: Eliminates the need for <code>break</code> statements.</li><li class="" style="font-size: 18px">Pattern Matching (Preview Feature): Introduced in later versions to allow type-checking.</li></ol><h4>Example:</h4><pre>public class EnhancedSwitchExample { public static void main(String[] args) { String day = "MONDAY"; int numLetters = switch (day) { case "MONDAY", "FRIDAY", "SUNDAY" -&gt; 6; case "TUESDAY" -&gt; 7; default -&gt; 8; }; System.out.println(numLetters); } }​ </pre><h2>2. Looping Statements </h2>​Looping statements allow a block of code to be executed repeatedly based on a condition. Java provides three types of loops: <h3>for Loop</h3>The <code>for</code> loop is used when the number of iterations is known beforehand.<h4>Syntax:</h4><pre>​for (initialization; condition; update) { // Code to execute in each iteration } </pre><h4>Example:</h4><pre>​for (int i = 1; i &lt;= 5; i++) { System.out.println("Iteration: " + i); } </pre><div style="background-color: transparent"> </div><h3 style="line-height: 1.2">for-each&nbsp; Loop (Enhanced Loop)</h3>​The for-each loop (also called the enhanced for loop) in Java is a simpler and more readable way to iterate over collections, arrays, or any <code>Iterable</code> object. <h4>Syntax:</h4><pre>for (Type variable : collection) { // Code to be executed } ​​ </pre><h4>Example:&nbsp;</h4><pre>public class ForEachArray { public static void main(String[] args) { int[] numbers = {1, 2, 3, 4, 5}; for (int num : numbers) { System.out.print(num + " "); } } } ​ </pre>​ <h3>while Loop</h3>The <code>while</code> loop is used when the number of iterations is not known, and the loop continues as long as the condition is <code>true</code>.<h4>Syntax:</h4><pre>while (condition) { // Code to execute while condition is true } </pre><div style="background-color: transparent"> </div><h4>Example:​</h4><pre>​int i = 1; while (i &lt;= 5) { System.out.println("Iteration: " + i); i++; } </pre><h3>do-while Loop </h3>​The <code>do-while</code> loop is similar to the <code>while</code> loop, but it guarantees that the code block is executed at least once.​ <pre>​​do { // Code to execute } while (condition); </pre> <h4>Example:</h4><pre>​int i = 1; do { System.out.println("Iteration: " + i); i++; } while (i &lt;= 5); </pre><div style="background-color: transparent"> </div><h2>3. Branching Statements </h2>​Branching statements are used to alter the normal flow of execution in a program. These include:<h3></h3><h4>break Statement</h4>​The <code>break</code> statement is used to exit a loop or a <code>switch</code> statement prematurely.<h4>​Example:</h4><pre>​for (int i = 1; i &lt;= 5; i++) { if (i == 3) { break; // Exit the loop when i == 3 } System.out.println("Iteration: " + i); } </pre><div style="background-color: transparent"> </div><h3>continue Statement</h3>The <code>continue</code> statement skips the current iteration of a loop and proceeds to the next iteration.<h4>Example:</h4><pre>for (int i = 1; i &lt;= 5; i++) { if (i == 3) { continue; // Skip the iteration when i == 3 } System.out.println("Iteration: " + i);} </pre><div style="background-color: transparent"></div><h3>return Statement</h3>​The <code>return</code> statement is used to exit from a method and optionally return a value. <h4>Example:</h4><pre>​public int add(int a, int b) { return a + b; // Exit the method and return the sum } </pre> <h3>Labelled break and continue</h3>​Java allows the use of labels with <code>break</code> and <code>continue</code> to control nested loops. <h4>Example:</h4><pre>outerLoop: for (int i = 1; i &lt;= 3; i++) { for (int j = 1; j &lt;= 3; j++) { if (i == 2 &amp;&amp; j == 2) { break outerLoop; // Exit the outer loop } System.out.println("i = " + i + ", j = " + j); } } </pre><h2> </h2><h2>Flow Control Statement Best Practices </h2><blockquote><ul><li style="background-color: transparent">Use meaningful conditions: Ensure that conditions in <code>if</code>, <code>while</code>, or <code>for</code> statements are clear and meaningful.</li><li style="background-color: transparent;font-size: 18px">Avoid infinite loops: Always include a termination condition in loops to prevent infinite execution.</li><li style="background-color: transparent;font-size: 18px">Minimize nested loops: Excessive nesting can make code harder to read and maintain.</li><li style="background-color: transparent">Use <code>switch</code> for multiple conditions: When testing a single variable against multiple values, prefer <code>switch</code> over <code>if-else</code> for better readability.</li></ul></blockquote>​ <div style="background-color: transparent"></div>

Java Flow Control Statements

<h1>Java Fundamental Course </h1><h3>Topics to cover </h3><ul><li style="font-size: 16px"><a href="https://www.cstechie.com/course/java/jdk-download-and-installation">Download and installation</a>​ </li><li style="font-size: 16px;color: rgb(0, 85, 255)">​<a href="https://www.cstechie.com/course/java/home">JVM &amp; JDK</a>​</li><li style="font-size: 16px;color: rgb(0, 85, 255)">​<a href="https://www.cstechie.com/course/java/home">Garbage Collections</a>​</li><li style="font-size: 16px">​<a href="https://www.cstechie.com/course/java/home">OOPS Concept</a>​</li></ul>

Java Home

To Run Java our own machine JDK needs to get installed on the machine.<h2>To Download: </h2>To download JDK we have to visit official website and select desired version and download it. Website:&nbsp;<a href="https://www.oracle.com/java/technologies/javase-downloads.html" target="_blank">https://www.oracle.com/java/technologies/javase-downloads.html​</a><h2>JDK Installation:</h2><h2>On Window:</h2><h3>​Method 1: Using the Installer (Recommended) </h3><ol><li style="font-size: 16px">​Download the <code>.exe</code> installer. </li><li style="font-size: 16px">Run the installer and follow the setup wizard. </li><li style="font-size: 16px">Set JAVA_HOME (Environment Variable): Open System Properties → Advanced → Environment Variables. Under "System Variables," click New and enter: Variable Name:<code>JAVA_HOME Variable Value:C:\Program Files\Java\jdk-XX (Replace XX with the version number</code></li><li style="font-size: 16px">Edit the Path variable and add: </li></ol><pre>%JAVA_HOME%\bin </pre>5. Verify Installation: Open Command Prompt (cmd) and run: <pre>​​java -version javac -version </pre><h2>On MacOS: </h2><h3>​Method 1: Using Homebrew (Recommended) </h3>1.&nbsp;Open Terminal and run:<pre>brew install openjdk </pre>2.&nbsp;Add JDK to your environment:<pre>​​echo 'export PATH="/opt/homebrew/opt/openjdk/bin:$PATH"' &gt;&gt; ~/.zshrc source ~/.zshrc</pre>3.&nbsp;Verify installation:<pre>​​java -version </pre><h3>Method 2: Manual Installation</h3><ol><li>Download the <code>.dmg</code> file from the Oracle website.</li><li style="font-size: 16px">Open the installer and follow the instructions.</li><li style="font-size: 16px">Verify with:</li></ol><pre>java -version </pre><h2>​​Linux Installation (Ubuntu/Debian) </h2><h3>​Method 1: Install OpenJDK (Recommended) </h3>1.&nbsp;Update package index <pre>​​sudo apt update </pre>2.&nbsp;Install JDK (e.g., JDK 17)<pre>​​sudo apt install openjdk-17-jdk -y </pre>3.&nbsp;Verify Installation<pre>​​java -version javac -version</pre><h2>Method 2: Install Oracle JDK</h2><ol><li>Download the <code>.tar.gz</code> file from Oracle.</li><li>Extract and move it to <code>/usr/lib/jvm</code></li></ol><pre>sudo mkdir -p /usr/lib/jvm sudo tar -xvzf jdk-XX.tar.gz -C /usr/lib/jvm </pre>3.&nbsp;Set Java alternatives:<pre>​​sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/jdk-XX/bin/java 1 sudo update-alternatives --config java</pre>4.&nbsp;Verify installation:<pre>​​java -version </pre><h2>​Set Up JAVA_HOME </h2>For Window JAVA_HOME set up is already mentioned above. For MacOs/Linux follow below steps:Add below command in&nbsp;~/.bashrc or ~/.zshrc:&nbsp;<pre>​​export JAVA_HOME=$(dirname $(dirname $(readlink -f $(which java)))) export PATH=$JAVA_HOME/bin:$PATH</pre>Then, reload: <pre>​​source ~/.zshrc # or source ~/.bashrc </pre><h2>​​Verify the Installation </h2><pre>java -version javac -version echo $JAVA_HOME </pre>

JDK Download And Installation

​Java is one of the most popular programming languages, and its platform is built on three core components: JDK (Java Development Kit), JVM (Java Virtual Machine), and JRE (Java Runtime Environment). These components work together to enable the development, compilation, and execution of Java programs. In this article, we’ll explore each of these components in detail, provide examples, and include a diagram to illustrate their relationships. <div class="se-component se-image-container __se__float-none"><figure style="width: 100%;"><img src="https://www.api.cstechie.com/upload/editor-image/JDK,_JRE,_and_JVM_Diagram_1742196142271.png" alt="JDK, JVM &amp; JRE diagram" data-rotate="" data-proportion="true" data-size="100%," data-align="none" data-percentage="100," data-file-name="JDK, JRE, and JVM Diagram.png" data-file-size="17618" data-origin="," origin-size="800,600" style="width: 100%;"></figure></div><h2>​​What is JDK? </h2>​The Java Development Kit (JDK) is a software development environment used to develop Java applications. It includes tools for writing, compiling, and debugging Java programs. The JDK is essential for developers because it provides everything needed to create Java applications. <h2>​​Key Components of JDK: </h2><ol><li style="background-color: transparent">Java Compiler (javac): Converts Java source code (<code>.java</code> files) into bytecode (<code>.class</code> files).</li><li style="background-color: transparent;font-size: 16px">Development Tools: Includes tools like <code>jlink</code>, <code>javadoc</code>, and <code>jdb</code> for linking, documenting, and debugging respectively.</li><li style="background-color: transparent;font-size: 16px">JRE: The JDK includes the JRE, which is required to run Java programs.</li></ol>Example:Suppose you write a simple Java program:<pre>public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } }</pre>To compile and run this program, you need the JDK. The <code>javac</code> compiler converts the <code>HelloWorld.java</code> file into <code>HelloWorld.class</code> (bytecode), which can then be executed by the JVM.<h2>​​What is JRE? </h2>​The Java Runtime Environment (JRE) is a part of the JDK that provides the runtime environment required to execute Java programs. It includes the Java Virtual Machine (JVM) and a set of class libraries that Java programs use. <h2>Key Components of JRE:</h2><ol class=""><li style="background-color: transparent">Class Libraries: Predefined classes and APIs (e.g., <code>java.util</code>, <code>java.io</code>) that provide functionality like data structures, file handling, and networking.</li><li style="background-color: transparent;font-size: 16px">JVM: The JRE includes the JVM, which executes the bytecode.</li></ol><h2> </h2><h4>Example:</h4>If you only want to run a Java program (not develop it), you can install the JRE. For instance, if you have the <code>HelloWorld.class</code> file, the JRE will allow you to execute it using the <code>java</code> command.<h2>What is JVM?</h2>The Java Virtual Machine (JVM) is the heart of the Java platform. It is responsible for executing Java bytecode. The JVM is platform-dependent, meaning it is tailored for specific operating systems, but it provides a platform-independent execution environment for Java programs.<h3>Key Components of JVM:</h3><ul><li style="background-color: transparent">Class Loader: Loads <code>.class</code> files into memory.</li><li style="background-color: transparent;font-size: 16px">Bytecode Verifier: Ensures the bytecode is valid and secure.</li><li style="background-color: transparent">Execution Engine: Executes the bytecode. It includes:<ul><li style="background-color: transparent;font-size: 16px">Interpreter: Executes bytecode line by line.</li><li style="background-color: transparent;font-size: 16px">Just-In-Time (JIT) Compiler: Converts bytecode into native machine code for faster execution.</li></ul></li><li style="background-color: transparent;font-size: 16px">Garbage Collector: Automatically manages memory by removing unused objects.</li></ul><h3> </h3><h4>Example:</h4>When you run the <code>HelloWorld.class</code> file using the <code>java</code> command, the JVM:<ol class=""><li style="background-color: transparent;font-size: 16px">Loads the bytecode into memory using the Class Loader.</li><li style="background-color: transparent;font-size: 16px">Verifies the bytecode for security.</li><li style="background-color: transparent;font-size: 16px">Executes the bytecode using the Execution Engine.</li></ol> <h2>Relationship Between JDK, JRE, and JVM</h2><ul class=""><li style="background-color: transparent;font-size: 16px">JDK: Includes tools for development (e.g., compiler) and the JRE.</li><li style="background-color: transparent;font-size: 16px">JRE: Provides the runtime environment, including the JVM and class libraries.</li><li style="background-color: transparent;font-size: 16px">JVM: Executes the bytecode and is part of the JRE.</li></ul><div class="se-component se-image-container __se__float-none"><figure><img src="https://www.api.cstechie.com/upload/editor-image/JDK_Internal_Working_Diagram_1742196846580.png" alt="JDK Internal Working structure diagram" data-rotate="" data-proportion="true" data-size="," data-align="none" data-percentage="auto,auto" data-file-name="JDK Internal Working Diagram.png" data-file-size="32138" data-origin="," style=""></figure></div>

JDK, JVM  and  JRE Utilities

​Java's Garbage Collector (GC) is a key feature of the Java Virtual Machine (JVM) that automatically manages memory. It helps developers by reclaiming memory occupied by objects that are no longer in use, preventing memory leaks and reducing the need for manual memory management. Understanding how the garbage collector works internally and its utilities can help developers write more efficient and optimized code. <h2>​​What Is the Garbage Collector? </h2>​In Java, memory is divided into two main areas: the heap and the stack. The heap is where objects are stored, while the stack is used for method execution and local variables. Over time, as objects are created and discarded, the heap can become cluttered with unused objects. The garbage collector identifies and removes these unused objects, freeing up memory for new allocations. <h2>​​How the Garbage Collector Works Internally? </h2>​The garbage collector operates based on the concept of reachability. An object is considered "reachable" if it can be accessed directly or indirectly by a live thread. If an object is no longer reachable, it is considered garbage and eligible for collection. Here's a breakdown of how the garbage collector works internally: Object Allocation: <ul><li style="background-color: transparent;font-size: 18px">When a new object is created, it is allocated memory in the heap.</li><li style="background-color: transparent;font-size: 18px">The JVM keeps track of all objects and their references.</li></ul>Mark-and-Sweep Algorithm: The garbage collector uses the mark-and-sweep process to identify and remove unused objects. <ul><li style="background-color: transparent;font-size: 18px">Mark Phase: The GC traverses the object graph starting from "root" references (e.g., static variables, local variables, and active threads) and marks all reachable objects.</li><li style="background-color: transparent;font-size: 18px">Sweep Phase: The GC scans the heap and removes objects that were not marked as reachable.</li></ul>​Generational Garbage Collection: To optimize performance, the heap is divided into generations:<ul><li style="background-color: transparent">Young Generation: Newly created objects are allocated here. Most objects are short-lived and are quickly garbage collected.</li><li style="background-color: transparent">Old Generation (Tenured): Objects that survive multiple garbage collection cycles in the young generation are promoted to the old generation.</li><li style="background-color: transparent">Permanent Generation (Metaspace in Java 8+): Stores metadata about classes and methods.</li></ul>The GC focuses on the young generation more frequently since most objects die young, making the process faster. ​Stop-the-World Events: During garbage collection, the JVM may pause all application threads to perform the cleanup. These pauses are called stop-the-world events and can impact application performance if not managed properly. Compacting:After removing unused objects, the GC may compact the heap to reduce fragmentation and improve memory allocation efficiency. <div class="se-component se-image-container __se__float-none" style="width: 100%"><figure style="width: 100%;"><img src="https://www.api.cstechie.com/upload/editor-image/garbage-collector-com_1742654718709.png" alt="Garbage Colector Comprehensive Diagram" data-rotate="" data-proportion="true" data-size="100%," data-align="none" data-percentage="100," data-file-name="garbage-collector-com.png" data-file-size="75407" data-origin="," style="width: 100%;"></figure></div><h2>​​Types of Garbage Collectors in Java </h2>Java provides several garbage collection algorithms, each optimized for different use cases:​ Serial Garbage Collector:A simple, single-threaded collector suitable for single-threaded applications or small heaps.Parallel Garbage Collector:Uses multiple threads to perform garbage collection, making it suitable for multi-threaded applications.CMS (Concurrent Mark-Sweep) Garbage Collector:Performs most of its work concurrently with the application threads, reducing stop-the-world pauses.G1 (Garbage-First) Garbage Collector:Divides the heap into regions and prioritizes collecting regions with the most garbage. It balances throughput and low latency.Z Garbage Collector (ZGC):Designed for low-latency applications, it performs most of its work concurrently and minimizes pause times.Shenandoah Garbage Collector:Similar to ZGC, it focuses on low-latency garbage collection with concurrent compaction.<h2>Utilities of the Garbage Collector</h2>Automatic Memory Management:Developers don't need to manually allocate or deallocate memory, reducing the risk of memory leaks and dangling pointers.Improved Application Stability: By reclaiming unused memory, the GC ensures that the application doesn't run out of memory, improving stability. Optimize​d Performance:Generational garbage collection and compacting help optimize memory usage and reduce fragmentation. Ease of Development: Developers can focus on writing business logic without worrying about low-level memory management. Monitoring and Tuning: Java provides tools like JVisualVM, JConsole, and Garbage Collection Logs to monitor and tune garbage collection performance. <h2>​​Best Practices for Working with the Garbage Collector </h2><ol><li style="background-color: transparent;font-size: 18px">Minimize Object Creation: Reuse objects where possible to reduce the load on the GC.</li><li style="background-color: transparent;font-size: 18px">Use Appropriate Data Structures: Choose efficient data structures to avoid unnecessary memory usage.</li><li style="background-color: transparent;font-size: 18px">Avoid Memory Leaks: Ensure that unused objects are not referenced, as this prevents the GC from reclaiming them.</li><li style="background-color: transparent;font-size: 18px">Tune the GC: Use JVM options (e.g., <code>-XX:+UseG1GC</code>, <code>-Xms</code>, <code>-Xmx</code>) to configure the garbage collector for your application's needs.</li><li style="background-color: transparent;font-size: 18px">Monitor Performance: Regularly monitor GC logs and application performance to identify and address bottlenecks.</li></ol>

Garbage Collector

​Java is a widely-used programming language that follows the Object-Oriented Programming (OOP) paradigm. OOP is a programming model that organizes software design around objects rather than functions or logic. This approach makes Java more modular, reusable, and easier to maintain.&nbsp; There are four pronciple of Object Oriented Programming:<ul><li>Encapsulation</li><li>Inheritance</li><li>Polymorphism</li><li>Abstraction</li></ul><h2>​​1. Encapsulation </h2>​Encapsulation is the process of wrapping data (variables) and methods (functions) into a single unit, typically a class. It restricts direct access to the internal state of an object and allows controlled access through methods, often referred to as getters and setters. This ensures data security and integrity. Example:<pre>​​public class Person { private String name; // Private variable // Getter method public String getName() { return name; } // Setter method public void setName(String name) { this.name = name; } } </pre>Here, the <code>name</code> variable is private, meaning it cannot be accessed directly from outside the class. Instead, the <code>getName</code> and <code>setName</code> methods provide controlled access.<h2>2. Inheritance</h2>Inheritance allows a class (child class) to inherit properties and methods from another class (parent class). This promotes code reuse and establishes a hierarchical relationship between classes. In Java, inheritance is implemented using the <code>extends</code> keyword.For example:<pre>class Animal { void eat() { System.out.println("This animal eats food."); } } class Dog extends Animal { void bark() { System.out.println("The dog barks."); } } public class Main { public static void main(String[] args) { Dog dog = new Dog(); dog.eat(); // Inherited method dog.bark(); // Method from Dog class } } </pre>In this example, the <code>Dog</code> class inherits the <code>eat</code> method from the <code>Animal</code> class, while also having its own <code>bark</code> method.<h2>3. Polymorphism</h2>Polymorphism allows objects to take on multiple forms. In Java, it is achieved through method overloading (compile-time polymorphism) and method overriding (runtime polymorphism). This makes the code more flexible and dynamic.Method Overloading: Multiple methods in the same class with the same name but different parameters.<pre>class Calculator { int add(int a, int b) { return a + b; } double add(double a, double b) { return a + b; } } ​ </pre>​Method Overriding: A subclass provides a specific implementation of a method already defined in its parent class.<pre>class Animal { void sound() { System.out.println("This animal makes a sound."); } } class Cat extends Animal { @Override void sound() { System.out.println("The cat meows."); } } public class Main { public static void main(String[] args) { Animal animal=new Cat(); animal.sound(); // Calls the overridden method in Cat } }​ </pre><h2>​​4. Abstraction </h2>​Abstraction focuses on hiding implementation details and showing only the essential features of an object. In Java, abstraction is achieved using abstract classes and interfaces. Abstract Class: A class that cannot be instantiated and may contain abstract methods (methods without a body). Example:<pre>​​abstract class Shape { abstract void draw(); // Abstract method } class Circle extends Shape { void draw() { System.out.println("Drawing a circle."); } } </pre>​Interface: A blueprint for a class that contains abstract methods. A class implements an interface using the <code>implements</code> keyword.<pre>interface Animal { void makeSound(); } class Dog implements Animal { public void makeSound() { System.out.println("The dog barks."); } }​ </pre>

OOPS Principles

Java programs are built using a combination of fundamental components that work together to create functional and efficient applications. These building blocks form the foundation of Java programming and include elements like classes, objects, methods, variables, and more. Let’s explore each of these in detail.<h2>1. Class </h2>A class is the blueprint or template for creating objects. It defines the structure and behavior of objects by encapsulating data (fields) and methods (functions). Every Java program must have at least one class.For example:<pre>​public class Car { String brand; // Field int speed; // Field void drive() { // Method System.out.println("The car is driving."); } } </pre><h2>​​2. Objects </h2>​An object is an instance of a class. It represents a real-world entity and has a state (data) and behavior (methods). Objects are created using the <code>new</code> keyword. Example:<pre>​​public class Main { public static void main(String[] args) { Car myCar = new Car(); // Creating an object myCar.brand = "Toyota"; // Setting field values myCar.speed = 120; myCar.drive(); // Calling a method } } </pre><h2>​​3. Methods </h2>​A method is a block of code that performs a specific task. Methods define the behavior of a class and can be called to execute their functionality. They may take parameters and return a value. Example:<pre>​​public class Calculator { int add(int a, int b) { // Method with parameters return a + b; // Returns the sum } } </pre><h2>​​4. Variables</h2>Variables are used to store data in a Java program. They have a type (e.g., <code>int</code>, <code>String</code>) and a name. Variables can be classified into:<ul class=""><li style="background-color: transparent;font-size: 18px">Instance Variables: Declared inside a class but outside methods, and belong to an object.</li><li style="background-color: transparent;font-size: 18px">Local Variables: Declared inside a method and accessible only within that method.</li><li style="background-color: transparent">Static Variables: Declared with the <code>static</code> keyword and shared among all objects of the class.</li></ul>Example<pre>​​public class Example { int instanceVar = 10; // Instance variable static int staticVar = 20; // Static variable void display() { int localVar = 30; // Local variable System.out.println(localVar); } } </pre><h2>​​5. Data Types</h2>Java is a strongly-typed language, meaning every variable must have a type. Data types are divided into:<ul class=""><li style="background-color: transparent;font-size: 18px">Primitive Types: Includes <code>int</code>, <code>float</code>, <code>char</code>, <code>boolean</code>, etc.</li><li style="background-color: transparent;font-size: 18px">Reference Types: Includes objects, arrays, and interfaces.</li></ul>Example:<pre>int age = 25; // Primitive type String name = "John"; // Reference type </pre><h2>​​6. Control Statements </h2>​Control statements determine the flow of execution in a program. They include:<ul class=""><li style="background-color: transparent;font-size: 18px">Conditional Statements: <code>if</code>, <code>else</code>, <code>switch</code></li><li style="background-color: transparent;font-size: 18px">Loops: <code>for</code>, <code>while</code>, <code>do-while</code></li><li style="background-color: transparent">Branching Statements: <code>break</code>, <code>continue</code>, <code>return</code></li></ul>Example:<pre>​​if (age &gt; 18) { System.out.println("You are an adult."); } else { System.out.println("You are a minor."); } </pre><h2>​​7. Packages </h2>​A package is a namespace that organizes classes and interfaces. It helps avoid name conflicts and makes code modular. Java provides built-in packages (e.g., <code>java.util</code>, <code>java.io</code>) and allows you to create custom packages. Example:<pre>​​package mypackage; public class MyClass { public void display() { System.out.println("This is a custom package."); } } </pre><h2>​​8. Libraries and APIs</h2>Java provides a rich set of libraries and APIs (Application Programming Interfaces) to perform various tasks, such as file handling, networking, and database access. These libraries are part of the Java Development Kit (JDK).For example, the <code>java.util</code> package contains classes like <code>ArrayList</code> and <code>HashMap</code> for data structures.<h2>​9. Main Method </h2>​The main method is the entry point of any Java program. It is where the program starts execution. The syntax is: <pre>​​public static void main(String[] args) { // Code to execute } </pre><h2>10. Comments</h2><h2>​Comments are used to document code and make it more readable. Java supports:</h2><ul class=""><li style="background-color: transparent;font-size: 18px">Single-line comments: <code>// This is a comment</code></li><li style="background-color: transparent;font-size: 18px">Multi-line comments: <code>/* This is a multi-line comment */</code></li><li style="background-color: transparent">Documentation comments: <code>/** This is a documentation comment */</code></li></ul><h2> </h2>​

Building Blocks of Java Programs

​Static members in Java belong to the class rather than any specific instance of the class. They are shared across all instances and can be accessed without creating an object. Let's explore the different types of static members and their uses. <h2>​​1. Static Variables </h2>​Static variables (also called class variables) are shared by all instances of a class. They are declared using the <code>static</code> keyword and are initialized only once when the class is loaded into memory. <pre>​​public class Counter { private static int count = 0; // Static variable private int instanceCount = 0; // Instance variable public Counter() { count++; // Increments the shared counter instanceCount++; // Increments individual counter } public static int getCount() { return count; } public int getInstanceCount() { return instanceCount; } } </pre>Usage Example: <pre>Counter c1 = new Counter(); Counter c2 = new Counter(); System.out.println(Counter.getCount()); // Outputs: 2 System.out.println(c1.getInstanceCount()); // Outputs: 1 System.out.println(c2.getInstanceCount()); // Outputs: 1 </pre><blockquote>As per above example Counter.getCount() method produce 2 while getInstanceCount() is 1 because during creation of object (c1 &amp; c2 ) Counter constructor called two times so initial value of static count value 0 incremented 2 times become 2. </blockquote><h2>​​2. Static Methods </h2>​Static methods belong to the class rather than instances. They:<ul class=""><li style="background-color: transparent;font-size: 18px">Can only directly access other static members</li><li style="background-color: transparent;font-size: 18px">Cannot use the <code>this</code> keyword</li><li style="background-color: transparent;font-size: 18px">Can be called without creating an object</li><li style="background-color: transparent;font-size: 18px">Cannot be overridden (though they can be hidden)</li></ul><pre>public class MathOperations { public static int add(int a, int b) { return a + b; } public static double calculateArea(double radius) { return Math.PI * radius * radius; } } // Usage int sum = MathOperations.add(5, 3); // Called without creating objectdouble area = MathOperations.calculateArea(5); // Static method call </pre><h2>​​3. Static Blocks </h2>​Static blocks are used for static initialization. They run when the class is first loaded into memory, before any static methods are called and before any instances are created. <pre>​​public class DatabaseConnection { private static String url; private static String username; // Static initialization block static { try { Properties props = new Properties(); props.load(new FileInputStream("config.properties")); url = props.getProperty("db.url"); username = props.getProperty("db.username"); } catch (IOException e) { System.err.println("Failed to load configuration"); } } } </pre><h2>​​4. Static Classes (Nested Classes) </h2>​A static nested class is a static member of its enclosing class. It:<ul class=""><li style="background-color: transparent;font-size: 18px">Can only access static members of the outer class</li><li style="background-color: transparent;font-size: 18px">Can be instantiated without an instance of the enclosing class</li><li style="background-color: transparent;font-size: 18px">Cannot access non-static members of the outer class directly</li></ul><pre>public class OuterClass { private static int outerStaticVar = 10; private int outerInstanceVar = 20; // Static nested class public static class StaticNestedClass { public void display() { System.out.println(outerStaticVar); // Can access static members // Cannot access outerInstanceVar directly } }} // Usage OuterClass.StaticNestedClass nested = new OuterClass.StaticNestedClass(); </pre><h2>​​Common Use Cases for Static Members </h2>​Utility Classes <pre>​public class StringUtils { public static String reverse(String str) { return new StringBuilder(str).reverse().toString(); } public static boolean isPalindrome(String str) { return str.equals(reverse(str)); } } </pre>Constants <pre>public class Constants { public static final double PI = 3.14159; public static final String APP_NAME = "MyApplication"; public static final int MAX_CONNECTIONS = 100; } </pre>Factory Methods <pre>public class AnimalFactory { public static Animal createAnimal(String type) { switch(type.toLowerCase()) { case "dog": return new Dog(); case "cat": return new Cat(); default: throw new IllegalArgumentException("Unknown animal type"); } }} </pre><h2>​​Best Practices and Considerations </h2><ol><li style="background-color: transparent">Avoid static members when:<ul class=""><li style="background-color: transparent;font-size: 18px">The value/behavior should be shared across all instances</li><li style="background-color: transparent;font-size: 18px">Utility functions don't require instance state</li><li style="background-color: transparent;font-size: 18px">Implementing factory methods</li><li style="background-color: transparent;font-size: 18px">Defining constants</li></ul></li><li style="background-color: transparent">Memory Management:<ul class=""><li style="background-color: transparent;font-size: 18px">Instance-specific behavior is needed</li><li style="background-color: transparent;font-size: 18px">State needs to vary between instances</li><li style="background-color: transparent;font-size: 18px">Testing requires mocking (static methods are harder to mock)</li></ul></li><li style="background-color: transparent">Thread Safety:<ul class=""><li style="background-color: transparent;font-size: 18px">Static members are shared across threads</li><li style="background-color: transparent;font-size: 18px">Consider thread safety when using static variables in multi-threaded applications</li></ul><ul class=""><li style="background-color: transparent;font-size: 18px">Static members stay in memory for the entire lifetime of the application</li><li style="background-color: transparent;font-size: 18px">Use them judiciously to avoid memory issues</li></ul></li><li>Use static members when:</li><ul class=""><li style="background-color: transparent;font-size: 18px">The value/behavior should be shared across all instances</li><li style="background-color: transparent;font-size: 18px">Utility functions don't require instance state</li><li style="background-color: transparent;font-size: 18px">Implementing factory methods</li><li style="background-color: transparent;font-size: 18px">Defining constants</li></ul></ol>

Static Members in Java

<h2>Java Data Types</h2>​Java's type system forms the foundation of its strong typing mechanism, which helps catch errors at compile time rather than runtime. Java data types are divided into two main categories:​​ <h2>​​Primitive Data Types </h2>​Java features eight built-in primitive data types that store simple values: byte: 8-bit signed integer (-128 to 127) <pre>​​byte smallNumber = 100; </pre>​short: 16-bit signed integer (-32,768 to 32,767)<pre>short mediumNumber = 20000; </pre>​int: 32-bit signed integer (-2,147,483,648 to 2,147,483,647)<pre>int standardNumber = 1000000; </pre><div style="background-color: transparent">​long: 64-bit signed integer (very large range) </div><pre>​​long bigNumber = 9223372036854775807L; // Note the 'L' suffix</pre>​float: 32-bit floating-point number​<pre>float decimalNumber = 3.14f; // Note the 'f' suffix </pre>​double: 64-bit floating-point number (higher precision)<pre>double preciseDecimal = 3.14159265359; </pre>​char: 16-bit Unicode character<pre>char singleCharacter = 'A'; </pre>​boolean: Represents true or false values<pre>boolean isJavaFun = true; </pre><h2>Reference Data Types </h2>​Reference types store references to objects rather than the actual values: Classes: User-defined types that serve as blueprints for objects <pre>​​String name = "Java Programming"; </pre>​Arrays: Collections of similar data types​ <pre>​​int[] numbers = {1, 2, 3, 4, 5}; </pre>​Interfaces: Abstract types that specify behavior <pre>​​List&lt;String&gt; programmingLanguages = new ArrayList&lt;&gt;(); </pre><h2>​​Java Literals: Fixed Values in Your Code</h2>Literals are fixed values that appear directly in your code. Java supports several types of literals:<h3>Integer Literals</h3><pre>int decimalLiteral = 42; // Decimal (base 10) int octalLiteral = 052; // Octal (base 8) - prefix with 0int hexadecimalLiteral = 0x2A; // Hexadecimal (base 16) - prefix with 0xint binaryLiteral = 0b101010; // Binary (base 2) - prefix with 0b </pre><h3>Floating-Point Literals</h3><pre>​​double standardDouble = 3.14; double scientificNotation = 3.14e2; // 3.14 × 10² = 314.0 float floatLiteral = 3.14f; // 'f' suffix for float </pre><h3>Character Literals</h3><pre>​char regularChar = 'A'; char unicodeChar = '\u0041'; // Unicode representation of 'A'char escape Char = '\n'; // Newline character </pre><h3>String Literals</h3><pre>​String message = "Hello, Java!"; String multiline = """ This is a multi-line text block in Java 15+ """; // Text blocks (Java 15+) </pre><div style="background-color: transparent">Boolean Literals</div><pre>​​boolean isTrue = true; boolean isFalse = false; </pre><h3>The Null Literal</h3><pre>​String emptyReference = null; // Represents absence of a value </pre><h2>Java Variables</h2>​Variables are named storage locations that hold values which can be changed during program execution. <h3>Variable Declaration and Initialization</h3><pre>// Declaration int age; // Initialization age = 25; // Combined declaration and initialization double salary = 50000.50; </pre><h2>Variable Naming Conventions</h2><ul><li style="background-color: transparent;font-size: 18px">Start with a letter, underscore (_), or dollar sign ($)</li><li style="background-color: transparent;font-size: 18px">Cannot start with a number</li><li style="background-color: transparent;font-size: 18px">Can include letters, numbers, underscores, and dollar signs</li><li style="background-color: transparent;font-size: 18px">Case-sensitive</li><li style="background-color: transparent;font-size: 18px">Cannot use Java reserved keywords</li></ul><pre>// Good variable names int studentCount; String firstName; double hourlyRate; // Poor variable names int a; // Not descriptive String s; // Too short </pre><h2>Variable Types Based on Scope</h2>Instance Variables (Non-Static Fields)<pre>public class Person { String name; // Instance variable int age; // Instance variable } </pre><h3>​​Class Variables (Static Fields)</h3><pre>​public class Constants { static final double PI = 3.14159; // Class variable } </pre><h3>Local Variables</h3><pre>​public void calculateArea() { double radius = 5.0; // Local variable double area = Math.PI * radius * radius; } </pre><h3>Parameters</h3><pre>​public void setName(String newName) { // Parameter this.name = newName; }</pre><h2> </h2><h2>Type Conversion in Java: Changing Data Types</h2>Type conversion is the process of converting a value from one data type to another.<h2>Implicit Type Conversion (Widening)</h2>Java automatically performs widening conversions when there's no risk of data loss:<pre>​​byte smallNumber = 10; int largerNumber = smallNumber; // Implicit conversion from byte to int int intValue = 100; long longValue = intValue; // int to long long longNum = 200; float floatNum = longNum; // long to float float floatVal = 300.5f; double doubleVal = floatVal; // float to double</pre>The widening conversion follows this hierarchy:<pre><code>byte → short → int → long → float → double </code></pre><h2>Explicit Type Conversion (Narrowing) </h2>​When converting from a larger data type to a smaller one, explicit casting is required to acknowledge potential data loss: ​<pre>​​double largeDouble = 100.56; int smallerInt = (int) largeDouble; // Explicit cast, result: 100 (decimal part lost) int largeInt = 200; byte smallByte = (byte) largeInt; // Explicit cast, potential overflow long bigLong = 9876543210L; int smallerInt2 = (int) bigLong; // Explicit cast, potential data loss</pre> <h2> </h2><h2>Type Casting in Java: Reference Type Conversions</h2>​Type casting with objects involves converting between compatible reference types.<h3>​​Upcasting (Widening Reference Conversion)</h3>Converting a subclass reference to a superclass reference:<pre>​​// Assuming Dog extends Animal Dog myDog = new Dog(); Animal myAnimal = myDog; // Upcasting, no explicit cast needed </pre><h3>Downcasting (Narrowing Reference Conversion)</h3>​Converting a superclass reference to a subclass reference:​<pre>​​Animal genericAnimal = new Dog(); Dog specificDog = (Dog) genericAnimal; // Downcasting, explicit cast required // Safety check with instanceof if (genericAnimal instanceof Dog) { Dog safeDog = (Dog) genericAnimal; } </pre><h3>Pattern Matching for instanceof (Java 16+)</h3><pre>​if (genericAnimal instanceof Dog specificDog) { // specificDog is already cast and available here specificDog.bark(); } </pre><h2>​​ </h2><h2>Best Practices for Java Data Types and Variables</h2>Choose appropriate data types for memory efficiency:<pre>​​// Good: Using int for a counter int counter = 0; // Inefficient: Using long when int would sufficelong small Counter = 0L; </pre><div style="background-color: transparent"> </div>Use meaningful variable names for code readability:<pre>​// Good int employeeCount = 42;// Poor int ec = 42; </pre> Initialize variables before using them:<pre>​​int sum; // sum = sum + 10; // Error: variable might not have been initialized int sum = 0; sum = sum + 10; // Correct </pre><div style="background-color: transparent"> </div>Use constants for fixed values:<pre>final double TAX_RATE = 0.08; </pre><div style="background-color: transparent"> </div><div style="background-color: transparent"> </div>Be cautious with type casting to avoid runtime errors:<pre>​​// Check before casting if (obj instanceof String) { String str = (String) obj; } </pre><div style="background-color: transparent"> </div><h2>​​ </h2><h2>Common Pitfalls and How to Avoid Them</h2><h3>Integer Overflow</h3><pre>int maxInt = Integer.MAX_VALUE; int overflow = maxInt + 1; // Overflows to negative value // Solution: Use a larger data type long safeValue = (long) maxInt + 1; </pre><div style="background-color: transparent"> </div><h3>Floating-Point Precision Issues</h3><pre>double a = 0.1; double b = 0.2; System.out.println(a + b == 0.3); // Prints false due to precision issues // Solution: Use BigDecimal for precise calculations BigDecimal x = new BigDecimal("0.1"); BigDecimal y = new BigDecimal("0.2"); System.out.println(x.add(y).equals(new BigDecimal("0.3"))); // true </pre><div style="background-color: transparent"> </div><div style="background-color: transparent"> </div><h3>ClassCastException</h3><pre>Object obj = "Hello"; Integer num = (Integer) obj; // Throws ClassCastException // Solution: Always check with instanceof if (obj instanceof Integer) { Integer num = (Integer) obj; } </pre><h2> </h2><h2>​</h2>​ <h2>​ </h2>

Java Data Types, Literals, Variables, Type Conversion & Casting

<h2>​​Introduction</h2>​In Java programming, primitive data types like <code>int</code>, <code>char</code>, and <code>boolean</code> are fundamental building blocks. However, there are scenarios where we need to treat these primitives as objects—for instance, when working with collections or utilizing object-oriented features. This is where Java wrapper classes come into play, along with the convenient autoboxing and unboxing mechanisms that simplify working with them. <h2>What Are Wrapper Classes in Java?</h2>​Wrapper classes are specialized classes in Java that encapsulate, or "wrap," primitive data types within objects. Each primitive type in Java has a corresponding wrapper class in the <code>java.lang</code> package:<table class="se-table-layout-fixed"><thead><tr><th><div>Primitive Type </div></th><th><div>Wrapper Class </div></th><th><div>Memory Size </div></th></tr></thead><tbody><tr><td><div>byte </div></td><td><div>Byte </div></td><td><div>1 byte</div></td></tr><tr><td><div>short </div></td><td><div>Short </div></td><td><div>2 bytes</div></td></tr><tr><td><div>int </div></td><td><div>Integer</div></td><td><div>4 bytes</div></td></tr><tr><td><div>long </div></td><td><div>Long </div></td><td><div>8 bytes</div></td></tr><tr><td><div>float </div></td><td><div>Float</div></td><td><div>4 bytes</div></td></tr><tr><td><div>double </div></td><td><div>Double </div></td><td><div>8 bytes</div></td></tr><tr><td><div>char</div></td><td><div>Character </div></td><td><div>2 bytes</div></td></tr><tr><td><div>boolean </div></td><td><div>Boolean </div></td><td><div>1 bit</div></td></tr></tbody></table> These wrapper classes provide several advantages:<ul><li style="background-color: transparent;font-size: 18px">They allow primitive types to be used where objects are required</li><li style="background-color: transparent;font-size: 18px">They provide useful methods for conversion and manipulation</li><li style="background-color: transparent;font-size: 18px">They enable primitive values to be stored in collections like ArrayList, HashMap, etc.</li><li style="background-color: transparent;font-size: 18px">They support null values, unlike primitives </li></ul><h2> </h2><h2>Creating Wrapper Objects</h2>​There are multiple ways to create wrapper objects in Java:​<h3>Using Constructors (Deprecated in Java 9+)</h3><pre>Integer intObj = new Integer(42); // Deprecated in Java 9+ Character charObj = new Character('A'); // Deprecated in Java 9+ </pre><div style="background-color: transparent"> </div><div style="background-color: transparent"> </div><h3>Using Static Factory Methods (Preferred)</h3><pre>​Integer intObj = Integer.valueOf(42); Character charObj = Character.valueOf('A'); </pre> <h3>Using Autoboxing (Most Convenient)</h3><pre>Integer intObj = 42; // Autoboxing Character charObj = 'A'; // Autoboxing </pre><h2> </h2><h2>Understanding Autoboxing</h2>Autoboxing is a feature introduced in Java 5 that automatically converts primitive types to their corresponding wrapper objects when needed. This conversion happens implicitly, making code cleaner and more readable.<h3>Examples of Autoboxing</h3><pre>// Without autoboxing (pre-Java 5) ArrayList&lt;Integer&gt; numbers = new ArrayList&lt;Integer&gt;(); numbers.add(Integer.valueOf(10)); // With autoboxing (Java 5+) ArrayList&lt;Integer&gt; numbers = new ArrayList&lt;Integer&gt;(); numbers.add(10); // Automatically converts int to Integer </pre><div style="background-color: transparent"> </div>Autoboxing occurs in various contexts:<pre>​​// Assigning a primitive to a wrapper reference Integer num = 100; // Autoboxing int to Integer // In method parameters public void processValue(Integer value) { /* ... */ } processValue(50); // Autoboxing int to Integer // In expressions involving wrapper objects Integer a = 10; Integer b = 20; Integer sum = a + b; // Unboxing, addition, then autoboxing </pre><div style="background-color: transparent"> </div><h2>Understanding Unboxing</h2>​Unboxing is the reverse process of autoboxing—it automatically converts wrapper objects to their corresponding primitive types when needed.<h3>Examples of Unboxing</h3><pre>// Without unboxing (pre-Java 5) Integer intObj = Integer.valueOf(10); int primitiveInt = intObj.intValue(); // With unboxing (Java 5+) Integer intObj = Integer.valueOf(10); int primitiveInt = intObj; // Automatically converts Integer to int </pre><div style="background-color: transparent"> </div>Unboxing occurs in various contexts:<pre>​​// Assigning a wrapper reference to a primitive Integer wrapperVal = Integer.valueOf(100); int primitiveVal = wrapperVal; // Unboxing // In arithmetic operations Integer intObj = 10; int result = intObj * 2; // Unboxing for multiplication // In conditional statements Boolean flag = Boolean.TRUE; if (flag) { // Unboxing Boolean to boolean System.out.println("Flag is true"); } </pre><div style="background-color: transparent"> </div><h2>Autoboxing and Unboxing in Practice</h2><h3>In Collections</h3>​One of the most common uses of wrapper classes is with Java collections, which can only store objects, not primitives: <pre>​// ArrayList of integers ArrayList&lt;Integer&gt; numbers = new ArrayList&lt;&gt;(); numbers.add(10); // Autoboxing numbers.add(20); // Autoboxing numbers.add(30); // Autoboxing // Accessing elements with unboxing int firstNumber = numbers.get(0); // Unboxing </pre><div style="background-color: transparent"> </div><h3>In Method Parameters and Return Types</h3><pre>​public Integer multiply(Integer a, Integer b) { return a * b; // Unboxing, multiplication, autoboxing } // Usage int result = multiply(5, 10); // Autoboxing for parameters, unboxing for result </pre><div style="background-color: transparent"> </div><h3>In Generics </h3><pre>public class Box&lt;T&gt; { private T value; public void setValue(T value) { this.value = value; } public T getValue() { return value; } } // Usage with primitive through autoboxing Box&lt;Integer&gt; intBox = new Box&lt;&gt;(); intBox.setValue(42); // Autoboxing int value = intBox.getValue(); // Unboxing </pre><div style="background-color: transparent"> </div><h2>Utility Methods in Wrapper Classes</h2>​Wrapper classes provide numerous utility methods that make working with primitive types more convenient: <h3>​Conversion Methods</h3><pre>// String to primitive int parsedInt = Integer.parseInt("100"); double parsedDouble = Double.parseDouble("3.14"); // Primitive to String String intStr = Integer.toString(100); String doubleStr = Double.toString(3.14); // Between number types int intValue = Integer.valueOf("100").intValue(); double doubleValue = Integer.valueOf("100").doubleValue(); </pre> <h3>Value Range Methods</h3><pre>// Min and max values System.out.println("Integer MAX: " + Integer.MAX_VALUE); System.out.println("Integer MIN: " + Integer.MIN_VALUE); System.out.println("Double MAX: " + Double.MAX_VALUE); </pre><div style="background-color: transparent"> </div><h3>Comparison Methods</h3><pre>​// Compare values System.out.println(Integer.compare(10, 20)); // Returns -1 System.out.println(Double.compare(3.14, 2.71)); // Returns 1 </pre><div style="background-color: transparent"> </div><h3>Type Checking</h3><pre>​// Check if a string is a valid number boolean isInt = true; try { Integer.parseInt("123"); } catch (NumberFormatException e) { isInt = false; } </pre><div style="background-color: transparent"> </div><h2>Performance Considerations</h2>​While autoboxing and unboxing provide convenience, they can impact performance if used excessively, especially in performance-critical code: <h3>Memory Overhead</h3>Wrapper objects consume more memory than primitives:<pre>​​// Approximately 4 bytes int primitiveInt = 42; // Approximately 16 bytes (object header) + 4 bytes (int value) Integer wrapperInt = 42; </pre><div style="background-color: transparent"> </div><h3>Processing Overhead</h3><pre>// Performance test long start = System.nanoTime(); int sum = 0; for (int i = 0; i &lt; 10000000; i++) { sum += i; // Using primitives } long end = System.nanoTime(); System.out.println("Primitive time: " + (end - start) + " ns"); start = System.nanoTime(); Integer wrapperSum = 0; for (Integer i = 0; i &lt; 10000000; i++) { wrapperSum += i; // Using wrappers with autoboxing/unboxing } end = System.nanoTime(); System.out.println("Wrapper time: " + (end - start) + " ns"); // Wrapper version typically runs significantly slower </pre> <h3>Integer Caching</h3>For performance optimization, Java caches frequently used Integer objects:<pre>​​Integer a = 127; Integer b = 127; System.out.println(a == b); // true (cached)Integer c = 128; Integer d = 128; System.out.println(c == d); // false (not cached) </pre> <h2>Common Pitfalls and Best Practices</h2><h3>NullPointerException Risk</h3>Unboxing a null wrapper reference throws a NullPointerException:<pre>​​Integer nullInteger = null; int value = nullInteger; // Throws NullPointerException </pre> Always check for null before unboxing:<pre>​​Integer nullableInteger = getIntegerFromSomewhere(); int value = (nullableInteger != null) ? nullableInteger : 0; </pre><div style="background-color: transparent"> </div><h3>Equality Comparison</h3>Be careful when comparing wrapper objects:<pre>​​Integer a = 128; Integer b = 128; System.out.println(a == b); // false (compares object references) System.out.println(a.equals(b)); // true (compares values) </pre><blockquote><div style="background-color: transparent">​ </div>For value comparison, use:<ul class=""><li style="background-color: transparent;font-size: 18px">The <code>equals()</code> method for wrapper objects</li><li style="background-color: transparent">The <code>==</code> operator for primitives</li></ul></blockquote><div style="background-color: transparent"> </div><div style="background-color: transparent"> </div><h3>Performance Optimization</h3>For performance-critical code:<pre>​​// Prefer primitives in loops for (int i = 0; i &lt; 1000000; i++) { // Use primitive operations } // Avoid unnecessary boxing/unboxingint sum = 0; for (Integer value : integerList) { sum += value.intValue(); // Explicit unboxing to avoid repeated auto-unboxing } </pre><div style="background-color: transparent"> </div><h2>Real-World Applications</h2><h3>Database Interaction</h3>​Wrapper classes are essential when working with databases, as they can represent SQL NULL values: <pre>​// JDBC result set handling Integer id = resultSet.getInt("id"); if (resultSet.wasNull()) { id = null; // Handle NULL value from database } </pre> <h3>JSON Processing</h3>When working with JSON libraries like Jackson or Gson:<pre>public class User { private Integer id; // Can be null in JSON private String name; // Getters and setters } </pre> <h3>Functional Programming</h3><h3>In Java's functional programming features:</h3><pre>​// Stream operations with wrapper classes List&lt;Integer&gt; numbers = Arrays.asList(1, 2, 3, 4, 5); int sum = numbers.stream() .filter(n -&gt; n % 2 == 0) // Unboxing for modulo .mapToInt(Integer::intValue) // Explicit unboxing .sum();</pre>​​​​​

Wrapper Classes: Understanding Autoboxing and Unboxing

​Java is a versatile and widely-used programming language that provides a rich set of operators to perform various operations on variables and values. Operators in Java are special symbols or keywords that perform specific operations, such as arithmetic, logical, relational, or bitwise operations. Assignments, on the other hand, are used to assign values to variables. Together, operators and assignments form the foundation of Java's ability to manipulate data and control program flow. <h2>Types of Operators in Java </h2>​Java operators can be broadly categorized into the following types: <ul><li style="background-color: transparent;font-size: 18px">Arithmetic Operators</li><li style="background-color: transparent;font-size: 18px">Relational (Comparison) Operators</li><li style="background-color: transparent;font-size: 18px">Logical Operators</li><li style="background-color: transparent;font-size: 18px">Bitwise Operators</li><li style="background-color: transparent;font-size: 18px">Assignment Operators</li><li style="background-color: transparent;font-size: 18px">Unary Operators</li><li style="background-color: transparent;font-size: 18px">Ternary Operator</li><li style="background-color: transparent;font-size: 18px">Instanceof Operator</li><li style="background-color: transparent;font-size: 18px">Shift Operators</li></ul><h2> </h2><h3>1. Arithmetic Operators </h3>​Arithmetic operators are used to perform basic mathematical operations. These include addition, subtraction, multiplication, division, and modulus. <table class="se-table-layout-fixed"><thead><tr><th><div>Operator</div></th><th><div>Description </div></th><th><div>Example </div></th></tr></thead><tbody><tr><td><div>+</div></td><td><div>Addition </div></td><td><div>a + b </div></td></tr><tr><td><div>-</div></td><td><div>Subtraction </div></td><td><div>a - b</div></td></tr><tr><td><div>*</div></td><td><div>Multiplication</div></td><td><div>a * b</div></td></tr><tr><td><div>/</div></td><td><div>Division </div></td><td><div>a / b</div></td></tr><tr><td><div>%</div></td><td><div>Modulus (remainder)</div></td><td><div>a % b</div></td></tr></tbody></table><h3>Example:</h3><pre>​int a = 10, b = 3; System.out.println(a + b); // Output: 13 System.out.println(a % b); // Output: 1 </pre><h2>2. Relational (Comparison) Operators </h2>Relational operators are used to compare two values. They return a boolean result (<code>true</code> or <code>false</code>).​<table class="se-table-layout-fixed"><thead><tr><th><div>Operator</div></th><th><div>Description </div></th><th><div>Example </div></th></tr></thead><tbody><tr><td><div>==</div></td><td><div>Equal to </div></td><td><div>a&nbsp; ==&nbsp; b </div></td></tr><tr><td><div>!=</div></td><td><div>Not Equal to </div></td><td><div>a !=&nbsp; b</div></td></tr><tr><td><div>&gt;</div></td><td><div>Greater than</div></td><td><div>a &gt; b</div></td></tr><tr><td><div>&lt;</div></td><td><div>Less than </div></td><td><div>a &lt;&nbsp; b</div></td></tr><tr><td><div>&gt;= </div></td><td><div>Greater than or equal to </div></td><td><div>a &gt;= b </div></td></tr><tr><td><div>&lt;=</div></td><td><div>Less than or equal to </div></td><td><div>a &lt;= b </div></td></tr></tbody></table><h3>Example: </h3><pre>int a = 5, b = 10; System.out.println(a &gt; b); // Output: false System.out.println(a != b); // Output: true </pre><h2>3. Logical Operators </h2>​Logical operators are used to combine multiple boolean expressions or values. <table class="se-table-layout-fixed"><thead><tr><th><div>Operator</div></th><th><div>Description</div></th><th><div>Example</div></th></tr></thead><tbody><tr><td><div>&amp;&amp;</div></td><td><div>Logical AND </div></td><td><div>a &amp;&amp; b</div></td></tr><tr><td><div>||</div></td><td><div>Logical OR </div></td><td><div>a || b</div></td></tr><tr><td><div>!</div></td><td><div>Logical NOT</div></td><td><div>a != b</div></td></tr></tbody></table> <h2>4. Bitwise Operators</h2>Bitwise operators operate on bits and perform bit-level operations.<table class="se-table-layout-fixed"><thead><tr><th><div>Operator</div></th><th><div>Description</div></th><th><div>Example</div></th></tr></thead><tbody><tr><td><div>&amp;</div></td><td><div>Bitwise AND </div></td><td><div>a &amp; b</div></td></tr><tr><td><div>|</div></td><td><div>Bitwise OR </div></td><td><div>a | b</div></td></tr><tr><td><div>^</div></td><td><div>Bitwise XOR</div></td><td><div>a ^ b</div></td></tr><tr><td><div>~</div></td><td><div>Bitwise Complement </div></td><td><div>~a</div></td></tr></tbody></table><h3>Example: </h3><pre>int a = 5, b = 3; // Binary: a = 0101, b = 0011 System.out.println(a &amp; b); // Output: 1 (0001) System.out.println(a | b); // Output: 7 (0111) </pre><h2>5. Assignment Operators </h2>​​Assignment operators are used to assign values to variables. The most common assignment operator is <code>=</code>. Other assignment operators combine arithmetic or bitwise operations with assignment. <table class="se-table-layout-fixed"><thead><tr><th><div>Operator</div></th><th><div>Description</div></th><th><div>Example</div></th></tr></thead><tbody><tr><td><div>=</div></td><td><div>Assign </div></td><td><div>a =&nbsp; b</div></td></tr><tr><td><div>+=</div></td><td><div>Add and assign </div></td><td><div>a += b</div></td></tr><tr><td><div>-=</div></td><td><div>Subtract and assign</div></td><td><div>a -= b</div></td></tr><tr><td><div>*=</div></td><td><div>Multiply and assign </div></td><td><div>a *= b</div></td></tr><tr><td><div>/=</div></td><td><div>Divide and assign </div></td><td><div>a /= b</div></td></tr><tr><td><div>%=</div></td><td><div>Modulus and assign </div></td><td><div>a %= b</div></td></tr></tbody></table><h3>Example: </h3><pre>int a = 10; a += 5; // Equivalent to a = a + 5 System.out.println(a); // Output: 15 </pre><h2>6. Unary Operators </h2>​Unary operators operate on a single operand. They include increment, decrement, and negation operators. <table class="se-table-layout-fixed"><thead><tr><th><div>Operator</div></th><th><div>Description</div></th><th><div>Example</div></th></tr></thead><tbody><tr><td><div>+</div></td><td><div>Unary plus </div></td><td><div>+a</div></td></tr><tr><td><div>-</div></td><td><div>Unary minus </div></td><td><div>-a</div></td></tr><tr><td><div>++</div></td><td><div>Increment</div></td><td><div>++a or a++</div></td></tr><tr><td><div>--</div></td><td><div>Decrement </div></td><td><div>--a or a--</div></td></tr><tr><td><div>!</div></td><td><div>Logical NOT </div></td><td><div>!a</div></td></tr></tbody></table><h3>Example:</h3><pre>​int a = 5; System.out.println(++a); // Pre-increment: Output 6 System.out.println(a--); // Post-decrement: Output 6, then a becomes 5</pre><h2>7. Ternary Operator​</h2>​The ternary operator is a shorthand for an <code>if-else</code> statement. It takes three operands. <pre>​​condition ? value_if_true : value_if_false;</pre><h2>Example:</h2><pre>int a = 10, b = 20; int max = (a &gt; b) ? a : b; System.out.println(max); // Output: 20 </pre><h2>8. Instanceof Operator </h2>​The <code>instanceof</code> operator is used to test whether an object is an instance of a specific class or subclass. <h3>Example:</h3><pre>​String str = "Hello"; System.out.println(str instanceof String); // Output: true </pre><h2>9. Shift Operators </h2>​Shift operators are used to shift bits to the left or right. <table class="se-table-layout-fixed"><thead><tr><th><div>Operator</div></th><th><div>Description</div></th><th><div>Example</div></th></tr></thead><tbody><tr><td><div>&lt;&lt;</div></td><td><div>Left shift </div></td><td><div>a &lt;&lt; 2</div></td></tr><tr><td><div>&gt;&gt;</div></td><td><div>Right Shift </div></td><td><div>a &gt;&gt; 2</div></td></tr><tr><td><div>&gt;&gt;&gt;</div></td><td><div>Unsigned right shift</div></td><td><div>a &gt;&gt;&gt; 2</div></td></tr></tbody></table><h3 style="line-height: 2em">​Example:</h3><pre>​int a = 8; // Binary: 1000 System.out.println(a &lt;&lt; 1); // Output: 16 (Binary: 10000) </pre><h2>Precedence and Associativity of Operators </h2>​Operator precedence determines the order in which operators are evaluated in an expression. For example, multiplication (<code>*</code>) has higher precedence than addition (<code>+</code>). <h3>Example:</h3><pre>​int result = 10 + 5 * 2; // Multiplication is evaluated first System.out.println(result); // Output: 20 </pre><div style="background-color: transparent">​Associativity determines the direction of evaluation when operators have the same precedence. Most operators in Java are left-associative, meaning they are evaluated from left to right. </div><div style="background-color: transparent"> </div><h2>Assignments in Java </h2>​Assignments in Java involve assigning values to variables using the assignment operator (<code>=</code>). Java supports both simple and compound assignments.<h3>​Simple Assignment</h3>​A simple assignment assigns a value to a variable. <pre>​​int a = 10; </pre><h3>Compound Assignment</h3>Compound assignments combine an operation with assignment.<pre> ​​int a = 10; a += 5; // Equivalent to a = a + 5 System.out.println(a); // Output: 15 </pre><blockquote>​Java operators and assignments are essential tools for performing operations and managing data in a program </blockquote>

Java Operators and Assignments

​Access modifiers in Java are keywords that define the visibility and accessibility of classes, methods, variables, and constructors. They play a crucial role in encapsulation, one of the core principles of object-oriented programming (OOP). By using access modifiers, developers can control how different parts of a program interact with each other, ensuring better security, modularity, and maintainability. <h2>Types of Access Modifiers in Java </h2>​Java provides four types of access modifiers:<ul><li style="background-color: transparent;font-size: 18px">Public</li><li style="background-color: transparent;font-size: 18px">Private</li><li style="background-color: transparent;font-size: 18px">Protected</li><li style="background-color: transparent;font-size: 18px">Default (Package-Private)</li></ul>Each access modifier determines the scope of accessibility for a class, method, or variable. The table below summarizes their visibility: <table class="se-table-layout-auto"><thead><tr><th><div>Modifier</div></th><th><div>Same Class </div></th><th><div>Same Package </div></th><th><div>Subclass (Different Package) </div></th><th><div>Other Classes </div></th></tr></thead><tbody><tr><td><div>public</div></td><td><div>Yes</div></td><td><div>Yes </div></td><td><div>Yes </div></td><td><div>Yes </div></td></tr><tr><td><div>protected</div></td><td><div>Yes </div></td><td><div>Yes </div></td><td><div>Yes </div></td><td><div>No</div></td></tr><tr><td><div>default</div></td><td><div>Yes </div></td><td><div>Yes </div></td><td><div>No</div></td><td><div>No</div></td></tr><tr><td><div>private</div></td><td><div>Yes </div></td><td><div>No</div></td><td><div>No</div></td><td><div>No</div></td></tr></tbody></table> <h3>1. Public Access Modifier</h3>​The <code>public</code> modifier makes a class, method, or variable accessible from anywhere in the program. It has the widest scope of all access modifiers.​Key Points:<ul class=""><li style="background-color: transparent">A <code>public</code> class or member can be accessed from any other class, regardless of the package.</li><li style="background-color: transparent;font-size: 18px">It is commonly used for methods or variables that need to be universally accessible.</li></ul><h4>Example:</h4><pre>​// File: Main.java package com.example; public class Main { public String message = "Hello, World!"; public void displayMessage() { System.out.println(message); } } // File: Test.java package com.test; import com.example.Main; public class Test { public static void main(String[] args) { Main main = new Main(); main.displayMessage(); // Accessible because it's public } } </pre><h3>2. Private Access Modifier </h3>​The <code>private</code> modifier restricts access to the class in which it is declared. It is the most restrictive access level. <h4>Key Points:</h4><ul class=""><li style="background-color: transparent">A <code>private</code> member is accessible only within the same class.</li><li style="background-color: transparent;font-size: 18px">It is commonly used to implement encapsulation by hiding internal details of a class.</li><li style="background-color: transparent;font-size: 18px">Getter and setter methods are often used to access private variables.</li></ul>Example:<pre>public class Account { private double balance; public double getBalance() { return balance; // Getter method } public void setBalance(double balance) { this.balance = balance; // Setter method } } public class Main { public static void main(String[] args) { Account account = new Account(); account.setBalance(1000.50); // Accessing private variable via setter System.out.println("Balance: " + account.getBalance()); // Accessing via getter } } </pre><h3>3. Protected Access Modifier</h3>The <code>protected</code> modifier allows access within the same package and to subclasses in other packages. It is less restrictive than <code>private</code> but more restrictive than <code>public</code>.​ <h4>Key Points:</h4><ul class=""><li style="background-color: transparent">A <code>protected</code> member is accessible in the same package and in subclasses (even if they are in different packages).</li><li style="background-color: transparent;font-size: 18px">It is commonly used in inheritance to allow subclasses to access parent class members.</li></ul>​ <h4>Example:&nbsp;</h4><pre>// File: Parent.java package com.example; public class Parent { protected String name = "Parent"; protected void displayName() { System.out.println("Name: " + name); } } // File: Child.java package com.test; import com.example.Parent; public class Child extends Parent { public void show() { displayName(); // Accessible because it's protected } } // File: Main.java package com.test; public class Main { public static void main(String[] args) { Child child = new Child(); child.show(); // Accessing protected method via subclass } } </pre><h3>4. Default (Package-Private) Access Modifier</h3>​If no access modifier is specified, the member is considered to have default (or package-private) access. This means it is accessible only within the same package.<h4>Key Points:</h4><ul class=""><li style="background-color: transparent;font-size: 18px">A default member is not accessible outside its package.</li><li style="background-color: transparent;font-size: 18px">It is commonly used for internal implementation details that should not be exposed to other packages.</li></ul> <h4>Example:</h4><pre>​// File: Example.java package com.example; class Example { void display() { System.out.println("Default access modifier"); } } // File: Main.java package com.example; public class Main { public static void main(String[] args) { Example example = new Example(); example.display(); // Accessible because it's in the same package } } // File: Test.java package com.test; import com.example.Example; public class Test { public static void main(String[] args) { // Example example = new Example(); // Error: Not accessible outside the package } } </pre><h2>Access Modifiers for Classes </h2>​In Java, access modifiers can also be applied to classes. However, only two modifiers are allowed for top-level classes: <ul><li style="background-color: transparent;font-size: 18px">Public: The class is accessible from any other class.</li><li style="background-color: transparent;font-size: 18px">Default (Package-Private): The class is accessible only within the same package.</li></ul><div style="background-color: transparent; font-size: 18px"> </div><div style="background-color: transparent; font-size: 18px"> </div><h4>Example:</h4><pre>​// Public class public class PublicClass { // Accessible from anywhere } // Default class class DefaultClass { // Accessible only within the same package } </pre><h2> </h2><h2>Access Modifiers and Inheritance </h2>​When a subclass inherits a class, the access modifiers of the parent class members determine their accessibility in the subclass: <ul><li style="background-color: transparent"><code>public</code> members are always accessible.</li><li style="background-color: transparent;font-size: 18px"><code>protected</code> members are accessible in the subclass, even if it is in a different package.</li><li style="background-color: transparent;font-size: 18px"><code>default</code> members are not accessible in subclasses outside the package.</li><li style="background-color: transparent"><code>private</code> members are never accessible in the subclass.</li></ul><div style="background-color: transparent"> </div><div style="background-color: transparent">Example:</div><div style="background-color: transparent"> </div><pre>package com.example; public class Parent { public String publicField = "Public"; protected String protectedField = "Protected"; String defaultField = "Default"; private String privateField = "Private"; } package com.test; import com.example.Parent; public class Child extends Parent { public void displayFields() { System.out.println(publicField); // Accessible System.out.println(protectedField); // Accessible &nbsp;&nbsp;&nbsp;&nbsp;// System.out.println(defaultField); // Error: Not accessible &nbsp;&nbsp;&nbsp;&nbsp;// System.out.println(privateField); // Error: Not accessible } } </pre><div style="background-color: transparent"> </div><h2>Best Practices for Using Access Modifiers</h2><blockquote><ol><li style="background-color: transparent">Use <code>private</code> for sensitive data: Always declare variables as <code>private</code> and provide controlled access through getter and setter methods.</li><li style="background-color: transparent;font-size: 18px">Minimize <code>public</code> members: Avoid exposing too many <code>public</code> members to maintain encapsulation.</li><li style="background-color: transparent;font-size: 18px">Use <code>protected</code> for inheritance: Use <code>protected</code> for members that should be accessible to subclasses but hidden from other classes.</li><li style="background-color: transparent;font-size: 18px">Default for internal use: Use default access for members that are only relevant within the same package.</li></ol></blockquote>

Access Modifiers

​In Java, a package is a namespace that organizes classes and interfaces into a structured hierarchy. Packages are used to group related classes and interfaces, making it easier to manage and maintain large codebases. They also help avoid naming conflicts by providing a unique namespace for each class. <h2>What is a Package in Java?</h2>​A package in Java is essentially a directory that contains related classes, interfaces, and sub-packages. It acts as a container for organizing code logically. For example, the <code>java.util</code> package contains utility classes like <code>ArrayList</code>, <code>HashMap</code>, and <code>Date</code>. <h3>Key Features of Packages:</h3><ul><li style="background-color: transparent;font-size: 18px">Namespace Management: Packages prevent naming conflicts by organizing classes into separate namespaces.</li><li style="background-color: transparent;font-size: 18px">Access Control: Packages provide access control through access modifiers like <code>public</code>, <code>protected</code>, and default (package-private).</li><li style="background-color: transparent;font-size: 18px">Code Reusability: Classes in a package can be reused in other programs.</li><li style="background-color: transparent;font-size: 18px">Logical Organization: Packages make it easier to locate and use classes in large projects.</li></ul><h3>Types of Packages in Java </h3>​Java packages are categorized into two types:<ul><li style="background-color: transparent;font-size: 16px">Built-in Packages</li><li style="background-color: transparent;font-size: 16px">User-defined Packages</li></ul><h3>1. Built-in Packages </h3>​Java provides a rich set of built-in packages that contain pre-defined classes and interfaces for various functionalities. Some commonly used built-in packages include: <ul><li style="background-color: transparent"><code>java.lang</code>: Contains fundamental classes like <code>String</code>, <code>Math</code>, <code>Object</code>, and <code>System</code>. This package is automatically imported.</li><li style="background-color: transparent;font-size: 18px"><code>java.util</code>: Provides utility classes like <code>ArrayList</code>, <code>HashMap</code>, <code>Collections</code>, and <code>Date</code>.</li><li style="background-color: transparent;font-size: 18px"><code>java.io</code>: Contains classes for input and output operations, such as <code>File</code>, <code>BufferedReader</code>, and <code>PrintWriter</code>.</li><li style="background-color: transparent;font-size: 18px"><code>java.net</code>: Provides classes for networking, such as <code>Socket</code>, <code>URL</code>, and <code>HttpURLConnection</code>.</li><li style="background-color: transparent"><code>java.sql</code>: Contains classes for database connectivity, such as <code>Connection</code>, <code>Statement</code>, and <code>ResultSet</code>.</li></ul><h4>Example:</h4><pre>import java.util.ArrayList; public class Main { public static void main(String[] args) { ArrayList&lt;String&gt; list = new ArrayList&lt;&gt;(); list.add("Java"); list.add("Packages"); System.out.println(list); } } </pre><h3>2. User-defined Packages </h3>User-defined packages are created by developers to organize their own classes and interfaces. These packages help in structuring code and avoiding naming conflicts in large projects.​<h4>Steps to Create a User-defined Package: </h4><ul><li style="background-color: transparent">Declare the package at the top of the Java file using the <code>package</code> keyword.</li><li style="background-color: transparent;font-size: 18px">Save the file in a directory that matches the package name.</li><li style="background-color: transparent;font-size: 18px">Compile the file using the <code>javac</code> command.</li><li style="background-color: transparent">Use the <code>import</code> statement to access the package in other classes.</li></ul><h3>Example:</h3><h4>Creating Package:</h4><pre>​// File: MyPackage/Hello.java package MyPackage; public class Hello { public void displayMessage() { System.out.println("Hello from MyPackage!"); } } </pre><h4>Compile the Package </h4><pre>bash javac -d . Hello.java </pre><h4>Use The Package</h4><pre>// File: Main.java import MyPackage.Hello; public class Main { public static void main(String[] args) { Hello hello = new Hello(); hello.displayMessage(); } } </pre><h4>Compile and Run </h4><pre>​​javac Main.java java Main </pre>​<h3>Importing Packages </h3>​To use classes from a package, you need to import them using the <code>import</code> statement. There are two ways to import packages:<h4>Import a Specific Class</h4><pre>​import java.util.ArrayList; </pre><h4>​Import All Classes in a Package</h4><pre>import java.util.*; </pre><blockquote>​Note: Importing all classes (<code>*</code>) can lead to unnecessary memory usage and potential naming conflicts. It is better to import specific classes when possible.​ </blockquote> <h2>Advantages of Using Packages </h2><ul><li style="background-color: transparent;font-size: 18px">Avoids Naming Conflicts: Packages provide a unique namespace for classes, preventing conflicts between classes with the same name.</li><li style="background-color: transparent;font-size: 18px">Code Organization: Packages help organize related classes and interfaces, making the codebase easier to navigate and maintain.</li><li style="background-color: transparent;font-size: 18px">Reusability: Classes in a package can be reused across multiple projects.</li><li style="background-color: transparent;font-size: 18px">Access Control: Packages allow developers to control the visibility of classes and members using access modifiers.</li><li style="background-color: transparent;font-size: 18px">Modularity: Packages promote modular programming by grouping related functionality together.</li></ul>

Java Packages

​Inheritance is one of the core principles of object-oriented programming (OOP) in Java. It allows a class (called the child or subclass) to inherit properties and behaviors (fields and methods) from another class (called the parent or superclass). Inheritance promotes code reuse, modularity, and extensibility, making it easier to build and maintain complex applications. <h2>What is Inheritance? </h2>​Inheritance is a mechanism in Java where one class acquires the properties (fields) and behaviors (methods) of another class. The class that inherits is called the subclass (child class), and the class being inherited from is called the superclass (parent class).​<h3>Key Features of Inheritance:</h3><ul><li style="background-color: transparent;font-size: 18px">Code Reusability: Common functionality can be defined in the parent class and reused in child classes.</li><li style="background-color: transparent;font-size: 18px">Method Overriding: Subclasses can provide specific implementations for methods defined in the parent class.</li><li style="background-color: transparent;font-size: 18px">IS-A Relationship: Inheritance represents an "is-a" relationship. For example, a Dog "is-a" type of Animal.</li></ul><h3> </h3><h3>Syntax of Inheritance</h3>Inheritance in Java is implemented using the <code>extends</code> keyword.<pre>​​class ParentClass { // Fields and methods } class ChildClass extends ParentClass { // Additional fields and methods } </pre><h3>Example</h3><pre>​class Animal { void eat() { System.out.println("This animal eats food."); } } class Dog extends Animal { void bark() { System.out.println("The dog barks."); } } public class Main { public static void main(String[] args) { Dog dog = new Dog(); dog.eat(); // Inherited from Animal dog.bark(); // Defined in Dog } } </pre><h2> </h2><h2>Types of Inheritance in Java</h2>​Java supports the following types of inheritance:<ul><li style="background-color: transparent;font-size: 18px">Single Inheritance</li><li style="background-color: transparent;font-size: 18px">Multilevel Inheritance</li><li style="background-color: transparent;font-size: 18px">Hierarchical Inheritance</li></ul> <h3>1. Single Inheritance</h3>In single inheritance, a subclass inherits from a single parent class.<pre>​​class Vehicle { void start() { System.out.println("Vehicle is starting."); }} class Car extends Vehicle { void drive() { System.out.println("Car is driving."); }} public class Main { public static void main(String[] args) { Car car = new Car(); car.start(); // Inherited from Vehicle car.drive(); // Defined in Car }} </pre><h2>2. Multilevel Inheritance </h2>​In multilevel inheritance, a class inherits from a class that is already a subclass of another class. <pre>​​class Animal { void eat() { System.out.println("This animal eats food."); } } class Mammal extends Animal { void walk() { System.out.println("This mammal walks."); }} class Dog extends Mammal { void bark() { System.out.println("The dog barks."); } } public class Main { public static void main(String[] args) { Dog dog = new Dog(); dog.eat(); // Inherited from Animal dog.walk(); // Inherited from Mammal dog.bark(); // Defined in Dog } } </pre><h3>3. Hierarchical Inheritance </h3>​In hierarchical inheritance, multiple subclasses inherit from a single parent class. <pre>​class Animal { void eat() { System.out.println("This animal eats food."); } } class Dog extends Animal { void bark() { System.out.println("The dog barks."); } } class Cat extends Animal { void meow() { System.out.println("The cat meows."); } } public class Main { public static void main(String[] args) { Dog dog = new Dog(); dog.eat(); // Inherited from Animal dog.bark(); // Defined in Dog Cat cat = new Cat(); cat.eat(); // Inherited from Animal cat.meow(); // Defined in Cat } } </pre><h2> </h2><h2>Why Java Does Not Support Multiple Inheritance? </h2>​Java does not support multiple inheritance with classes to avoid ambiguity caused by the Diamond Problem. The diamond problem occurs when a class inherits from two classes that have methods with the same name, leading to confusion about which method to execute.Instead, Java provides interfaces to achieve multiple inheritance-like behavior. A class can implement multiple interfaces.<pre>​​interface A { void methodA(); } interface B { void methodB(); } class C implements A, B { public void methodA() { System.out.println("Method A"); } public void methodB() { System.out.println("Method B"); } } public class Main { public static void main(String[] args) { C obj = new C(); obj.methodA(); obj.methodB(); } } </pre><h2> </h2><h2>Method Overriding in Inheritance </h2>​Method overriding allows a subclass to provide a specific implementation of a method that is already defined in the parent class. The overridden method in the subclass must have the same name, return type, and parameters as the method in the parent class. <pre>​​class Animal { void sound() { System.out.println("This animal makes a sound."); } } class Dog extends Animal { @Override void sound() { System.out.println("The dog barks."); } } public class Main { public static void main(String[] args) { Animal animal = new Dog(); animal.sound(); // Output: The dog barks. } } </pre><h2> </h2><h2>The <code>super</code> Keyword​</h2>The <code>super</code> keyword is used in inheritance to refer to the parent class. It can be used to:<ul><li style="background-color: transparent;font-size: 18px">Access parent class methods or variables.</li><li style="background-color: transparent;font-size: 18px">Call the parent class constructor.</li></ul><h4>Example: Accessing Parent Class Methods </h4><pre>​class Animal { void sound() { System.out.println("This animal makes a sound."); } } class Dog extends Animal { void sound() { super.sound(); // Call parent class method System.out.println("The dog barks."); } } public class Main { public static void main(String[] args) { Dog dog = new Dog(); dog.sound(); } } </pre><h3>Example: Calling Parent Class Constructor </h3><pre>​class Animal { Animal() { System.out.println("Animal constructor called."); } } class Dog extends Animal { Dog() { super(); // Call parent class constructor System.out.println("Dog constructor called."); } } public class Main { public static void main(String[] args) { Dog dog = new Dog(); } } </pre><h3> </h3><h2>Advantages of Inheritance </h2><ul><li style="background-color: transparent;font-size: 18px">Code Reusability: Common functionality can be written once in the parent class and reused in child classes.</li><li style="background-color: transparent;font-size: 18px">Extensibility: New functionality can be added to existing classes without modifying them.</li><li style="background-color: transparent;font-size: 18px">Polymorphism: Inheritance enables polymorphism, allowing a subclass to override methods and provide specific behavior.</li><li style="background-color: transparent;font-size: 18px">Improved Code Organization: Related classes can be grouped together in a hierarchy, making the codebase easier to understand and maintain.</li></ul> <h2>Limitations of Inheritance </h2><ul><li style="background-color: transparent;font-size: 18px">Tight Coupling: Subclasses are tightly coupled to their parent classes, making changes in the parent class potentially affect all subclasses.</li><li style="background-color: transparent;font-size: 18px">Increased Complexity: Overusing inheritance can lead to complex and hard-to-maintain hierarchies.</li><li style="background-color: transparent;font-size: 18px">Not Always Suitable: Inheritance should only be used when there is a clear "is-a" relationship. Otherwise, composition or interfaces may be more appropriate.</li></ul>

Inheritance

​Abstraction is one of the key principles of Object-Oriented Programming (OOP) in Java. It is the process of hiding implementation details and showing only the essential features of an object. Abstraction allows developers to focus on what an object does rather than how it does it. This makes the code more modular, easier to maintain, and less prone to errors.In Java, abstraction is achieved using abstract classes and interfaces. Both provide a way to define methods that must be implemented by subclasses or implementing classes, without specifying the exact implementation. <h2>Abstract Classes </h2>​An abstract class in Java is a class that cannot be instantiated. It can contain both abstract methods (methods without a body) and concrete methods (methods with a body). Abstract classes are used when you want to provide a common base for subclasses while enforcing certain methods to be implemented by them. <h3>Syntax:</h3><pre>​abstract class Animal { // Abstract method (no body) abstract void makeSound(); // Concrete method (with body) void eat() { System.out.println("This animal eats food."); } } </pre> <h3 style="line-height: 1.2">Example:</h3><pre>​abstract class Animal { abstract void makeSound(); // Abstract method void sleep() { // Concrete method System.out.println("This animal sleeps."); } } class Dog extends Animal { @Override void makeSound() { System.out.println("The dog barks."); } } public class Main { public static void main(String[] args) { Animal myDog = new Dog(); myDog.makeSound(); // Output: The dog barks. myDog.sleep(); // Output: This animal sleeps. } } </pre>​In this example, the <code>Animal</code> class is abstract and defines an abstract method <code>makeSound()</code>. The <code>Dog</code> class extends <code>Animal</code> and provides the implementation for <code>makeSound()</code>. <h2>Interfaces </h2>​An interface in Java is a blueprint of a class that contains only abstract methods (prior to Java 8). Starting from Java 8, interfaces can also include default methods (methods with a body) and static methods. Interfaces are used to achieve 100% abstraction and allow multiple inheritance, as a class can implement multiple interfaces. <h3>Syntax:</h3><pre>interface Animal { void makeSound(); // Abstract method } </pre><div style="background-color: transparent"> </div><h3>Example:</h3><pre>interface Animal { void makeSound(); // Abstract method } class Cat implements Animal { @Override public void makeSound() { System.out.println("The cat meows."); } } public class Main { public static void main(String[] args) { Animal myCat = new Cat(); myCat.makeSound(); // Output: The cat meows. } } </pre><div style="background-color: transparent">In this example, the <code>Animal</code> interface defines the <code>makeSound()</code> method, and the <code>Cat</code> class implements the interface by providing the method's implementation.</div><div style="background-color: transparent">​ </div><h3>Abstract Classes vs Interfaces </h3><table class="se-table-layout-fixed"><thead><tr><th><div>Feature </div></th><th><div>Abstract Class </div></th><th><div>Interface </div></th></tr></thead><tbody><tr><td><div>​Methods​ </div></td><td><div>Can have both abstract and concrete methods. </div></td><td><div>Can have abstract, default, and static methods (since Java 8). </div></td></tr><tr><td><div>Inheritance </div></td><td><div>A class can extend only one abstract class. </div></td><td><div>A class can implement multiple interfaces. </div></td></tr><tr><td><div>Access Modifiers </div></td><td><div>Can have any access modifier (public, protected, private). </div></td><td><div>All methods are implicitly <code>public</code> and abstract (except default and static methods).​ </div></td></tr><tr><td><div>Fields </div></td><td><div>Can have instance variables. </div></td><td><div>Can only have <code>public static final</code> constants.​ </div></td></tr><tr><td><div>Use Case </div></td><td><div>Used when classes share common behavior. </div></td><td><div>Used to define a contract for unrelated classes. </div></td></tr></tbody></table> <h2>Advantages of Abstraction </h2><ul><li style="background-color: transparent;font-size: 18px">Improved Code Reusability: Abstract classes and interfaces allow developers to define reusable code structures.</li><li style="background-color: transparent;font-size: 18px">Enhanced Maintainability: By focusing on the "what" rather than the "how," abstraction makes code easier to maintain and extend.</li><li style="background-color: transparent;font-size: 18px">Reduced Complexity: Hiding implementation details reduces the complexity of the codebase.</li><li style="background-color: transparent;font-size: 18px">Encapsulation: Abstraction works hand-in-hand with encapsulation to protect sensitive data and implementation details.</li></ul>

Abstraction

​Polymorphism is one of the four fundamental principles of Object-Oriented Programming (OOP) in Java, alongside encapsulation, inheritance, and abstraction. The term "polymorphism" is derived from the Greek words poly (many) and morph (forms), meaning "many forms." In Java, polymorphism allows a single entity (such as a method or object) to behave differently based on the context.Polymorphism enhances code flexibility, reusability, and maintainability by allowing developers to write more generic and extensible code. It is primarily achieved through method overloading (compile-time polymorphism) and method overriding (runtime polymorphism).<h2>Types of Polymorphism in Java </h2><h3>​1. Compile-Time Polymorphism (Method Overloading)</h3>​Compile-time polymorphism, also known as static polymorphism, occurs when multiple methods in the same class share the same name but differ in their parameter lists (number, type, or order of parameters). The method to be called is determined at compile time based on the method signature.​Example:<pre>​​class Calculator { // Method with two parameters int add(int a, int b) { return a + b; } // Overloaded method with three parameters int add(int a, int b, int c) { return a + b + c; } } public class Main { public static void main(String[] args) { Calculator calc = new Calculator(); System.out.println(calc.add(5, 10)); // Output: 15 System.out.println(calc.add(5, 10, 20)); // Output: 35 } } </pre>​In this example, the <code>add</code> method is overloaded with two versions: one that takes two parameters and another that takes three. The appropriate method is selected at compile time based on the arguments passed. <h3>2. Runtime Polymorphism (Method Overriding)</h3>​Runtime polymorphism, also known as dynamic polymorphism, occurs when a subclass provides a specific implementation of a method that is already defined in its parent class. The method to be called is determined at runtime based on the object's actual type.​<h4>Example:</h4><pre>​class Animal { void makeSound() { System.out.println("Some generic animal sound"); } } class Dog extends Animal { @Override void makeSound() { System.out.println("The dog barks"); } } class Cat extends Animal { @Override void makeSound() { System.out.println("The cat meows"); } } public class Main { public static void main(String[] args) { Animal myAnimal; myAnimal = new Dog(); myAnimal.makeSound(); // Output: The dog barks myAnimal = new Cat(); myAnimal.makeSound(); // Output: The cat meows } } </pre>In this example, the <code>makeSound</code> method is overridden in the <code>Dog</code> and <code>Cat</code> classes. At runtime, the method corresponding to the actual object type (<code>Dog</code> or <code>Cat</code>) is executed, even though the reference type is <code>Animal</code>.<h2>​Polymorphism with Interfaces</h2>​Polymorphism can also be achieved using interfaces. A class can implement multiple interfaces, and the behavior can vary depending on the implementation. <h3>Example:</h3><pre>​interface Shape { void draw(); } class Circle implements Shape { @Override public void draw() { System.out.println("Drawing a circle"); } } class Rectangle implements Shape { @Override public void draw() { System.out.println("Drawing a rectangle"); } } public class Main { public static void main(String[] args) { Shape shape; shape = new Circle(); shape.draw(); // Output: Drawing a circle shape = new Rectangle(); shape.draw(); // Output: Drawing a rectangle } } </pre><div style="background-color: transparent">Here, the <code>Shape</code> interface is implemented by <code>Circle</code> and <code>Rectangle</code>. The <code>draw</code> method behaves differently depending on the actual object type.</div><div style="background-color: transparent">​ </div><h2>Key Differences Between Compile-Time and Runtime Polymorphism </h2><table class="se-table-layout-fixed"><thead><tr><th><div>Feature </div></th><th><div>Compile-Time Polymorphism </div></th><th><div>Runtime Polymorphism </div></th></tr></thead><tbody><tr><td><div>Method Binding </div></td><td><div>Happens at compile time (static binding). </div></td><td><div>Happens at runtime (dynamic binding). </div></td></tr><tr><td><div>Achieved Through </div></td><td><div>Method overloading. </div></td><td><div>Method overriding. </div></td></tr><tr><td><div>Flexibility </div></td><td><div>Less flexible, as the method is fixed at compile time. </div></td><td><div>More flexible, as the method is determined at runtime. </div></td></tr><tr><td><div>Inheritance Required </div></td><td><div>No. </div></td><td><div>Yes (or interface implementation). </div></td></tr></tbody></table> <h2>Advantages of Polymorphism </h2><ul><li style="background-color: transparent;font-size: 18px">Code Reusability: Polymorphism allows the same method or interface to be reused across different classes.</li><li style="background-color: transparent;font-size: 18px">Extensibility: New functionality can be added without modifying existing code.</li><li style="background-color: transparent;font-size: 18px">Flexibility: Objects can take on multiple forms, making the code more dynamic and adaptable.</li><li style="background-color: transparent">Simplified Code: Polymorphism reduces the need for complex conditional statements (e.g., <code>if-else</code> or <code>switch</code>).</li></ul> <h2>Real-World Example of Polymorphism </h2>​Consider a payment system where different payment methods (credit card, PayPal, bank transfer) are implemented. Polymorphism allows you to handle all payment methods using a single interface or parent class.<pre>​​package polymorph; abstract class Payment { abstract void pay(double amount); } class CreditCard extends Payment { @Override void pay(double amount) { System.out.println("Paid $" + amount + " using Credit Card."); } } class PayPal extends Payment { @Override void pay(double amount) { System.out.println("Paid $" + amount + " using PayPal."); } } </pre><div> </div><div>MainRunner.java</div><div> </div><pre>package polymorph; public class MainRunner { public static void main(String[] args) { Payment payment; payment = new CreditCard(); payment.pay(100.0); // Output: Paid $100.0 using Credit Card. payment = new PayPal(); payment.pay(200.0); // Output: Paid $200.0 using PayPal. } } ​​ </pre><div>.</div>

Polymorphism

​Encapsulation is one of the fundamental principles of Object-Oriented Programming (OOP) in Java. It is the process of bundling data (fields) and methods (functions) that operate on the data into a single unit, typically a class. Encapsulation also involves restricting direct access to some of an object's components, which is achieved by using access modifiers like <code>private</code>, <code>protected</code>, and <code>public</code>. This ensures that the internal state of an object is hidden from the outside world and can only be accessed or modified through controlled mechanisms, such as getter and setter methods.Encapsulation promotes data security, modularity, and maintainability, making it a key concept in writing robust and scalable Java applications.<h2>Key Features of Encapsulation </h2><ul><li style="background-color: transparent">Data Hiding: By declaring class variables as <code>private</code>, you prevent direct access to them from outside the class. This ensures that sensitive data is protected.</li><li style="background-color: transparent;font-size: 18px">Controlled Access: Access to private fields is provided through public getter and setter methods, allowing controlled modification and retrieval of data.</li><li style="background-color: transparent;font-size: 18px">Improved Maintainability: Encapsulation makes it easier to modify or update the internal implementation of a class without affecting external code that uses the class.</li><li style="background-color: transparent;font-size: 18px">Modularity: Encapsulation helps in dividing the code into smaller, manageable units, making the application easier to understand and maintain.</li></ul> <h3>Example of Encapsulation in Java</h3>​Below is an example that demonstrates encapsulation by using private fields and public getter and setter methods. <pre>​​class Employee { // Private fields (data hiding) private String name; private int age; private double salary; // Public getter for 'name' public String getName() { return name; } // Public setter for 'name' public void setName(String name) { this.name = name; } // Public getter for 'age' public int getAge() { return age; } // Public setter for 'age' public void setAge(int age) { if (age &gt; 0) { // Validation to ensure valid data this.age = age; } else { System.out.println("Age must be positive."); } } // Public getter for 'salary' public double getSalary() { return salary; } // Public setter for 'salary' public void setSalary(double salary) { if (salary &gt; 0) { // Validation to ensure valid data this.salary = salary; } else { System.out.println("Salary must be positive."); } } } public class Main { public static void main(String[] args) { Employee emp = new Employee(); // Setting values using setter methods emp.setName("John Doe"); emp.setAge(30); emp.setSalary(50000); // Accessing values using getter methods System.out.println("Name: " + emp.getName()); // John Doe System.out.println("Age: " + emp.getAge()); // 30 System.out.println("Salary: $" + emp.getSalary()); // $50000.0 } } </pre><h3>Explanation&nbsp;</h3><ul><li style="background-color: transparent">The fields <code>name</code>, <code>age</code>, and <code>salary</code> are declared as <code>private</code>, ensuring they cannot be accessed directly from outside the <code>Employee</code> class.</li><li style="background-color: transparent;font-size: 18px">Public getter and setter methods provide controlled access to these fields, allowing validation and logic to be applied when setting or retrieving values.</li></ul><h3>Benefits of Encapsulation </h3><ul><li style="background-color: transparent;font-size: 18px">Data Security: By hiding sensitive data, encapsulation prevents unauthorized access and ensures that only valid data is stored in the fields.</li><li style="background-color: transparent;font-size: 18px">Flexibility: You can change the internal implementation of a class (e.g., modify how data is stored or processed) without affecting external code that uses the class.</li><li style="background-color: transparent;font-size: 18px">Code Reusability: Encapsulation promotes modularity, making it easier to reuse and maintain code.</li><li style="background-color: transparent;font-size: 18px">Improved Debugging: Encapsulation makes it easier to identify and fix issues since the data and methods are tightly coupled within a single class.</li></ul> <h2>Real-World Example of Encapsulation </h2>​Consider a banking application where a <code>BankAccount</code> class is used to manage customer accounts. Encapsulation ensures that sensitive data, such as the account balance, is protected and can only be accessed or modified through controlled methods.<pre>class BankAccount { private double balance; public double getBalance() { return balance; } public void deposit(double amount) { if (amount &gt; 0) { balance += amount; System.out.println("Deposited: $" + amount); } else { System.out.println("Invalid deposit amount."); } } public void withdraw(double amount) { if (amount &gt; 0 &amp;&amp; amount &lt;= balance) { balance -= amount; System.out.println("Withdrawn: $" + amount); } else { System.out.println("Invalid withdrawal amount or insufficient balance."); } } } public class Main { public static void main(String[] args) { BankAccount account = new BankAccount(); account.deposit(1000); account.withdraw(500); System.out.println("Current Balance: $" + account.getBalance()); } } </pre><h3>Output: </h3>​Deposited: $1000.0 Withdrawn: $500.0 Current Balance: $500.0 ​In this example, the <code>balance</code> field is private, and all operations on it (deposit and withdrawal) are performed through public methods, ensuring data security and controlled access.

Encapsulation

​Exception handling and assertions are essential features in Java that help developers write robust and error-resilient code. While exception handling is used to manage runtime errors gracefully, assertions are used to test assumptions during development. Together, they contribute to building reliable and maintainable applications. <h2>Exception Handling in Java </h2><h3>​What is an Exception? </h3>​An exception is an event that disrupts the normal flow of a program during runtime. It occurs due to various reasons, such as invalid user input, file not found, network issues, or arithmetic errors (e.g., division by zero). Java provides a robust mechanism to handle such exceptions and prevent the program from crashing. <h3>Exception Hierarchy </h3>​In Java, all exceptions are derived from the <code>Throwable</code> class. The hierarchy is as follows: Throwable&nbsp;<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mo>↓</mo></mrow><annotation encoding="application/x-tex">\downarrow</annotation></semantics></math>↓<ul class=""><li style="background-color: transparent;font-size: 18px">Error: Represents serious issues that applications should not handle (e.g., <code>OutOfMemoryError</code>).</li><li style="background-color: transparent">Exception: Represents conditions that applications might want to catch and handle.<ul class=""><li style="background-color: transparent;font-size: 18px">Checked Exceptions: Exceptions that must be handled at compile time (e.g., <code>IOException</code>, <code>SQLException</code>).</li><li style="background-color: transparent">Unchecked Exceptions: Exceptions that occur at runtime and do not require mandatory handling (e.g., <code>NullPointerException</code>, <code>ArithmeticException</code>).</li></ul></li></ul><div class="se-component se-image-container __se__float-none" style="width: 100%"><figure style="width: 100%;"><img src="https://www.api.cstechie.com/upload/editor-image/Exceptions_(1)_1743004272899.png" alt="Exception Heirarchy" data-rotate="" data-proportion="true" data-size="100%," data-align="none" data-percentage="100," data-file-name="Exceptions (1).png" data-file-size="46836" data-origin="," style="width: 100%;"></figure></div><h3> </h3><h2>Checked vs Unchecked Exceptions in Java </h2><h3>Checked Exceptions: </h3>​Checked exceptions are exceptions that are checked at compile time. The Java compiler ensures that these exceptions are either handled using a <code>try-catch</code> block or declared in the method signature using the <code>throws</code> keyword. If not handled, the code will fail to compile.<h4>​Examples:</h4><ul class=""><li style="background-color: transparent;font-size: 18px"><code>IOException</code></li><li style="background-color: transparent;font-size: 18px"><code>SQLException</code></li><li style="background-color: transparent;font-size: 18px"><code>FileNotFoundException</code></li><li style="background-color: transparent;font-size: 18px"><code>ClassNotFoundException</code></li></ul><h3> </h3><h4>Characteristics:</h4><ul><li style="background-color: transparent;font-size: 18px">Must be handled explicitly in the code.</li><li style="background-color: transparent;font-size: 18px">Represent conditions that a program should anticipate and recover from (e.g., file not found, database connection failure).</li><li style="background-color: transparent;font-size: 18px">Typically used for external resources like files, databases, or network operations.</li></ul><h3> </h3><h3>Example of Checked Exception: </h3><pre>import java.io.File; import java.io.FileReader; import java.io.IOException; public class CheckedExceptionExample { public static void main(String[] args) { try { File file = new File("nonexistent.txt"); FileReader reader = new FileReader(file); // May throw FileNotFoundException } catch (IOException e) { System.out.println("File not found: " + e.getMessage()); } } } </pre><blockquote><h3>​In this example, the <code>FileReader</code> constructor throws a <code>FileNotFoundException</code>, which is a checked exception. The code must handle it using a <code>try-catch</code> block.​ </h3></blockquote><h3> </h3><h2>Unchecked Exceptions </h2>​Unchecked exceptions are exceptions that are not checked at compile time. These exceptions occur during runtime and are typically caused by programming errors, such as invalid logic or improper use of APIs. <h3>Examples:​</h3><ul class=""><li style="background-color: transparent;font-size: 18px"><code>NullPointerException</code></li><li style="background-color: transparent;font-size: 18px"><code>ArithmeticException</code></li><li style="background-color: transparent;font-size: 18px"><code>ArrayIndexOutOfBoundsException</code></li><li style="background-color: transparent;font-size: 18px"><code>IllegalArgumentException</code></li></ul><h3> </h3><h3>Characteristics:</h3><ul><li style="background-color: transparent;font-size: 18px">Do not need to be explicitly handled or declared in the method signature.</li><li style="background-color: transparent;font-size: 18px">Represent programming errors or bugs that the program cannot recover from (e.g., accessing a null object, dividing by zero).</li><li style="background-color: transparent">Typically extend the <code>RuntimeException</code> class.</li></ul><h3> </h3><h3>Example of Unchecked Exception: </h3><pre>​public class UncheckedExceptionExample { public static void main(String[] args) { int[] numbers = {1, 2, 3}; System.out.println(numbers[5]); // Throws ArrayIndexOutOfBoundsException } } </pre><h3><blockquote>​In this example, accessing an invalid array index throws an <code>ArrayIndexOutOfBoundsException</code>, which is an unchecked exception. The program will terminate unless the exception is handled.​ </blockquote></h3><h3> </h3><h3>Comparison</h3><table class="se-table-layout-fixed"><thead><tr><th><div>Aspect </div></th><th><div>Checked Exceptions </div></th><th><div>Unchecked Exceptions </div></th></tr></thead><tbody><tr><td><div>Compile-Time Check </div></td><td><div>Checked at compile time. </div></td><td><div>Not checked at compile time. </div></td></tr><tr><td><div>Handling Requirement </div></td><td><div>Must be handled using <code>try-catch</code> or declared with <code>throws</code>.​ </div></td><td><div>Handling is optional. </div></td></tr><tr><td><div>Cause </div></td><td><div>Represent recoverable conditions (e.g., file not found). </div></td><td><div>Represent programming errors (e.g., null pointer). </div></td></tr><tr><td><div>Class Hierarchy </div></td><td><div>Subclasses of <code>Exception</code> (excluding <code>RuntimeException</code>).​ </div></td><td><div>Subclasses of <code>RuntimeException</code>.​ </div></td></tr><tr><td><div>Examples </div></td><td><div>​<code>IOException</code>, <code>SQLException</code>, <code>FileNotFoundException</code>.​ </div></td><td><div>​<code>NullPointerException</code>, <code>ArithmeticException</code>.​ </div></td></tr></tbody></table><h3> </h3>

Exception handling

Java provides several keywords to handle exceptions effectively, ensuring robust and error-resilient applications. Below are the key exception handling keywords and their utilities: <h3>1. try </h3>The <code>try</code> block is used to enclose code that might throw an exception. It identifies the section of code where exceptions may occur. The <code>try</code> block must be followed by either a <code>catch</code> block, a <code>finally</code> block, or both.Utility: Encapsulates risky code to handle exceptions gracefully.<pre>​​try { int result = 10 / 0; // Risky code } catch (ArithmeticException e) { System.out.println("Cannot divide by zero."); } </pre> <h3>2. catch</h3>The <code>catch</code> block handles exceptions thrown in the <code>try</code> block. It specifies the type of exception to catch and provides a way to handle it. Multiple <code>catch</code> blocks can be used to handle different types of exceptions.Utility: Catches and processes specific exceptions.<pre>​try { int[] arr = new int[3]; System.out.println(arr[5]); // Risky code } catch (ArrayIndexOutOfBoundsException e) { System.out.println("Array index is out of bounds."); } </pre> <h3>Key Points:</h3><blockquote>​ <ul><li style="background-color: transparent">Specific Exception Handling:<ul><li style="font-size: 18px;background-color: transparent">we can use multiple<code>catch</code>blocks to handle different types of exceptions explicitly.</li><li style="font-size: 18px;background-color: transparent">The most specific exception should be caught first, followed by more general exceptions. This is because Java checks the<code>catch</code>blocks in the order they are written, and the first matching block is executed.</li></ul></li><li style="background-color: transparent">Generic Exception Handling:<ul><li style="font-size: 18px;background-color: transparent">If no specific<code>catch</code>block matches the thrown exception, a generic<code>catch</code>block using<code>Exception</code>can be used as a fallback to handle any other exceptions.</li></ul></li><li style="background-color: transparent">Order of Catch Blocks:<ul><li style="background-color: transparent">The order of<code>catch</code>blocks is important. More specific exceptions (e.g.,<code>ArithmeticException</code>,<code>NullPointerException</code>) must come before the generic<code>Exception</code>block. Otherwise, a compilation error will occur because the generic<code>Exception</code>block would catch all exceptions, making the specific blocks unreachable.</li></ul></li></ul></blockquote><ul><li style="background-color: transparent">Specific Exception Handling:<ul><li style="font-size: 18px;background-color: transparent">we can use multiple<code>catch</code>blocks to handle different types of exceptions explicitly.</li><li style="font-size: 18px;background-color: transparent">The most specific exception should be caught first, followed by more general exceptions. This is because Java checks the<code>catch</code>blocks in the order they are written, and the first matching block is executed.</li></ul></li><li style="background-color: transparent">Generic Exception Handling:<ul><li style="font-size: 18px;background-color: transparent">If no specific<code>catch</code>block matches the thrown exception, a generic<code>catch</code>block using<code>Exception</code>can be used as a fallback to handle any other exceptions.</li></ul></li><li style="background-color: transparent">Order of Catch Blocks:<ul><li style="background-color: transparent">The order of<code>catch</code>blocks is important. More specific exceptions (e.g.,<code>ArithmeticException</code>,<code>NullPointerException</code>) must come before the generic<code>Exception</code>block. Otherwise, a compilation error will occur because the generic<code>Exception</code>block would catch all exceptions, making the specific blocks unreachable.</li></ul></li></ul><h3>Example:</h3><pre>​public class MultipleCatchExample { public static void main(String[] args) { try { int[] arr = new int[3]; arr[5] = 10; // This will throw ArrayIndexOutOfBoundsException } catch (ArithmeticException e) { System.out.println("Arithmetic Exception caught: " + e.getMessage()); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("Array Index Out of Bounds Exception caught: " + e.getMessage()); } catch (Exception e) { System.out.println("Generic Exception caught: " + e.getMessage()); } } }</pre><h3> </h3><h3>3. finally</h3>The <code>finally</code> block contains code that will always execute, regardless of whether an exception is thrown or not. It is typically used for cleanup operations, such as closing files or releasing resources.Utility: Ensures cleanup actions are performed.<pre>​try { int result = 10 / 2; System.out.println(result); } catch (ArithmeticException e) { System.out.println("Error occurred."); } finally { System.out.println("Execution completed."); } </pre> <h3>4. throw</h3>The <code>throw</code> keyword is used to explicitly throw an exception. It is often used to throw custom exceptions or re-throw exceptions caught in a <code>catch</code> block.Utility: Manually triggers an exception.<pre>​public void validateAge(int age) { if (age &lt; 18) { throw new IllegalArgumentException("Age must be 18 or above."); } } </pre> <h3>5. throws</h3>The <code>throws</code> keyword is used in method declarations to indicate that a method might throw one or more exceptions. It delegates the responsibility of handling the exception to the calling method.Utility: Declares exceptions that a method can throw.<pre>​public void readFile(String fileName) throws IOException { FileReader file = new FileReader(fileName); } </pre> <h3>6. try-with-resources</h3>Introduced in Java 7, the <code>try-with-resources</code> statement is used to automatically close resources (e.g., files, streams) that implement the <code>AutoCloseable</code> interface. It eliminates the need for a <code>finally</code> block for resource cleanup.Utility: Simplifies resource management.<pre>​try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) { System.out.println(br.readLine()); } catch (IOException e) { System.out.println("Error reading file."); } </pre><h2>Summary:</h2><blockquote><ul><li style="background-color: transparent"><code>try</code>: Encapsulates risky code.</li><li style="background-color: transparent;font-size: 18px"><code>catch</code>: Handles specific exceptions.</li><li style="background-color: transparent;font-size: 18px"><code>finally</code>: Ensures cleanup actions are performed.</li><li style="background-color: transparent;font-size: 18px"><code>throw</code>: Explicitly throws an exception.</li><li style="background-color: transparent;font-size: 18px"><code>throws</code>: Declares exceptions a method might throw.</li><li style="background-color: transparent"><code>try-with-resources</code>: Automatically manages resource cleanup. </li></ul></blockquote>

Exception Handling Keywords and their utilities

Introduction to Java AssertionsAssertions in Java are a debugging tool used to test assumptions about a program's logic during development. They help identify and fix bugs by verifying that certain conditions hold true at specific points in the code. If an assertion fails, the program throws an <code>AssertionError</code>, indicating a potential issue in the code.Assertions are primarily used during development and testing phases and are typically disabled in production environments. They are not a substitute for exception handling but rather a complementary tool to ensure code correctness. <h3>Syntax </h3>​The <code>assert</code> keyword is used to create assertions in Java. There are two forms of assertions:<h4>Simple Assertion: </h4><pre>assert condition; </pre><code>condition</code>: A boolean expression that must evaluate to <code>true</code>. If it evaluates to <code>false</code>, an <code>AssertionError</code> is thrown.​ <h4>​Assertion with a Message:​ </h4><pre>assert condition : message; </pre><code>message</code>: An optional value (e.g., a string or object) that provides additional information when the assertion fails.​ <h2>Enabling and Disabling Assertions </h2>​By default, assertions are disabled in Java. To enable them, you need to use the <code>-ea</code> or <code>-enableassertions</code> flag when running the program. To disable assertions, use the <code>-da</code> or <code>-disableassertions</code> flag. <h3>Example: </h3><pre>java -ea MyProgram java -da MyProgram </pre> We can also enable or disable assertions for specific classes or packages:<ul class=""><li style="background-color: transparent;font-size: 18px">Enable for a specific class: <code>java -ea:com.example.MyClass MyProgram</code></li><li style="background-color: transparent">Disable for a specific package: <code>java -da:com.example... MyProgram</code></li></ul> <h3>Example of Assertions in Java</h3><pre>​public class AssertionExample { public static void main(String[] args) { int age = -5; assert age &gt; 0 : "Age must be positive"; System.out.println("Age is: " + age); } } </pre><h3> </h3><h3>When to Use Assertions </h3><ul><li style="background-color: transparent;font-size: 18px">Validating Assumptions: Use assertions to verify assumptions about the program's state that should always be true.</li><li style="background-color: transparent;font-size: 18px">Testing Invariants: Ensure that class invariants or loop invariants hold true during execution.</li><li style="background-color: transparent;font-size: 18px">Debugging: Use assertions to catch unexpected conditions during development.</li></ul> <h3>When Not to Use Assertions </h3><ul><li style="background-color: transparent;font-size: 18px">Production Code: Avoid using assertions for input validation or error handling in production, as they may be disabled.</li><li style="background-color: transparent;font-size: 18px">Side Effects: Do not include code with side effects (e.g., modifying variables) in assertions, as they may not execute if assertions are disabled.</li></ul> <h3>Advantages of Assertions</h3><ul><li style="background-color: transparent;font-size: 18px">Simplifies debugging by catching logical errors early.</li><li style="background-color: transparent;font-size: 18px">Improves code readability by documenting assumptions.</li><li style="background-color: transparent;font-size: 18px">Helps maintain code correctness during development.</li></ul> <h3>Limitations of Assertions</h3><ul><li style="background-color: transparent;font-size: 18px">Assertions are not a replacement for exception handling.</li><li style="background-color: transparent;font-size: 18px">They are disabled by default in production, so they should not be relied upon for critical checks.</li></ul><h3> </h3>

Java Assertions - A Comprehensive Guide

<h2>Introduction to Custom Exceptions in Java </h2>In Java, exceptions are used to handle errors and other exceptional events that occur during program execution. While Java provides a rich set of built-in exceptions (e.g., <code>NullPointerException</code>, <code>IOException</code>), there are scenarios where these exceptions may not adequately describe the problem. In such cases, developers can create custom exceptions to represent specific application-level errors.Custom exceptions improve code readability, maintainability, and provide more meaningful error messages tailored to the application's needs.<h2>Steps to Create a Custom Exception in Java </h2>​Creating a custom exception involves extending the <code>Exception</code> class (for checked exceptions) or the <code>RuntimeException</code> class (for unchecked exceptions). Below are the steps:<ul><li style="background-color: transparent">Define the Custom Exception Class: <ul><li style="background-color: transparent;font-size: 18px">Extend the<code>Exception</code>class for checked exceptions or<code>RuntimeException</code>for unchecked exceptions.</li><li style="background-color: transparent;font-size: 18px">Provide constructors to initialize the exception with custom messages or causes.</li></ul></li><li style="background-color: transparent"></li><li style="background-color: transparent">Throw the Custom Exception:<ul><li style="background-color: transparent;font-size: 18px">Use the <code>throw</code> keyword to explicitly throw the custom exception when a specific condition is met.​ </li></ul></li><li style="background-color: transparent">Handle the Custom Exception:<ul><li style="background-color: transparent">Use a <code>try-catch</code> block to handle the custom exception.</li></ul> </li></ul><h3>Example:&nbsp;Creating a Custom Checked Exception</h3><pre>​// Step 1: Define the custom exception class InvalidAgeException extends Exception { public InvalidAgeException(String message) { super(message); } } // Step 2: Throw the custom exception public class CustomExceptionExample { public void validateAge(int age) throws InvalidAgeException { if (age &lt; 18) { throw new InvalidAgeException("Age must be 18 or above."); } System.out.println("Age is valid."); } public static void main(String[] args) { CustomExceptionExample example = new CustomExceptionExample(); try { example.validateAge(16); // This will throw the exception } catch (InvalidAgeException e) { System.out.println("Caught Exception: " + e.getMessage()); } } } </pre><h3> </h3><h3> </h3><h3>Example: Creating a Custom Unchecked Exception </h3><pre>​// Step 1: Define the custom exception class NegativeNumberException extends RuntimeException { public NegativeNumberException(String message) { super(message); } } // Step 2: Throw the custom exception public class CustomUncheckedExceptionExample { public void checkNumber(int number) { if (number &lt; 0) { throw new NegativeNumberException("Number cannot be negative."); } System.out.println("Number is valid."); } public static void main(String[] args) { CustomUncheckedExceptionExample example = new CustomUncheckedExceptionExample(); try { example.checkNumber(-5); // This will throw the exception } catch (NegativeNumberException e) { System.out.println("Caught Exception: " + e.getMessage()); } } } </pre><h3> </h3><h3>Key Differences Between Checked and Unchecked Exceptions </h3>​ <table class="se-table-layout-fixed"><thead><tr><th><div>Aspect </div></th><th><div>Checked Exceptions </div></th><th><div>Unchecked Exceptions </div></th></tr></thead><tbody><tr><td><div>Class Hierarchy </div></td><td><div>Extend the <code>Exception</code> class (excluding <code>RuntimeException</code>).​ </div></td><td><div>Extend the <code>RuntimeException</code> class.​ </div></td></tr><tr><td><div>Compile-Time Check </div></td><td><div>Checked at compile time. </div></td><td><div>Not checked at compile time. </div></td></tr><tr><td><div>Declaration </div></td><td><div>Must be declared in the <code>throws</code> clause.​ </div></td><td><div>No need to declare in the <code>throws</code> clause.​ </div></td></tr><tr><td><div>Use Case </div></td><td><div>Used for recoverable conditions (e.g., file not found). </div></td><td><div>Used for programming errors (e.g., null pointer). </div></td></tr><tr><td><div>Examples </div></td><td><div>​<code>IOException</code>, <code>SQLException</code>​ </div></td><td><div>​<code>NullPointerException</code>, <code>ArithmeticException</code>​ </div></td></tr></tbody></table><h3> </h3><h3> </h3><h3>Best Practices for Creating Custom Exceptions </h3><ul><li style="background-color: transparent;font-size: 18px">Meaningful Names: Use descriptive names for custom exceptions to clearly indicate the error.</li><li style="background-color: transparent;font-size: 18px">Custom Messages: Provide detailed error messages to help identify the issue.</li><li style="background-color: transparent;font-size: 18px">Extend the Right Class: Use <code>Exception</code> for checked exceptions and <code>RuntimeException</code> for unchecked exceptions.</li><li style="background-color: transparent;font-size: 18px">Avoid Overuse: Only create custom exceptions when built-in exceptions are insufficient.</li><li style="background-color: transparent;font-size: 18px">Document Exceptions: Clearly document when and why the custom exception is thrown.</li></ul>

Creating Custom Exceptions in Java

<h2>Introduction to Multithreading in Java </h2>Multithreading is a core feature of Java that allows multiple threads to run concurrently within a program. A thread is the smallest unit of a process, and multithreading enables efficient utilization of CPU resources by executing multiple tasks simultaneously. This is particularly useful for applications that require parallel processing, such as gaming, web servers, or real-time systems.Java provides built-in support for multithreading through the <code>java.lang.Thread</code> class and the <code>java.util.concurrent</code> package, making it easier to create and manage threads. <h2>Creating Threads in Java</h2>​There are two primary ways to create threads in Java:<h3>​Extending the <code>Thread</code> Class:​</h3><ul><li style="background-color: transparent">Create a class that extends the <code>Thread</code> class.</li><li style="background-color: transparent;font-size: 18px">Override the <code>run()</code> method to define the task to be executed by the thread.</li><li style="background-color: transparent">Start the thread using the <code>start()</code> method.</li></ul> <pre>class MyThread extends Thread { public void run() { System.out.println("Thread is running: " + Thread.currentThread().getName()); } } public class ThreadExample { public static void main(String[] args) { MyThread thread1 = new MyThread(); thread1.start(); // Starts the thread } } ​ </pre> <h3>Implementing the <code>Runnable</code> Interface:</h3><ul class=""><li style="background-color: transparent">Create a class that implements the <code>Runnable</code> interface.</li><li style="background-color: transparent;font-size: 18px">Define the task in the <code>run()</code> method.</li><li style="background-color: transparent">Pass the <code>Runnable</code> object to a <code>Thread</code> object and start the thread.</li></ul><pre>​​class MyRunnable implements Runnable { public void run() { System.out.println("Thread is running: " + Thread.currentThread().getName()); } } public class RunnableExample { public static void main(String[] args) { MyRunnable runnable = new MyRunnable(); Thread thread = new Thread(runnable); thread.start(); // Starts the thread } } </pre><blockquote>*To Avoid Diamond problem, It is advisable to use Interface in place of Thread class. </blockquote><h2>Thread Lifecycle </h2>A thread in Java goes through the following states:<ol class=""><li style="background-color: transparent;font-size: 18px">New: The thread is created but not yet started.</li><li style="background-color: transparent;font-size: 18px">Runnable: The thread is ready to run but waiting for CPU time.</li><li style="background-color: transparent;font-size: 18px">Running: The thread is actively executing.</li><li style="background-color: transparent;font-size: 18px">Blocked/Waiting: The thread is waiting for a resource or signal.</li><li style="background-color: transparent;font-size: 18px">Terminated: The thread has completed execution.</li></ol> <h2>Advantages of Multithreading </h2><ul><li style="background-color: transparent;font-size: 18px">Concurrency: Multiple tasks can run simultaneously.</li><li style="background-color: transparent;font-size: 18px">Resource Sharing: Threads share the same memory space, reducing overhead.</li><li style="background-color: transparent;font-size: 18px">Improved Performance: Tasks are executed faster by utilizing CPU cores efficiently.</li></ul> <h2>Challenges of Multithreading </h2><ul><li style="background-color: transparent;font-size: 18px">Thread Interference: Multiple threads accessing shared resources can lead to data inconsistency.</li><li style="background-color: transparent;font-size: 18px">Deadlocks: Threads waiting indefinitely for resources can cause a deadlock.</li><li style="background-color: transparent;font-size: 18px">Complex Debugging: Multithreaded programs are harder to debug due to concurrent execution.</li></ul>

Multithreading

Java provides several methods in the <code>Thread</code> class to manage and control threads. These methods allow developers to create, start, pause, resume, and terminate threads effectively. Below is a detailed explanation of the most commonly used thread methods and their use cases.​<h3>start()</h3><ul class=""><li style="background-color: transparent">Description: Starts a new thread and invokes the <code>run()</code> method. This method transitions the thread from the "new" state to the "runnable" state.</li><li style="background-color: transparent;font-size: 18px">Use Case: Used to begin the execution of a thread.</li></ul><h3> </h3><h4>Example:</h4><pre>Thread thread = new Thread(() -&gt; System.out.println("Thread is running")); thread.start(); </pre> <h3>run()</h3><ul><li style="background-color: transparent">Description: Contains the code that a thread executes. It is called automatically when the <code>start()</code> method is invoked.</li><li style="background-color: transparent;font-size: 18px">Use Case: Override this method to define the task for the thread.</li></ul><h4>Example:</h4><pre>class MyThread extends Thread { public void run() { System.out.println("Thread is running"); } } </pre> <h3>sleep(long milliseconds)</h3><ul><li style="background-color: transparent;font-size: 18px">Description: Pauses the execution of the current thread for the specified time (in milliseconds).</li><li style="background-color: transparent;font-size: 18px">Use Case: Used to delay thread execution or simulate a waiting period.</li></ul><h4>Example</h4><pre>​​try { Thread.sleep(1000); // Pauses for 1 second } catch (InterruptedException e) { e.printStackTrace(); } </pre><h3> </h3><h3>join()</h3><ul><li style="background-color: transparent;font-size: 18px">Description: Waits for a thread to finish its execution before proceeding with the next line of code.</li><li style="background-color: transparent;font-size: 18px">Use Case: Used when one thread depends on the completion of another thread.</li></ul><h4>Example</h4><pre>Thread thread = new Thread(() -&gt; System.out.println("Thread finished")); thread.start(); try { thread.join(); // Waits for the thread to complete System.out.println("Main thread continues"); } catch (InterruptedException e) { e.printStackTrace(); } </pre><h3> </h3><h3>isAlive() </h3><ul><li style="background-color: transparent;font-size: 18px">Description: Checks if a thread is still running.</li><li style="background-color: transparent;font-size: 18px">Use Case: Used to verify whether a thread has completed its execution.</li></ul><h4>Example:</h4><pre>​Thread thread = new Thread(() -&gt; System.out.println("Thread is running")); thread.start(); System.out.println("Is thread alive? " + thread.isAlive()); </pre> <h3>getName() and setName(String name)</h3><ul><li style="background-color: transparent">Description: <code>getName()</code> retrieves the name of the thread, and <code>setName()</code> sets a custom name for the thread.</li><li style="background-color: transparent;font-size: 18px">Use Case: Used to identify threads, especially in multithreaded applications.</li></ul><pre>Thread thread = new Thread(() -&gt; System.out.println("Thread is running")); thread.setName("MyThread"); thread.start(); System.out.println("Thread name: " + thread.getName()); // Output // Thread name MyThread </pre> <h3>getPriority() and setPriority(int priority)</h3><ul><li style="background-color: transparent">Description: <code>getPriority()</code> retrieves the priority of a thread, and <code>setPriority()</code> sets the priority (values range from <code>Thread.MIN_PRIORITY</code> (1) to <code>Thread.MAX_PRIORITY</code> (10)).</li><li style="background-color: transparent;font-size: 18px">Use Case: Used to control the execution order of threads (though thread scheduling is platform-dependent).</li></ul><pre>​​Thread thread = new Thread(() -&gt; System.out.println("Thread is running")); thread.setPriority(Thread.MAX_PRIORITY); thread.start(); System.out.println("Thread priority: " + thread.getPriority()); // 10 </pre><h3>interrupt()</h3><ul><li style="background-color: transparent;font-size: 18px">Description: Interrupts a thread, signaling it to stop or perform a specific action. The thread must handle the interruption explicitly.</li><li style="background-color: transparent;font-size: 18px">Use Case: Used to stop a thread or signal it to perform a specific task.</li></ul><pre>​​Thread thread = new Thread(() -&gt; { try { Thread.sleep(5000); } catch (InterruptedException e) { System.out.println("Thread interrupted"); } }); thread.start(); thread.interrupt(); // Interrupts the thread </pre><h3>yield()</h3><ul><li style="background-color: transparent;font-size: 18px">Description: Temporarily pauses the execution of the current thread to allow other threads of the same priority to execute.</li><li style="background-color: transparent;font-size: 18px">Use Case: Used to improve thread scheduling and allow other threads to execute.</li></ul><pre>Thread thread = new Thread(() -&gt; { System.out.println("Thread yielding"); Thread.yield(); System.out.println("Thread resumed"); }); thread.start(); </pre> <h3>currentThread()</h3><ul><li style="background-color: transparent;font-size: 18px">Description: Returns a reference to the currently executing thread.</li><li style="background-color: transparent;font-size: 18px">Use Case: Used to get information about the thread currently running.</li></ul><pre>​​Thread thread = Thread.currentThread(); System.out.println("Current thread: " + thread.getName()); </pre> <h3>setDaemon(boolean t) and isDaemon()</h3><ul><li style="background-color: transparent">Description: <code>setDaemon()</code> marks a thread as a daemon thread, and <code>isDaemon()</code> checks if a thread is a daemon. Daemon threads run in the background and terminate when all user threads finish.</li><li style="background-color: transparent;font-size: 18px">Use Case: Used for background tasks like garbage collection.</li></ul><pre>​​Thread thread = new Thread(() -&gt; System.out.println("Daemon thread running")); thread.setDaemon(true); thread.start(); System.out.println("Is daemon: " + thread.isDaemon()); </pre> <h3>stop()&nbsp; (Depricatted)</h3><ul><li style="background-color: transparent;font-size: 18px">Description: Forces a thread to stop execution immediately.</li><li style="background-color: transparent">Use Case: Not recommended as it can leave resources in an inconsistent state. Use <code>interrupt()</code> instead.</li></ul> ​ ​

Thread Methods and their use cases

<h2>Introduction to Synchronization in Java </h2>In Java, synchronization is a mechanism that ensures controlled access to shared resources in a multithreaded environment. When multiple threads access shared resources (e.g., variables, objects, or files) simultaneously, it can lead to data inconsistency or race conditions. Synchronization prevents such issues by allowing only one thread to access a critical section of code at a time.Java provides built-in synchronization mechanisms to ensure thread safety and maintain data integrity. <h2>Why Synchronization is Needed </h2>​In a multithreaded program, threads often share resources like variables or objects. Without synchronization, multiple threads may modify the same resource simultaneously, leading to unpredictable results. <h3>​Example of a Race Condition:​ </h3><pre>class Counter { private int count = 0; public void increment() { count++; } public int getCount() { return count; } } public class RaceConditionExample { public static void main(String[] args) { Counter counter = new Counter(); Thread t1 = new Thread(() -&gt; { for (int i = 0; i &lt; 1000; i++) { counter.increment(); } }); Thread t2 = new Thread(() -&gt; { for (int i = 0; i &lt; 1000; i++) { counter.increment(); } }); t1.start(); t2.start(); try { t1.join(); t2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Final count: " + counter.getCount()); } } </pre> Output (varies):Final count: 1897<blockquote>​In this example, the final count is incorrect because both threads modify the <code>count</code> variable simultaneously, causing a race condition.​ </blockquote> <h2>Types of Synchronization in Java </h2>Java provides two types of synchronization: <ul><li style="background-color: transparent;font-size: 18px">Process Synchronization: Ensures that processes (not threads) execute in a synchronized manner.</li><li style="background-color: transparent;font-size: 18px">Thread Synchronization: Ensures that threads access shared resources in a synchronized manner. This is the focus of this article.</li></ul> <h3>Thread Synchronization in Java </h3>​Thread synchronization can be achieved in the following ways: <ol><li style="background-color: transparent">Synchronized Methods</li><li style="background-color: transparent">Synchronized Blocks</li><li style="background-color: transparent">Static Synchronization</li><li style="background-color: transparent">Using Locks (from <code>java.util.concurrent.locks</code> package)</li></ol><h3>&nbsp;Synchronized Methods </h3>A synchronized method ensures that only one thread can execute it at a time. The lock is associated with the object on which the method is called. <pre>​​class Counter { private int count = 0; public synchronized void increment() { count++; } public int getCount() { return count; } } public class SynchronizedMethodExample { public static void main(String[] args) { Counter counter = new Counter(); Thread t1 = new Thread(() -&gt; { for (int i = 0; i &lt; 1000; i++) { counter.increment(); } }); Thread t2 = new Thread(() -&gt; { for (int i = 0; i &lt; 1000; i++) { counter.increment(); } }); t1.start(); t2.start(); try { t1.join(); t2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Final count: " + counter.getCount()); } } </pre> Output:Final count: 2000​<h3>Synchronized Blocks </h3>​A synchronized block allows you to synchronize only a specific part of the code, rather than the entire method. This improves performance by reducing the scope of synchronization. Syntax:<pre>synchronized(object) { // Critical section } </pre>Example:<pre>​​class Counter { private int count = 0; public void increment() { synchronized (this) { count++; } } public int getCount() { return count; } } </pre> <blockquote>​​In this example, only the critical section (<code>count++</code>) is synchronized, improving performance.</blockquote> <h3>Static Synchronization </h3>Static synchronization is used to synchronize static methods. The lock is associated with the class, not the object. <h4>Example</h4><pre>​class Counter { private static int count = 0; public static synchronized void increment() { count++; } public static int getCount() { return count; } } public class StaticSynchronizationExample { public static void main(String[] args) { Thread t1 = new Thread(() -&gt; { for (int i = 0; i &lt; 1000; i++) { Counter.increment(); } }); Thread t2 = new Thread(() -&gt; { for (int i = 0; i &lt; 1000; i++) { Counter.increment(); } }); t1.start(); t2.start(); try { t1.join(); t2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Final count: " + Counter.getCount()); } } </pre> <h3>Using Locks </h3>​The <code>java.util.concurrent.locks</code> package provides the <code>Lock</code> interface, which offers more flexibility than synchronized methods or blocks.<h4>Example: </h4><pre>import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class Counter { private int count = 0; private Lock lock = new ReentrantLock(); public void increment() { lock.lock(); try { count++; } finally { lock.unlock(); } } public int getCount() { return count; } } public class LockExample { public static void main(String[] args) { Counter counter = new Counter(); Thread t1 = new Thread(() -&gt; { for (int i = 0; i &lt; 1000; i++) { counter.increment(); } }); Thread t2 = new Thread(() -&gt; { for (int i = 0; i &lt; 1000; i++) { counter.increment(); } }); t1.start(); t2.start(); try { t1.join(); t2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Final count: " + counter.getCount()); } } </pre> <h2>Advantages of Synchronization </h2><ul><li style="background-color: transparent;font-size: 18px">Thread Safety: Prevents data inconsistency and race conditions.</li><li style="background-color: transparent;font-size: 18px">Data Integrity: Ensures that shared resources are accessed in a controlled manner.</li><li style="background-color: transparent;font-size: 18px">Simplified Debugging: Reduces unpredictable behavior in multithreaded programs.</li></ul> <h2>Disadvantages of Synchronization </h2><ul><li style="background-color: transparent;font-size: 18px">Performance Overhead: Synchronization can slow down the program due to thread contention.</li><li style="background-color: transparent;font-size: 18px">Deadlocks: Improper synchronization can lead to deadlocks, where threads wait indefinitely for resources.</li><li style="background-color: transparent;font-size: 18px">Complexity: Managing synchronized code can make the program harder to understand and maintain.</li></ul>

Synchronization in Java Multithreading

​Thread communication refers to the mechanism by which threads can communicate and coordinate their actions. Java provides three key methods from the <code>Object</code> class to facilitate thread communication: <code>wait()</code>, <code>notify()</code>, and <code>notifyAll()</code>. These methods are used in conjunction with synchronization to ensure proper coordination between threads. <h2>Key Methods for Thread Communication </h2><ul><li style="background-color: transparent"><code>wait()</code>: <ul><li style="background-color: transparent;font-size: 18px">Causes the current thread to release the lock and enter the waiting state until another thread invokes<code>notify()</code>or<code>notifyAll()</code>on the same object.</li><li style="background-color: transparent">Must be called within a synchronized block or method.</li></ul></li><li style="background-color: transparent"><code>notify()</code>: <ul><li style="background-color: transparent;font-size: 18px">Wakes up a single thread that is waiting on the object's monitor. The awakened thread will resume execution after acquiring the lock.</li></ul></li><li style="background-color: transparent"><code>notifyAll()</code>:<ul><li style="background-color: transparent;font-size: 18px">Wakes up all threads that are waiting on the object's monitor. Only one thread will acquire the lock and continue execution.</li></ul> </li></ul><h3>Example of Thread Communication </h3>​The following example demonstrates how threads can communicate using <code>wait()</code>, <code>notify()</code>, and <code>notifyAll()</code>:<pre>class SharedResource { private boolean flag = false; public synchronized void produce() { try { while (flag) { wait(); // Wait until the consumer consumes } System.out.println("Producing..."); flag = true; notify(); // Notify the consumer } catch (InterruptedException e) { e.printStackTrace(); } } public synchronized void consume() { try { while (!flag) { wait(); // Wait until the producer produces } System.out.println("Consuming..."); flag = false; notify(); // Notify the producer } catch (InterruptedException e) { e.printStackTrace(); } } } public class ThreadCommunicationExample { public static void main(String[] args) { SharedResource resource = new SharedResource(); Thread producer = new Thread(() -&gt; { for (int i = 0; i &lt; 5; i++) { resource.produce(); } }); Thread consumer = new Thread(() -&gt; { for (int i = 0; i &lt; 5; i++) { resource.consume(); } }); producer.start(); consumer.start(); } } </pre> <h3>Output:</h3><code>Producing...</code><code> Consuming... </code><code> Producing... </code><code> Consuming... </code><code> ... </code> <h2>Best Practices for Thread Communication</h2><ul><li style="background-color: transparent">Always use <code>wait()</code>, <code>notify()</code>, and <code>notifyAll()</code> within synchronized blocks or methods.</li><li style="background-color: transparent;font-size: 18px">Use <code>notify()</code> when only one thread needs to be awakened and <code>notifyAll()</code> when multiple threads are waiting.</li><li style="background-color: transparent">Avoid using <code>wait()</code> in a loop without a condition check to prevent spurious wakeups.</li></ul>

Thread Communication

A thread group in Java is a way to group multiple threads into a single unit. It allows you to manage threads collectively, such as starting, interrupting, or checking the status of all threads in the group. Thread groups are part of the <code>java.lang</code> package and are represented by the <code>ThreadGroup</code> class.​ <h2>Creating a Thread Group </h2>We&nbsp;can create a thread group using the <code>ThreadGroup</code> class. Threads can be added to a group by specifying the group in the thread's constructor. <h4>Example:</h4><pre>​public class ThreadGroupExample { public static void main(String[] args) { // Create a thread group ThreadGroup group = new ThreadGroup("MyThreadGroup"); // Create threads and add them to the group Thread t1 = new Thread(group, () -&gt; System.out.println("Thread 1 is running"), "Thread-1"); Thread t2 = new Thread(group, () -&gt; System.out.println("Thread 2 is running"), "Thread-2"); t1.start(); t2.start(); // Display information about the thread group System.out.println("Thread Group Name: " + group.getName()); group.list(); // Lists all threads in the group } } </pre> <h3>Output:</h3><blockquote>Thread 1 is running Thread 2 is running Thread Group Name: MyThreadGroup java.lang.ThreadGroup[name=MyThreadGroup,maxpri=10] Thread[Thread-1,5,MyThreadGroup] Thread[Thread-2,5,MyThreadGroup]</blockquote><h3> </h3><h3>Key Methods of the <code>ThreadGroup</code> Class</h3><ul><li style="background-color: transparent">getName(): <ul><li style="background-color: transparent;font-size: 18px">Returns the name of the thread group.</li></ul></li><li style="background-color: transparent">activeCount():<ul><li style="background-color: transparent;font-size: 18px">Returns the number of active threads in the group.</li></ul></li><li style="background-color: transparent">list():<ul><li style="background-color: transparent;font-size: 18px">Prints information about the thread group and its threads.</li></ul></li><li style="background-color: transparent">interrupt(): <ul><li style="background-color: transparent;font-size: 18px">Interrupts all threads in the group.</li></ul></li><li style="background-color: transparent">setMaxPriority(int priority):<ul><li style="background-color: transparent;font-size: 18px">Sets the maximum priority for threads in the group.</li></ul> </li></ul><h3>Example: Managing Threads with a Thread Group </h3><pre>public class ThreadGroupManagement { public static void main(String[] args) { ThreadGroup group = new ThreadGroup("WorkerGroup"); Runnable task = () -&gt; { System.out.println(Thread.currentThread().getName() + " is running"); try { Thread.sleep(1000); } catch (InterruptedException e) { System.out.println(Thread.currentThread().getName() + " was interrupted"); } }; Thread t1 = new Thread(group, task, "Worker-1"); Thread t2 = new Thread(group, task, "Worker-2"); Thread t3 = new Thread(group, task, "Worker-3"); t1.start(); t2.start(); t3.start(); System.out.println("Active threads in group: " + group.activeCount()); // Interrupt all threads in the group group.interrupt(); } } </pre><h3> </h3><h3>Output:</h3><blockquote>Worker-1 is running Worker-2 is running Worker-3 is running Active threads in group: 3 Worker-1 was interrupted Worker-2 was interrupted Worker-3 was interrupted </blockquote><h3>​ </h3><h2>​Advantages of Thread Groups </h2><ul><li style="background-color: transparent;font-size: 18px">Simplified Management: Thread groups allow you to manage multiple threads collectively.</li><li style="background-color: transparent;font-size: 18px">Centralized Control: You can interrupt or set priorities for all threads in a group at once.</li><li style="background-color: transparent;font-size: 18px">Organization: Thread groups help organize threads logically, making the program easier to understand.</li></ul><h2> </h2><h2>Limitations of Thread Groups </h2><ul><li style="background-color: transparent;font-size: 18px">Deprecated Features: Some features of thread groups, such as stopping threads, are deprecated due to safety concerns.</li><li style="background-color: transparent">Limited Use: Modern applications often use the <code>ExecutorService</code> from the <code>java.util.concurrent</code> package for thread management.</li></ul><h2> </h2>

Thread Group in Java

<h2>Introduction to Executor Framework </h2>​The Executor Framework in Java is a powerful API introduced in Java 5 as part of the <code>java.util.concurrent</code> package. It provides a high-level mechanism for managing and controlling threads in a multithreaded application. Instead of manually creating and managing threads, the Executor Framework allows developers to focus on task execution while the framework handles thread pooling, scheduling, and resource management.​ The Executor Framework is designed to simplify multithreading by decoupling task submission from thread management. It is particularly useful for applications that require efficient thread management, such as web servers, real-time systems, and parallel processing applications. <h2>Key Components of the Executor Framework </h2>​The Executor Framework consists of several key interfaces and classes: <ul><li style="background-color: transparent"><code>Executor</code> Interface: <ul><li style="background-color: transparent;font-size: 18px">The base interface for executing tasks.</li><li style="background-color: transparent;font-size: 18px">Provides a single method,<code>execute(Runnable command)</code>, to submit tasks for execution.</li></ul></li><li style="background-color: transparent">ExecutorService Interface:<ul><li style="background-color: transparent;font-size: 18px">Extends the <code>Executor</code> interface and provides additional methods for managing and controlling thread execution.</li><li style="background-color: transparent;font-size: 18px">Includes methods like <code>submit()</code>, <code>shutdown()</code>, and <code>invokeAll()</code>.</li></ul></li><li style="background-color: transparent">ScheduledExecutorService Interface: <ul><li style="background-color: transparent;font-size: 18px">Extends<code>ExecutorService</code>and supports task scheduling (e.g., executing tasks after a delay or at fixed intervals).</li></ul></li><li style="background-color: transparent">ThreadPoolExecutor Class:<ul><li style="background-color: transparent;font-size: 18px">A concrete implementation of<code>ExecutorService</code>that provides a customizable thread pool.</li></ul></li><li style="background-color: transparent">Executors Utility Class:<ul><li style="background-color: transparent">Provides factory methods to create pre-configured thread pools, such as <code>newFixedThreadPool()</code>, <code>newCachedThreadPool()</code>, and <code>newSingleThreadExecutor()</code>.</li></ul> </li></ul><h2>Benefits of the Executor Framework </h2><ul><li style="background-color: transparent;font-size: 18px">Thread Pooling: Reuses a pool of threads to execute tasks, reducing the overhead of creating and destroying threads.</li><li style="background-color: transparent;font-size: 18px">Task Management: Simplifies task submission and execution, allowing developers to focus on the logic of the tasks.</li><li style="background-color: transparent;font-size: 18px">Scalability: Efficiently manages thread resources, making it suitable for high-performance applications.</li><li style="background-color: transparent;font-size: 18px">Scheduling: Supports task scheduling with <code>ScheduledExecutorService</code>.</li><li style="background-color: transparent;font-size: 18px">Graceful Shutdown: Provides methods to shut down the executor gracefully.</li></ul> <h2>Creating and Using Executors </h2>​The Executors class provides several factory methods to create different types of thread pools: <h3>​1. Fixed Thread Pool</h3>​A thread pool with a fixed number of threads. If all threads are busy, new tasks are queued until a thread becomes available. <pre>​​import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class FixedThreadPoolExample { public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(3); for (int i = 1; i &lt;= 5; i++) { int taskId = i; executor.execute(() -&gt; { System.out.println("Task " + taskId + " is running by " + Thread.currentThread().getName()); }); } executor.shutdown(); // Gracefully shuts down the executor } } </pre><h3> </h3><h3>2. Cached Thread Pool</h3>​A thread pool that creates new threads as needed but reuses previously created threads when available. Suitable for short-lived tasks. <pre>​​ExecutorService executor = Executors.newCachedThreadPool(); for (int i = 1; i &lt;= 5; i++) { int taskId = i; executor.execute(() -&gt; { System.out.println("Task " + taskId + " is running by " + Thread.currentThread().getName()); }); } executor.shutdown(); </pre> <h3>3. Single Thread Executor​ </h3>​A thread pool with a single thread. Tasks are executed sequentially in the order they are submitted. <pre>​​ExecutorService executor = Executors.newSingleThreadExecutor(); for (int i = 1; i &lt;= 5; i++) { int taskId = i; executor.execute(() -&gt; { System.out.println("Task " + taskId + " is running by " + Thread.currentThread().getName()); }); } executor.shutdown(); </pre> <h3>4. Scheduled Thread Pool</h3>​A thread pool that supports task scheduling, such as executing tasks after a delay or at fixed intervals. <pre>​​import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public class ScheduledThreadPoolExample { public static void main(String[] args) { ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2); // Schedule a task to run after a 2-second delay scheduler.schedule(() -&gt; { System.out.println("Task executed after 2 seconds"); }, 2, TimeUnit.SECONDS); // Schedule a task to run repeatedly every 3 seconds scheduler.scheduleAtFixedRate(() -&gt; { System.out.println("Repeating task executed"); }, 1, 3, TimeUnit.SECONDS); // Shutdown the scheduler after 10 seconds scheduler.schedule(() -&gt; scheduler.shutdown(), 10, TimeUnit.SECONDS); } } </pre> <h2>Managing Executors</h2><ul><li style="background-color: transparent">Shutting Down Executors:<ul><li style="background-color: transparent;font-size: 18px">Use shutdown() to stop accepting new tasks and allow existing tasks to complete.</li><li style="background-color: transparent;font-size: 18px">Use shutdownNow() to attempt to stop all tasks immediately.</li></ul></li><li style="background-color: transparent">Submitting Tasks:<ul><li style="background-color: transparent;font-size: 18px">Use execute() for Runnable tasks.</li><li style="background-color: transparent;font-size: 18px">Use submit() for Callable tasks, which return a result.</li></ul></li><li style="background-color: transparent">Handling Results:<ul><li style="background-color: transparent;font-size: 18px">Use Future to retrieve the result of a Callable task or check its completion status.</li></ul></li></ul><h3> </h3><h3> </h3><h3>​Example with Callable and Future: </h3><pre>​import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class CallableExample { public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(2); Callable&lt;Integer&gt; task = () -&gt; { System.out.println("Task is running by " + Thread.currentThread().getName()); return 42; // Return a result }; Future&lt;Integer&gt; future = executor.submit(task); try { System.out.println("Result: " + future.get()); // Retrieve the result } catch (Exception e) { e.printStackTrace(); } executor.shutdown(); } } </pre> <h2> </h2><h2>Advantages of the Executor Framework​ </h2><ol><li style="background-color: transparent;font-size: 18px">Efficient Resource Management: Reuses threads, reducing the overhead of thread creation and destruction.</li><li style="background-color: transparent;font-size: 18px">Simplified Multithreading: Provides a high-level API for managing threads and tasks.</li><li style="background-color: transparent;font-size: 18px">Scalability: Supports dynamic thread management and task scheduling.</li><li style="background-color: transparent;font-size: 18px">Error Handling: Allows better error handling and monitoring of tasks using Future and Callable.</li></ol> <h2>Best Practices for Using the Executor Framework </h2><ul><li style="background-color: transparent">Always shut down the executor using <code>shutdown()</code> or <code>shutdownNow()</code> to release resources.</li><li style="background-color: transparent;font-size: 18px">Use <code>Callable</code> and <code>Future</code> for tasks that return results or throw exceptions.</li><li style="background-color: transparent;font-size: 18px">Avoid creating too many threads in a thread pool to prevent resource exhaustion.</li><li style="background-color: transparent">Use <code>ScheduledExecutorService</code> for periodic or delayed tasks instead of <code>Timer</code>.</li></ul>