Java

Final vs Finally vs Finalize in Java

Final vs Finally vs Finalize in Java: The Ultimate Guide to Avoid Confusion

Java developers often get confused between final, finally, and finalize. These three terms might sound similar, but they serve completely different purposes. If you’ve ever struggled to understand their differences, this guide is for you!

By the end of this post, you’ll have a clear understanding of final vs finally vs finalize in Java and how to use each one correctly. Let’s dive in!

1. What is final in Java?

The final keyword in Java is used for constants, method restrictions, and inheritance control. It can be applied to variables, methods, and classes.

a) final with Variables (Constant Values)

When a variable is declared final, its value cannot be changed once assigned.

Java
public class FinalVariableExample {
    final int MAX_VALUE = 100; // Constant value
    
    void display() {
        // MAX_VALUE = 200; // This will cause a compilation error
        System.out.println("Max Value: " + MAX_VALUE);
    }
}

The MAX_VALUE variable is declared as final, so its value cannot be modified.

b) final with Methods (Prevent Overriding)

A final method cannot be overridden by subclasses.

Java
class Parent {
    final void show() {
        System.out.println("This is a final method.");
    }
}

class Child extends Parent {
    // void show() { // This will cause a compilation error
    //     System.out.println("Cannot override a final method");
    // }
}

The show() method in the Parent class is marked final, preventing the Child class from overriding it.

c) final with Classes (Prevent Inheritance)

A class declared as final cannot be extended.

Java
final class FinalClass {
    void display() {
        System.out.println("This is a final class.");
    }
}

// class SubClass extends FinalClass { // This will cause a compilation error
// }

The FinalClass cannot be extended by any subclass.

2. What is finally in Java?

The finally block in Java is used to ensure that important code executes, regardless of exceptions. It is primarily used with try-catch blocks to handle exceptions.

Java
public class FinallyExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // This will cause an exception
        } catch (ArithmeticException e) {
            System.out.println("Exception caught: " + e.getMessage());
        } finally {
            System.out.println("Finally block executed!");
        }
    }
}

Output:

Java
Exception caught: / by zero
Finally block executed!

The finally block runs no matter what happens in the try-catch block. This is useful for closing resources like database connections or file streams.

3. What is finalize() in Java?

The finalize() method is used for garbage collection. It is called by the Garbage Collector before an object is destroyed to perform cleanup operations.

Java
class FinalizeExample {
    protected void finalize() {
        System.out.println("Finalize method called before garbage collection.");
    }

    public static void main(String[] args) {
        FinalizeExample obj = new FinalizeExample();
        obj = null; // Making object eligible for garbage collection
        System.gc(); // Requesting garbage collection
        System.out.println("End of main method.");
    }
}

Output (may vary depending on JVM execution):

Java
End of main method.
Finalize method called before garbage collection.
  • The finalize() method is called before an object is garbage collected but not guaranteed to execute immediately or at all.
  • Calling System.gc() only suggests garbage collection to the JVM, but it does not force it.
  • Due to unpredictability and performance issues, finalize() has been deprecated in Java 9 and removed (marked as remove) in Java 18.
Alternatives to finalize():
  • Try-with-resources (AutoCloseable) – For handling resources like files, sockets, and streams.
  • java.lang.ref.Cleaner (Java 9+) – A more reliable way to register cleanup actions when objects become unreachable.
Important Note:

The use of finalize() is strongly discouraged in modern Java programming. Developers should use explicit resource management instead of relying on garbage collection for cleanup.

Final vs Finally vs Finalize in Java: Key Differences

Featurefinalfinallyfinalize()
UsageVariable, method, or class modifierBlock in exception handlingMethod in garbage collection
EffectRestricts variable reassignment, method overriding, and class inheritanceEnsures execution of critical codeAllows cleanup before object removal
ExecutionCompile-timeAlways runs after try-catchCalled by garbage collector
PurposeRestrictionCode execution assuranceCleanup

When to Use Final, Finally, and Finalize?

  • Use final when you want to create constants, prevent method overriding, or restrict class inheritance.
  • Use finally when you need to execute important code regardless of exceptions, like closing resources.
  • Use finalize() only if you need to clean up resources before garbage collection, though it is now discouraged.

Conclusion

Understanding final vs finally vs finalize in Java is crucial for writing efficient and error-free Java programs. While final is used for constants, method restrictions, and inheritance prevention, finally ensures essential code execution, and finalize() helps with garbage collection (though deprecated in Java 9+).

custom exceptions

Custom Exceptions vs. Standard Exceptions in Java: When to Extend and When Not To

Java provides a robust exception handling mechanism that helps developers write reliable and maintainable code. While Java’s standard exceptions cover many common error scenarios, sometimes you need something more specific to your application’s needs. This is where custom exceptions in Java come into play. But when should you create a custom exception, and when is...

Membership Required

You must be a member to access this content.

View Membership Levels

Already a member? Log in here
Checked Exceptions

Checked Exceptions in Java: What They Are and How They Work

When writing Java programs, handling errors is an essential part of creating robust and reliable applications. One important concept in Java’s error-handling mechanism is checked exceptions. If you’re new to Java or need a refresher, this guide will walk you through what checked exceptions are, how they work, and how to handle them effectively.

What Are Checked Exceptions in Java?

Checked exceptions in Java are a category of exceptions that must be either caught or declared in the method signature using the throws keyword. They are part of Java’s mechanism to enforce error handling at compile-time, ensuring that developers acknowledge and manage potential problems before running the program.

Unlike unchecked exceptions, which arise due to programming errors (such as NullPointerException or ArrayIndexOutOfBoundsException), checked exceptions typically indicate recoverable conditions like missing files, failed network connections, or invalid user input.

Let’s understand this with a simple example.

Imagine you are booking a flight online. There are two possible situations:

  1. You enter correct details, and the ticket is booked successfully.
  2. You enter an incorrect credit card number, and the system stops the booking process, showing an error.

In Java terms:

  • Booking the flight successfully is like a normal method execution.
  • Entering an invalid card number is like a checked exception, because the system knows this issue could happen and forces you to handle it (e.g., by showing an error message).

How Does Java Enforce Checked Exceptions?

When writing Java code, some operations have a high chance of failing, like:

  • Reading a file (the file may not exist) → IOException
  • Connecting to a database (the database might be down) → SQLException
  • Waiting for a thread to complete → InterruptedException

Since these errors are expected, Java forces you to either:

  • Handle them using try-catch
  • Declare them using throws in the method signature

Let’s say we want to read a file. There’s a chance the file doesn’t exist, so Java forces us to handle this situation.

Without Handling (Compilation Error)

Java
import java.io.FileReader;

public class CheckedExceptionExample {
    public static void main(String[] args) {
        FileReader file = new FileReader("path\data.txt"); // Compilation Error!
    }
}

Error: Unhandled exception: java.io.FileNotFoundException
 Java stops compilation because we didn’t handle the exception. Also the compiler suggests two options: the first one is to surround the code with a try-catch block, and the second is to declare the exception using the throws keyword in the method signature.

Handling with try-catch

We handle the error inside the method using try-catch:

Java
import java.io.FileReader;
import java.io.IOException;

public class CheckedExceptionExample {
    public static void main(String[] args) {
        try {
            FileReader file = new FileReader("path\data.txt"); 
            System.out.println("File opened successfully.");
        } catch (IOException e) {
            System.out.println("Error: File not found.");
        }
    }
}

Output if file exists: File opened successfully.
Output if file is missing: Error: File not found.

Handling with throws (Delegating the Exception)

Instead of handling it inside the method, we can let the caller handle it by declaring throws in the method signature.

Java
import java.io.FileReader;
import java.io.IOException;

public class CheckedExceptionExample {
    public static void main(String[] args) throws IOException {
        FileReader file = new FileReader("path\data.txt"); 
        System.out.println("File opened successfully.");
    }
}

This approach is useful for propagating exceptions to higher-level methods where they can be handled appropriately.

Why Are Checked Exceptions Important?

Checked exceptions serve an important role in Java by enforcing better error handling. Here’s why they matter:

  1. Compile-Time Safety: They prevent runtime failures by ensuring errors are anticipated and handled during development.
  2. Encourages Robust Code: Developers are forced to think about possible failure scenarios and how to deal with them.
  3. Improves Code Maintainability: Explicit exception declarations make it clear which methods can fail, improving readability and maintainability.

Conclusion

Checked exceptions in Java play a crucial role in enforcing proper error handling at compile-time. By understanding how they work and following best practices, you can write cleaner, more reliable Java code. Whether you use try-catch blocks or declare exceptions with throws, handling checked exceptions properly ensures your applications run smoothly and recover gracefully from potential issues.

By integrating these techniques into your Java development workflow, you’ll be better prepared to handle unexpected situations, making your applications more robust and user-friendly.

Unchecked Exceptions in Java

Unchecked Exceptions in Java: What They Are

Java is a powerful programming language that provides robust error handling mechanisms through exceptions. Exceptions in Java are classified into checked exceptions and unchecked exceptions. In this blog post, we’ll dive deep into unchecked exceptions in java, focusing on RuntimeException, and explore how they work, when to use them, and best practices.

What Are Unchecked Exceptions in Java?

Unchecked exceptions in Java are exceptions that occur during the execution of a program and do not need to be explicitly declared or handled. They are subclasses of RuntimeException, which itself extends Exception. Unlike checked exceptions, the compiler does not force you to handle unchecked exceptions, giving developers more flexibility.

Imagine you are driving a car:

  • If you run out of fuel before starting, you already know you’ll need to refill (like a checked exception, where Java warns you in advance).
  • If you suddenly get a flat tire while driving, it’s unexpected (like an unchecked exception, because Java doesn’t force you to check for it).

Unchecked exceptions usually happen due to coding mistakes like dividing by zero, accessing an invalid index, or dereferencing null.

Key Characteristics of Unchecked Exceptions:

  • They occur at runtime.
  • They are not required to be handled using try-catch or declared with throws
  • They indicate programming errors, such as logical flaws or improper API usage.
  • Examples include NullPointerException, ArrayIndexOutOfBoundsException, and IllegalArgumentException.

Common Causes of Unchecked Exceptions

Unchecked exceptions often arise from:

  1. Null references — Trying to access methods or fields of a null object leads to a NullPointerException.
  2. Invalid array access — Accessing an index beyond the array’s length results in ArrayIndexOutOfBoundsException.
  3. Illegal operations — Dividing by zero throws an ArithmeticException.
  4. Invalid casting — Trying to cast an object to an incompatible type leads to ClassCastException.
  5. Improper argument usage — Passing an invalid argument to a method can trigger IllegalArgumentException.

How to Handle Unchecked Exceptions in Java?

Although unchecked exceptions don’t require explicit handling, it is good practice to write defensive code to avoid them. Here are some best practices:

1. Use Null Checks

Before using an object, always ensure it is not null to avoid NullPointerException.

2. Validate Input Arguments

Check method parameters before processing them.

3. Use Try-Catch Blocks Sparingly

Try-catch blocks should not be overused for unchecked exceptions but can be useful in specific cases.

Difference Between Checked and Unchecked Exceptions

Understanding the distinction between checked and unchecked exceptions is crucial for writing efficient Java code.

FeatureChecked ExceptionsUnchecked Exceptions
InheritanceExtends Exception (except RuntimeException)Extends RuntimeException
Compile-time CheckingChecked by the compilerNot checked by the compiler
Handling RequirementMust be handled or declaredNo mandatory handling
Use CaseRepresent recoverable conditions (e.g., IOException)Indicate programming errors (e.g., NullPointerException)

Should You Catch Unchecked Exceptions in Java?

Generally, it’s best to avoid catching unchecked exceptions unless you’re implementing a global exception handler. Instead, focus on writing clean, error-free code by using input validation and proper null checks. However, in web applications or frameworks, handling unchecked exceptions globally can enhance user experience by providing clear error messages rather than allowing the application to crash.

Conclusion

Unchecked exceptions in Java, particularly those derived from RuntimeException, provide flexibility but also require responsible usage. They indicate programming mistakes that should be fixed rather than caught. By following best practices like validating inputs, using meaningful messages, and logging exceptions properly, developers can write robust and maintainable Java applications.

How to create threads in java

How to Create Threads in Java (The Easy Way): From Thread Class to Runnable Explained

If you’re diving into Java programming, one of the most empowering features to understand is multithreading. It allows you to run multiple tasks concurrently, making your application more efficient and responsive. In this post, we’ll walk you through how to create threads in Java, using both the Thread class and the Runnable interface.

Why Multithreading Matters in Java

Multithreading helps your program perform multiple operations simultaneously. Think of downloading files, processing data, and updating the UI all at once. Without multithreading, these tasks would run one after the other, slowing everything down.

Java makes multithreading easy thanks to built-in support via the Thread class and the Runnable interface.

Method 1: Using the Thread Class

This is the most direct way to create a thread in Java.

Step-by-step:

  1. Extend the Thread class.
  2. Override the run() method.
  3. Create an object of your class.
  4. Call the start() method.
Java
class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running...");
    }

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
    }
}

What Happens Here?

  • run() defines the code that runs in the new thread.
  • start() creates a new thread and invokes run().
  • If you call run() directly, it runs in the main thread, not a new one.

This method is simple but has a limitation: your class can’t extend any other class since Java doesn’t support multiple inheritance.

Method 2: Implementing the Runnable Interface

A more flexible way to create threads in Java is by implementing the Runnable interface.

Step-by-step:

  1. Implement Runnable.
  2. Override the run() method.
  3. Pass the object to a Thread constructor.
  4. Start the thread.
Java
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable thread is running...");
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable);
        t1.start();
    }
}

Why Use Runnable?

  • It allows your class to extend another class while still supporting threads.
  • It separates the task (logic in run()) from the thread execution (managed by Thread).

Thread Class vs Runnable Interface: Quick Comparison

FeatureThread ClassRunnable Interface
Inheritance LimitationYes (extends Thread)No (implements Runnable)
Separation of ConcernsNoYes
Recommended ForSimple one-off threadsBetter architecture & reuse

Pro Tip: Use Anonymous Classes or Lambdas (Java 8+)

If you’re working with short-lived tasks, you don’t need to write a separate class.

Anonymous Runnable:

Java
Thread t = new Thread(new Runnable() {
    public void run() {
        System.out.println("Anonymous thread running");
    }
});
t.start();

Lambda Runnable (Java 8+):

Java
Thread t = new Thread(() -> {
    System.out.println("Lambda thread running");
});
t.start();

Best Practices for Creating Threads in Java

  • Avoid calling run() directly. Use start() to ensure a new thread is created.
  • Use Runnable when possible. It offers better design flexibility.
  • Name your threads. This makes debugging easier: Thread t = new Thread(runnable, "WorkerThread");
  • Use thread pools for many threads. For heavy-duty multithreading, look into ExecutorService.

Want more details? Check out the full guide: [Main Article URL]

Conclusion

Learning how to create threads in Java isn’t just about writing concurrent code. It’s about writing efficient, clean, and scalable applications.

Start with Thread if you’re just experimenting. Move to Runnable for better design. Embrace lambdas and anonymous classes for quick jobs.

Multithreading is a key skill in Java. Master it, and you unlock a whole new level of performance for your applications.

FAQ: How to Create Threads in Java

Q: Can I start a thread without creating a class?
A: Yes, use anonymous classes or lambdas.

Q: What happens if I call run() instead of start()?
A: The code runs in the main thread, not in a new thread.

Q: Is Runnable better than Thread?
A: Usually yes. It gives more design flexibility and aligns with best practices.

Multithreading in Java

What Is Multithreading in Java? A Beginner-Friendly Guide with Real Examples

If you’re learning Java, you’ve probably come across the term multithreading. It may sound complicated at first, but it’s one of the most powerful features Java offers for building fast and responsive applications. This guide will break down multithreading in Java. You’ll learn what it is, why it matters, how it works, and how to...

Membership Required

You must be a member to access this content.

View Membership Levels

Already a member? Log in here
finalize() Method

Java finalize() Method Explained: Is It Still Relevant in 2025?

Java developers have used the finalize() method for years to handle cleanup operations before an object is garbage collected. But in 2025, does the finalize() method in Java still hold any relevance? With advancements in garbage collection and alternative resource management techniques, many developers question its necessity. In this blog post, we’ll explore the finalize()...

Membership Required

You must be a member to access this content.

View Membership Levels

Already a member? Log in here
throw and throws

How to Use throw and throws Effectively in Java

When working with Java, handling exceptions properly is crucial to writing robust and maintainable applications. Two essential keywords in Java’s exception-handling mechanism are throw and throws. While they may look similar, they serve different purposes. In this guide, we will explore how to use throw and throws effectively in Java, ensuring clarity and proper exception handling.

Understanding throw and throws in Java

Both throw and throws relate to Java’s exception-handling framework, but they are used differently:

  • throw: Used within a method to explicitly throw an exception.
  • throws: Declares exceptions that a method might throw.

Now, let’s explore both in detail with examples.

Understanding throw in Java

The throw keyword in Java is used to manually create and throw an exception object. This allows the programmer to explicitly indicate exceptional conditions in the program flow.

Java
throw new ArithmeticException("/ by zero");

In this example, an ArithmeticException object is created explicitly with the message “/ by zero” and thrown using the throw keyword.

The main objective of the throw keyword is to hand over the created exception object to the JVM manually.

The following two programs yield exactly the same result:

Without throw keyword:

Java
class Test {
    public static void main(String[] args) {
        System.out.println(10/0);
    }
}


//output

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Test.main(Test.java:3)

In this case, the main method is responsible for causing the ArithmeticException and implicitly hands over the exception object to the JVM.

With throw keyword:

Java
class Test {
    public static void main(String[] args) {
        throw new ArithmeticException("/ by zero");
    }
}


//o/p

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Test.main(Test.java:3)

In this case, the main method explicitly creates an ArithmeticException object using throw keyword and hands it over to the JVM.

Here is one more example.

Java
public class ThrowExample {
    static void checkAge(int age) {
        if (age < 18) {
            throw new IllegalArgumentException("Age must be 18 or above");
        } else {
            System.out.println("Access granted.");
        }
    }
    
    public static void main(String[] args) {
        checkAge(15);  // This will throw an exception
    }
}

Here,

  • The method checkAge(int age) checks whether the given age is 18 or more.
  • If the condition is not met, throw is used to raise an IllegalArgumentException.
  • This terminates program execution unless the exception is caught and handled. The throw statement stops execution of the current block and transfers control to the nearest exception handler.

Understanding throws in Java

In Java, if there is a possibility of a checked exception being thrown within a method, the method must either handle the exception using a try-catch block or declare that it throws the exception using the throws keyword in its method signature.

Java
import java.io.*;

class Test {
    public static void main(String[] args) {
        PrintWriter pw = new PrintWriter("abc.txt");
        pw.println("Hello");
    }
}

//Compilation Error: unreported exception java.io.FileNotFoundException; must be caught or declared to be thrown

In this example, the PrintWriter constructor can throw a FileNotFoundException, a checked exception. Since it’s not handled within the main method, it results in a compilation error.

To handle this error, you can either use a try-catch block to handle the exception:

Java
import java.io.*;

class Test {
    public static void main(String[] args) {
        try {
            PrintWriter pw = new PrintWriter("abc.txt");
            pw.println("Hello");
        } catch (FileNotFoundException e) {
            // Handle the exception
            e.printStackTrace();
        }
    }
}

Or you can declare that the method throws the exception using the throws keyword:

Java
import java.io.*;

class Test {
    public static void main(String[] args) throws FileNotFoundException {
        PrintWriter pw = new PrintWriter("abc.txt");
        pw.println("Hello");
    }
}

Using the throws keyword delegates the responsibility of handling the exception to the caller of the method.

Here is another example.

Java
import java.io.IOException;

public class ThrowsExample {
    static void readFile() throws IOException {
        throw new IOException("File not found");
    }
    
    public static void main(String[] args) {
        try {
            readFile();
        } catch (IOException e) {
            System.out.println("Exception handled: " + e.getMessage());
        }
    }
}

Here,

  • The readFile method declares throws IOException, meaning it might throw an IOException.
  • Instead of handling the exception inside readFile, it delegates handling to the caller (main method).
  • The main method catches the exception using a try-catch block, preventing the program from crashing.

Note: It’s recommended to handle exceptions using try-catch blocks where possible, as using throws may propagate exceptions up the call stack without handling them properly.

Key Differences Between throw and throws

Featurethrowthrows
PurposeUsed to explicitly throw an exceptionDeclares exceptions a method can throw
LocationInside the method bodyIn the method signature
Number of ExceptionsCan only throw one exception at a timeCan declare multiple exceptions separated by commas
PropagationStops execution immediately unless handledInforms the caller to handle the exception

Best Practices for Using throw and throws

1. Use throw for Specific Error Conditions

When you detect a problem in your logic, use throw to raise an appropriate exception. Always provide meaningful error messages to help debugging.

2. Use throws for Method-Level Exception Handling

If a method performs an operation that may result in an exception (e.g., file handling, database access), use throws to declare it and let the caller handle it.

3. Catch and Handle Exceptions Properly

Declaring exceptions using throws does not replace exception handling. Always use try-catch blocks where necessary.

4. Avoid Overusing throws

Overusing throws can make a method difficult to use, as the caller must handle multiple exceptions. Only declare exceptions when handling them inside the method is impractical or when the caller needs to decide how to respond.

Conclusion

Understanding how to use throw and throws effectively in Java is key to writing robust applications. throw is used to generate exceptions manually, while throws is used to declare potential exceptions in a method. By following best practices, you can ensure better error handling and maintainable code.

Try-Catch-Finally in Java

Try-Catch-Finally in Java: How Multiple Catch Blocks Fit into Java’s Exception Handling Flow

Try-Catch-Finally in Java is a crucial part of Java programming. It helps prevent programs from crashing due to unexpected errors. Java provides a structured way to handle exceptions using try, catch, and finally blocks. In this post, we’ll explore how multiple catch blocks work in Java’s exception handling flow and how they improve code reliability....

Membership Required

You must be a member to access this content.

View Membership Levels

Already a member? Log in here
Java Exception Hierarchy

Java Exception Hierarchy Explained: A Complete Guide

Java is a powerful, object-oriented programming language that provides a structured way to handle errors using exceptions. Understanding the Java Exception Hierarchy is crucial for writing robust, error-free code. In this guide, we’ll break down Java’s exception system, explore its hierarchy, and show you how to use it effectively. Java Exception Hierarchy In Java’s Exception...

Membership Required

You must be a member to access this content.

View Membership Levels

Already a member? Log in here
error: Content is protected !!