java try assignment

The Java Tutorials have been written for JDK 8. Examples and practices described in this page don't take advantage of improvements introduced in later releases and might use technology no longer available. See Java Language Changes for a summary of updated language features in Java SE 9 and subsequent releases. See JDK Release Notes for information about new features, enhancements, and removed or deprecated options for all JDK releases.

The try-with-resources Statement

The try -with-resources statement is a try statement that declares one or more resources. A resource is an object that must be closed after the program is finished with it. The try -with-resources statement ensures that each resource is closed at the end of the statement. Any object that implements java.lang.AutoCloseable , which includes all objects which implement java.io.Closeable , can be used as a resource.

The following example reads the first line from a file. It uses an instance of FileReader and BufferedReader to read data from the file. FileReader and BufferedReader are resources that must be closed after the program is finished with it:

In this example, the resources declared in the try -with-resources statement are a FileReader and a BufferedReader . The declaration statements of these resources appear within parentheses immediately after the try keyword. The classes FileReader and BufferedReader , in Java SE 7 and later, implement the interface java.lang.AutoCloseable . Because the FileReader and BufferedReader instances are declared in a try -with-resource statement, they will be closed regardless of whether the try statement completes normally or abruptly (as a result of the method BufferedReader.readLine throwing an IOException ).

Prior to Java SE 7, you can use a finally block to ensure that a resource is closed regardless of whether the try statement completes normally or abruptly. The following example uses a finally block instead of a try -with-resources statement:

However, this example might have a resource leak. A program has to do more than rely on the garbage collector (GC) to reclaim a resource's memory when it's finished with it. The program must also release the resoure back to the operating system, typically by calling the resource's close method. However, if a program fails to do this before the GC reclaims the resource, then the information needed to release the resource is lost. The resource, which is still considered by the operaing system to be in use, has leaked.

In this example, if the readLine method throws an exception, and the statement br.close() in the finally block throws an exception, then the FileReader has leaked. Therefore, use a try -with-resources statement instead of a finally block to close your program's resources.

If the methods readLine and close both throw exceptions, then the method readFirstLineFromFileWithFinallyBlock throws the exception thrown from the finally block; the exception thrown from the try block is suppressed. In contrast, in the example readFirstLineFromFile , if exceptions are thrown from both the try block and the try -with-resources statement, then the method readFirstLineFromFile throws the exception thrown from the try block; the exception thrown from the try -with-resources block is suppressed. In Java SE 7 and later, you can retrieve suppressed exceptions; see the section Suppressed Exceptions for more information.

The following example retrieves the names of the files packaged in the zip file zipFileName and creates a text file that contains the names of these files:

In this example, the try -with-resources statement contains two declarations that are separated by a semicolon: ZipFile and BufferedWriter . When the block of code that directly follows it terminates, either normally or because of an exception, the close methods of the BufferedWriter and ZipFile objects are automatically called in this order. Note that the close methods of resources are called in the opposite order of their creation.

The following example uses a try -with-resources statement to automatically close a java.sql.Statement object:

The resource java.sql.Statement used in this example is part of the JDBC 4.1 and later API.

Note : A try -with-resources statement can have catch and finally blocks just like an ordinary try statement. In a try -with-resources statement, any catch or finally block is run after the resources declared have been closed.

Suppressed Exceptions

An exception can be thrown from the block of code associated with the try -with-resources statement. In the example writeToFileZipFileContents , an exception can be thrown from the try block, and up to two exceptions can be thrown from the try -with-resources statement when it tries to close the ZipFile and BufferedWriter objects. If an exception is thrown from the try block and one or more exceptions are thrown from the try -with-resources statement, then those exceptions thrown from the try -with-resources statement are suppressed, and the exception thrown by the block is the one that is thrown by the writeToFileZipFileContents method. You can retrieve these suppressed exceptions by calling the Throwable.getSuppressed method from the exception thrown by the try block.

Classes That Implement the AutoCloseable or Closeable Interface

See the Javadoc of the AutoCloseable and Closeable interfaces for a list of classes that implement either of these interfaces. The Closeable interface extends the AutoCloseable interface. The close method of the Closeable interface throws exceptions of type IOException while the close method of the AutoCloseable interface throws exceptions of type Exception . Consequently, subclasses of the AutoCloseable interface can override this behavior of the close method to throw specialized exceptions, such as IOException , or no exception at all.

About Oracle | Contact Us | Legal Notices | Terms of Use | Your Privacy Rights

Copyright © 1995, 2022 Oracle and/or its affiliates. All rights reserved.

Try-Catch Statement

What is an exception ​.

In Java, an exception is an unforeseen or abnormal event that occurs during the execution of a program and disrupts its normal flow. These events can be caused by various factors, such as invalid user input, attempting to divide by zero, accessing a null object, or trying to access an array element with an invalid index.

Why Exception Handling is Needed: ​

Exception handling is essential for creating robust and reliable Java programs. It provides a structured way to deal with unexpected situations and ensures that the program can gracefully recover from errors. Here are some key reasons why exception handling is crucial:

Error Recovery:

• Exception handling allows the program to recover from errors and continue its execution rather than abruptly terminating.

Improved User Experience:

• Handling exceptions helps in providing meaningful error messages to users, making it easier for them to understand and address issues.
• Proper exception handling facilitates easier debugging by providing information about the cause and location of an error.

Maintainability:

• Code that includes exception handling is often more maintainable, as it explicitly addresses potential issues and provides a clear path for resolution.

The Use of Try-Catch Block: ​

The try-catch block is a fundamental mechanism in Java for handling exceptions. It allows you to enclose a block of code in a try block, and if an exception occurs within that block, it can be caught and handled in the corresponding catch block.

Example: Division by Zero: ​

• The try block contains the code that may throw an exception, in this case, dividing by zero.
• If an ArithmeticException occurs (which happens when dividing by zero), the control is transferred to the catch block.
• The catch block handles the exception by printing an error message.

When catching exceptions, consider logging the exception details along with additional contextual information. This practice aids in effective debugging.

Explain the importance of the order of catch blocks. How does the order impact the handling of exceptions, and what considerations should be taken into account?

• What is an Exception?
• Why Exception Handling is Needed:
• Example: Division by Zero:

Learn Java practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn java interactively, java introduction.

• Java Hello World
• Java JVM, JRE and JDK
• Java Variables and Literals
• Java Data Types
• Java Operators
• Java Input and Output
• Java Expressions & Blocks
• Java Comment

Java Flow Control

• Java if...else
• Java switch Statement
• Java for Loop
• Java for-each Loop
• Java while Loop
• Java break Statement
• Java continue Statement
• Java Arrays
• Multidimensional Array
• Java Copy Array

Java OOP (I)

• Java Class and Objects
• Java Methods
• Java Method Overloading
• Java Constructor
• Java Strings
• Java Access Modifiers
• Java this keyword
• Java final keyword
• Java Recursion
• Java instanceof Operator

Java OOP (II)

• Java Inheritance
• Java Method Overriding
• Java super Keyword
• Abstract Class & Method
• Java Interfaces
• Java Polymorphism
• Java Encapsulation

Java OOP (III)

• Nested & Inner Class
• Java Static Class
• Java Anonymous Class
• Java Singleton
• Java enum Class
• Java enum Constructor
• Java enum String
• Java Reflection

Java Exception Handling

• Java Exceptions

Java try...catch

Java throw and throws

Java catch Multiple Exceptions

Java try-with-resources

• Java Annotations
• Java Annotation Types
• Java Logging
• Java Assertions
• Java Collections Framework
• Java Collection Interface
• Java List Interface
• Java ArrayList
• Java Vector
• Java Queue Interface
• Java PriorityQueue
• Java Deque Interface
• Java LinkedList
• Java ArrayDeque
• Java BlockingQueue Interface
• Java ArrayBlockingQueue
• Java LinkedBlockingQueue
• Java Map Interface
• Java HashMap
• Java LinkedHashMap
• Java WeakHashMap
• Java EnumMap
• Java SortedMap Interface
• Java NavigableMap Interface
• Java TreeMap
• Java ConcurrentMap Interface
• Java ConcurrentHashMap
• Java Set Interface
• Java HashSet
• Java EnumSet
• Java LinkedhashSet
• Java SortedSet Interface
• Java NavigableSet Interface
• Java TreeSet
• Java Algorithms
• Java Iterator
• Java ListIterator
• Java I/O Streams
• Java InputStream
• Java OutputStream
• Java FileInputStream
• Java FileOutputStream
• Java ByteArrayInputStream
• Java ByteArrayOutputStream
• Java ObjectInputStream
• Java ObjectOutputStream
• Java BufferedInputStream
• Java BufferedOutputStream
• Java PrintStream

Java Reader/Writer

• Java Reader
• Java Writer
• Java InputStreamReader
• Java OutputStreamWriter
• Java FileReader
• Java FileWriter
• Java BufferedReader
• Java BufferedWriter
• Java StringReader
• Java StringWriter
• Java PrintWriter

Additional Topics

• Java Scanner Class
• Java Type Casting
• Java autoboxing and unboxing
• Java Lambda Expression
• Java Generics
• Java File Class
• Java Wrapper Class
• Java Command Line Arguments

Java Tutorials

In the last tutorial, we learned about Java exceptions . We know that exceptions abnormally terminate the execution of a program.

This is why it is important to handle exceptions. Here's a list of different approaches to handle exceptions in Java.

• try...catch block
• finally block
• throw and throws keyword

1. Java try...catch block

The try-catch block is used to handle exceptions in Java. Here's the syntax of try...catch block:

Here, we have placed the code that might generate an exception inside the try block. Every try block is followed by a catch block.

When an exception occurs, it is caught by the catch block. The catch block cannot be used without the try block.

Example: Exception handling using try...catch

In the example, we are trying to divide a number by 0 . Here, this code generates an exception.

To handle the exception, we have put the code, 5 / 0 inside the try block. Now when an exception occurs, the rest of the code inside the try block is skipped.

The catch block catches the exception and statements inside the catch block is executed.

If none of the statements in the try block generates an exception, the catch block is skipped.

2. Java finally block

In Java, the finally block is always executed no matter whether there is an exception or not.

The finally block is optional. And, for each try block, there can be only one finally block.

The basic syntax of finally block is:

If an exception occurs, the finally block is executed after the try...catch block. Otherwise, it is executed after the try block. For each try block, there can be only one finally block.

Example: Java Exception Handling using finally block

In the above example, we are dividing a number by 0 inside the try block. Here, this code generates an ArithmeticException .

The exception is caught by the catch block. And, then the finally block is executed.

Note : It is a good practice to use the finally block. It is because it can include important cleanup codes like,

• code that might be accidentally skipped by return, continue or break
• closing a file or connection

3. Java throw and throws keyword

The Java throw keyword is used to explicitly throw a single exception.

When we throw an exception, the flow of the program moves from the try block to the catch block.

Example: Exception handling using Java throw

In the above example, we are explicitly throwing the ArithmeticException using the throw keyword.

Similarly, the throws keyword is used to declare the type of exceptions that might occur within the method. It is used in the method declaration.

Example: Java throws keyword

When we run this program, if the file test.txt does not exist, FileInputStream throws a FileNotFoundException which extends the IOException class.

The findFile() method specifies that an IOException can be thrown. The main() method calls this method and handles the exception if it is thrown.

If a method does not handle exceptions, the type of exceptions that may occur within it must be specified in the throws clause.

To learn more, visit Java throw and throws .

Table of Contents

• Introduction
• Java try...catch block
• Java finally block
• Java throw and throws keyword

Sorry about that.

Related Tutorials

Java Tutorial

• Manage Email Subscriptions
• How to Post to DZone
• Article Submission Guidelines
• Manage My Drafts

Intro to AI: Dive into the fundamentals of artificial intelligence, machine learning, neural networks, ethics, and more.

Vector databases: Learn all about the specialized VDBMS — its initial setup, data preparation, collection creation, data querying, and more.

Open Source Migration Practices and Patterns : Explore key traits of migrating open-source software and its impact on software development.

Enterprise AI Trend Report: Gain insights on ethical AI, MLOps, generative AI, large language models, and much more.

• Five Java Developer Must-Haves for Ultra-Fast Startup Solutions
• Mastering Concurrency: An In-Depth Guide to Java's ExecutorService
• A Maven Story
• Java EE 6 Pet Catalog with GlassFish and MySQL
• How to Submit a Post to DZone
• Essential Math to Master AI and Quantum
• Telemetry Pipelines Workshop: Parsing Multiple Events
• Using Spring AI With AI/LLMs to Query Relational Databases

How to Specify Multiple Resources in a Single Try-With-Resources Statement

The ability to specify multiple resources in a single try-with-resources statement is a feature introduced in java 7. but, it can be fraught with peril if not used carefully. read on to ensure you do this right every time..

Join the DZone community and get the full member experience.

One of the more useful features of Java 7 was the introduction of the try-with-resources statement , also known as the  Automatic Resource Management ( ARM ). The attractiveness of the try-with-resources statement lies in its promise to "ensure that each resource is closed at the end of the statement." A "resource" in this context is any class that implements AutoCloseable and its close() method and is instantiated inside the "try" clause of the try-with-resources statement .

The Java Language Specification (JLS) describes the try-with-resources statement in detail in Section 14.20.3  of Java SE 10 JLS in this case. The JLS states that the " try -with-resources statement is parameterized with local variables (known as resources ) that are initialized before execution of the try block and closed automatically, in the reverse order from which they were initialized, after execution of the try block."

The JLS clearly specifies that multiple resources can be defined in relation to a single try -with-resources statement, and it specifies how multiple resources are specified. Specifically, it indicates that try can be followed by a " ResourceSpecification " that is composed of a " ResourceList " that is composed of one or more " Resource 's." When there is more than a single declared resource, the multiple resources are delimited by a semicolon ( ; ). This specification of multiple resources in a semicolon-delimited list is important because any candidate resources not declared in this manner will not be supported (will not be closed automatically) by the try -with-resources statement.

The most likely source of errors when specifying multiple resources in a try -with-resources statement is "nesting" instantiations of "resources," instead of explicitly instantiating local variables of each of them separately with semicolons between each instantiation. The examples below will illustrate the difference.

Two ridiculous but illustrative classes are shown next. Each class implements an  AutoCloseable and can be used in conjunction with try -with-resources and will have its close() method called automatically when used correctly with the try -with-resources statement. They are named to reflect that the OuterResource can be instantiated with an instance of the InnerResource .

InnerResource.java

OuterResource.java

The two classes defined can now be used to demonstrate the difference between correctly declaring instances of each in the same try -with-resources statement in a semicolon-delimited list and incorrectly nesting instantiation of the inner resource within the constructor of the outer resource. The latter approach doesn't work as well as hoped, because the inner resource  —without a locally defined variable — is not treated as a "resource" in terms of invoking its AutoCloseable.close() method.

The next code listing demonstrates the incorrect approach for instantiating "resources" in the try -with-resources statement.

Incorrect Approach for Instantiating Resources in try -with-resources Statement

When the code above is executed, the output "  InnerResource created " is seen, but no output is ever presented related to the resource's closure. This is because the instance of InnerResource was instantiated within the call to the constructor of the OuterResource class and was never assigned to its own separate variable in the resource list of the try -with-resource statement. With a real resource, the implication of this is that the resource is not closed properly.

The next code listing demonstrates the correct approach for instantiating "resources" in the try -with-resources statement.

Correct Approach for Instantiating Resources in try -with-resources Statement

When the code above is executed, the output includes both  InnerResource created   and  InnerResource closed  , because the InnerResource instance was properly assigned to a variable within the try -with-resources statement. Therefore, its close() method is properly called, even when an exception occurs during its instantiation.

The try-with-resources statement section of the Java Tutorials includes examples of correctly specifying the resources in the try -with-resources as semicolon-delimited individual variable definitions. One example shows this correct approach with java.util.zip.ZipFile and java.io.BufferedWriter . Another example shows this correct approach with instances of java.sql.Statement and java.sql.ResultSet .

The introduction of try -with-resources in JDK 7 was a welcome addition to the language that it made it easier for Java developers to write resource-safe applications that were not as likely to leak or waste resources. However, when multiple resources are declared within a single try -with-resources statement, it's important to ensure that each resource is individually instantiated and assigned to its own variable declared within the try 's resource specifier list to ensure that each and every resource is properly closed. A quick way to check this is to ensure that for n,  AutoCloseable  is implementing resources specified in the try. There should be  n-1 semicolons, separating those instantiated resources.

Published at DZone with permission of Dustin Marx , DZone MVB . See the original article here.

Opinions expressed by DZone contributors are their own.

Partner Resources

• About DZone
• Send feedback
• Community research
• Advertise with DZone

CONTRIBUTE ON DZONE

• Become a Contributor
• Core Program
• Visit the Writers' Zone
• Terms of Service
• Privacy Policy
• 3343 Perimeter Hill Drive
• Nashville, TN 37211
• [email protected]

Let's be friends:

• New Sandbox Program

Click on one of our programs below to get started coding in the sandbox!

Try Catch In Java

This tutorial covers the basics of try and catch statements in Java. It is intended as an introduction to the concept and assumes some basic Java prior knowledge.

By David Burnham

Related tutorials.

Using the Java Debugger

By Calvin Studebaker

Java in CodeHS

By Andy Bayer

• Computer Science Curriculum
• Certifications
• Professional Development
• Assignments
• Classroom Management
• Integrations
• Course Catalog
• Project Catalog
• K-12 Pathways
• State Courses
• Spanish Courses
• Hour of Code
• Digital Textbooks
• Online PD Courses
• In-Person PD Workshops
• Virtual PD Workshops
• Free PD Workshops
• Teacher Certification Prep
• Microcredentials
• PD Membership

Programming Languages

• Case Studies
• Testimonials
• Read Write Code Blog
• Read Write Code Book
• Knowledge Base
• Student Projects
• Career Center
• Privacy Center
• Privacy Policy
• Accessibility

Welcome to Java

Using try/catch blocks assignment.

• Java Arrays
• Java Strings
• Java Collection
• Java 8 Tutorial
• Java Multithreading
• Java Exception Handling
• Java Programs
• Java Project
• Java Collections Interview
• Java Interview Questions
• Spring Boot
• Java Tutorial

Overview of Java

• Introduction to Java
• The Complete History of Java Programming Language
• C++ vs Java vs Python
• How to Download and Install Java for 64 bit machine?
• Setting up the environment in Java
• How to Download and Install Eclipse on Windows?
• JDK in Java
• How JVM Works - JVM Architecture?
• Differences between JDK, JRE and JVM
• Just In Time Compiler
• Difference between JIT and JVM in Java
• Difference between Byte Code and Machine Code
• How is Java platform independent?

Basics of Java

• Java Basic Syntax
• Java Hello World Program
• Java Data Types
• Primitive data type vs. Object data type in Java with Examples
• Java Identifiers

Operators in Java

• Java Variables
• Scope of Variables In Java

Wrapper Classes in Java

Input/output in java.

• How to Take Input From User in Java?
• Scanner Class in Java
• Java.io.BufferedReader Class in Java
• Difference Between Scanner and BufferedReader Class in Java
• Ways to read input from console in Java
• System.out.println in Java
• Difference between print() and println() in Java
• Formatted Output in Java using printf()
• Fast I/O in Java in Competitive Programming

Flow Control in Java

• Decision Making in Java (if, if-else, switch, break, continue, jump)
• Java if statement with Examples
• Java if-else
• Java if-else-if ladder with Examples
• Loops in Java
• For Loop in Java
• Java while loop with Examples
• Java do-while loop with Examples
• For-each loop in Java
• Continue Statement in Java
• Break statement in Java
• Usage of Break keyword in Java
• return keyword in Java
• Java Arithmetic Operators with Examples
• Java Unary Operator with Examples

Java Assignment Operators with Examples

• Java Relational Operators with Examples
• Java Logical Operators with Examples
• Java Ternary Operator with Examples
• Bitwise Operators in Java
• Strings in Java
• String class in Java
• Java.lang.String class in Java | Set 2
• Why Java Strings are Immutable?
• StringBuffer class in Java
• StringBuilder Class in Java with Examples
• String vs StringBuilder vs StringBuffer in Java
• StringTokenizer Class in Java
• StringTokenizer Methods in Java with Examples | Set 2
• StringJoiner Class in Java
• Arrays in Java
• Arrays class in Java
• Multidimensional Arrays in Java
• Different Ways To Declare And Initialize 2-D Array in Java
• Jagged Array in Java
• Final Arrays in Java
• Reflection Array Class in Java
• util.Arrays vs reflect.Array in Java with Examples

OOPS in Java

• Object Oriented Programming (OOPs) Concept in Java
• Why Java is not a purely Object-Oriented Language?
• Classes and Objects in Java
• Naming Conventions in Java
• Java Methods

Access Modifiers in Java

• Java Constructors
• Four Main Object Oriented Programming Concepts of Java

Inheritance in Java

Abstraction in java, encapsulation in java, polymorphism in java, interfaces in java.

• 'this' reference in Java
• Inheritance and Constructors in Java
• Java and Multiple Inheritance
• Interfaces and Inheritance in Java
• Association, Composition and Aggregation in Java
• Comparison of Inheritance in C++ and Java
• abstract keyword in java
• Abstract Class in Java
• Difference between Abstract Class and Interface in Java
• Control Abstraction in Java with Examples
• Difference Between Data Hiding and Abstraction in Java
• Difference between Abstraction and Encapsulation in Java with Examples
• Difference between Inheritance and Polymorphism
• Dynamic Method Dispatch or Runtime Polymorphism in Java
• Difference between Compile-time and Run-time Polymorphism in Java

Constructors in Java

• Copy Constructor in Java
• Constructor Overloading in Java
• Constructor Chaining In Java with Examples
• Private Constructors and Singleton Classes in Java

Methods in Java

• Static methods vs Instance methods in Java
• Abstract Method in Java with Examples
• Overriding in Java
• Method Overloading in Java
• Difference Between Method Overloading and Method Overriding in Java
• Differences between Interface and Class in Java
• Functional Interfaces in Java
• Nested Interface in Java
• Marker interface in Java
• Comparator Interface in Java with Examples
• Need of Wrapper Classes in Java
• Different Ways to Create the Instances of Wrapper Classes in Java
• Character Class in Java
• Java.Lang.Byte class in Java
• Java.Lang.Short class in Java
• Java.lang.Integer class in Java
• Java.Lang.Long class in Java
• Java.Lang.Float class in Java
• Java.Lang.Double Class in Java
• Java.lang.Boolean Class in Java
• Autoboxing and Unboxing in Java
• Type conversion in Java with Examples

Keywords in Java

• Java Keywords
• Important Keywords in Java
• Super Keyword in Java
• final Keyword in Java
• static Keyword in Java
• enum in Java
• transient keyword in Java
• volatile Keyword in Java
• final, finally and finalize in Java
• Public vs Protected vs Package vs Private Access Modifier in Java
• Access and Non Access Modifiers in Java

Memory Allocation in Java

• Java Memory Management
• How are Java objects stored in memory?
• Stack vs Heap Memory Allocation
• How many types of memory areas are allocated by JVM?
• Garbage Collection in Java
• Types of JVM Garbage Collectors in Java with implementation details
• Memory leaks in Java
• Java Virtual Machine (JVM) Stack Area

Classes of Java

• Understanding Classes and Objects in Java
• Singleton Method Design Pattern in Java
• Object Class in Java
• Inner Class in Java
• Throwable Class in Java with Examples

Packages in Java

• Packages In Java
• How to Create a Package in Java?
• Java.util Package in Java
• Java.lang package in Java
• Java.io Package in Java
• Java Collection Tutorial

Exception Handling in Java

• Exceptions in Java
• Types of Exception in Java with Examples
• Checked vs Unchecked Exceptions in Java
• Java Try Catch Block
• Flow control in try catch finally in Java
• throw and throws in Java
• User-defined Custom Exception in Java
• Chained Exceptions in Java
• Null Pointer Exception In Java
• Exception Handling with Method Overriding in Java
• Multithreading in Java
• Lifecycle and States of a Thread in Java
• Java Thread Priority in Multithreading
• Main thread in Java
• Java.lang.Thread Class in Java
• Runnable interface in Java
• Naming a thread and fetching name of current thread in Java
• What does start() function do in multithreading in Java?
• Difference between Thread.start() and Thread.run() in Java
• Thread.sleep() Method in Java With Examples
• Synchronization in Java
• Importance of Thread Synchronization in Java
• Method and Block Synchronization in Java
• Lock framework vs Thread synchronization in Java
• Difference Between Atomic, Volatile and Synchronized in Java
• Deadlock in Java Multithreading
• Deadlock Prevention And Avoidance
• Difference Between Lock and Monitor in Java Concurrency
• Reentrant Lock in Java

File Handling in Java

• Java.io.File Class in Java
• Java Program to Create a New File
• Different ways of Reading a text file in Java
• Java Program to Write into a File
• Delete a File Using Java
• File Permissions in Java
• FileWriter Class in Java
• Java.io.FileDescriptor in Java
• Java.io.RandomAccessFile Class Method | Set 1
• Regular Expressions in Java
• Regex Tutorial - How to write Regular Expressions?
• Matcher pattern() method in Java with Examples
• Pattern pattern() method in Java with Examples
• Quantifiers in Java
• java.lang.Character class methods | Set 1
• Java IO : Input-output in Java with Examples
• Java.io.Reader class in Java
• Java.io.Writer Class in Java
• Java.io.FileInputStream Class in Java
• FileOutputStream in Java
• Java.io.BufferedOutputStream class in Java
• Java Networking
• TCP/IP Model
• User Datagram Protocol (UDP)
• Differences between IPv4 and IPv6
• Difference between Connection-oriented and Connection-less Services
• Socket Programming in Java
• java.net.ServerSocket Class in Java
• URL Class in Java with Examples

JDBC - Java Database Connectivity

• Introduction to JDBC (Java Database Connectivity)
• JDBC Drivers
• Establishing JDBC Connection in Java
• Types of Statements in JDBC
• JDBC Tutorial
• Java 8 Features - Complete Tutorial

Operators constitute the basic building block of any programming language. Java too provides many types of operators which can be used according to the need to perform various calculations and functions, be it logical, arithmetic, relational, etc. They are classified based on the functionality they provide.

Types of Operators: 

• Arithmetic Operators
• Unary Operators
• Assignment Operator
• Relational Operators
• Logical Operators
• Ternary Operator
• Bitwise Operators
• Shift Operators

This article explains all that one needs to know regarding Assignment Operators. 

Assignment Operators

These operators are used to assign values to a variable. The left side operand of the assignment operator is a variable, and the right side operand of the assignment operator is a value. The value on the right side must be of the same data type of the operand on the left side. Otherwise, the compiler will raise an error. This means that the assignment operators have right to left associativity, i.e., the value given on the right-hand side of the operator is assigned to the variable on the left. Therefore, the right-hand side value must be declared before using it or should be a constant. The general format of the assignment operator is, 

Types of Assignment Operators in Java

The Assignment Operator is generally of two types. They are:

1. Simple Assignment Operator: The Simple Assignment Operator is used with the “=” sign where the left side consists of the operand and the right side consists of a value. The value of the right side must be of the same data type that has been defined on the left side.

2. Compound Assignment Operator: The Compound Operator is used where +,-,*, and / is used along with the = operator.

Let’s look at each of the assignment operators and how they operate: 

1. (=) operator: 

This is the most straightforward assignment operator, which is used to assign the value on the right to the variable on the left. This is the basic definition of an assignment operator and how it functions. 

Syntax:  

Example:  

2. (+=) operator: 

This operator is a compound of ‘+’ and ‘=’ operators. It operates by adding the current value of the variable on the left to the value on the right and then assigning the result to the operand on the left. 

Note: The compound assignment operator in Java performs implicit type casting. Let’s consider a scenario where x is an int variable with a value of 5. int x = 5; If you want to add the double value 4.5 to the integer variable x and print its value, there are two methods to achieve this: Method 1: x = x + 4.5 Method 2: x += 4.5 As per the previous example, you might think both of them are equal. But in reality, Method 1 will throw a runtime error stating the “i ncompatible types: possible lossy conversion from double to int “, Method 2 will run without any error and prints 9 as output.

Reason for the Above Calculation

Method 1 will result in a runtime error stating “incompatible types: possible lossy conversion from double to int.” The reason is that the addition of an int and a double results in a double value. Assigning this double value back to the int variable x requires an explicit type casting because it may result in a loss of precision. Without the explicit cast, the compiler throws an error. Method 2 will run without any error and print the value 9 as output. The compound assignment operator += performs an implicit type conversion, also known as an automatic narrowing primitive conversion from double to int . It is equivalent to x = (int) (x + 4.5) , where the result of the addition is explicitly cast to an int . The fractional part of the double value is truncated, and the resulting int value is assigned back to x . It is advisable to use Method 2 ( x += 4.5 ) to avoid runtime errors and to obtain the desired output.

Same automatic narrowing primitive conversion is applicable for other compound assignment operators as well, including -= , *= , /= , and %= .

3. (-=) operator: 

This operator is a compound of ‘-‘ and ‘=’ operators. It operates by subtracting the variable’s value on the right from the current value of the variable on the left and then assigning the result to the operand on the left. 

4. (*=) operator:

 This operator is a compound of ‘*’ and ‘=’ operators. It operates by multiplying the current value of the variable on the left to the value on the right and then assigning the result to the operand on the left. 

5. (/=) operator: 

This operator is a compound of ‘/’ and ‘=’ operators. It operates by dividing the current value of the variable on the left by the value on the right and then assigning the quotient to the operand on the left. 

6. (%=) operator: 

This operator is a compound of ‘%’ and ‘=’ operators. It operates by dividing the current value of the variable on the left by the value on the right and then assigning the remainder to the operand on the left. 

Please Login to comment...

Similar reads.

• Java-Operators
• Otter.ai vs. Fireflies.ai: Which AI Transcribes Meetings More Accurately?
• Google Chrome Will Soon Let You Talk to Gemini In The Address Bar
• AI Interior Designer vs. Virtual Home Decorator: Which AI Can Transform Your Home Into a Pinterest Dream Faster?
• Top 10 Free Webclipper on Chrome Browser in 2024
• 30 OOPs Interview Questions and Answers (2024)

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Java Tutorial

Java methods, java classes, java file handling, java how to, java reference, java examples, java operators.

Operators are used to perform operations on variables and values.

In the example below, we use the + operator to add together two values:

Try it Yourself »

Although the + operator is often used to add together two values, like in the example above, it can also be used to add together a variable and a value, or a variable and another variable:

Java divides the operators into the following groups:

• Arithmetic operators
• Assignment operators
• Comparison operators
• Logical operators
• Bitwise operators

Arithmetic Operators

Arithmetic operators are used to perform common mathematical operations.

Advertisement

Java Assignment Operators

Assignment operators are used to assign values to variables.

In the example below, we use the assignment operator ( = ) to assign the value 10 to a variable called x :

The addition assignment operator ( += ) adds a value to a variable:

A list of all assignment operators:

Java Comparison Operators

Comparison operators are used to compare two values (or variables). This is important in programming, because it helps us to find answers and make decisions.

The return value of a comparison is either true or false . These values are known as Boolean values , and you will learn more about them in the Booleans and If..Else chapter.

In the following example, we use the greater than operator ( > ) to find out if 5 is greater than 3:

Java Logical Operators

You can also test for true or false values with logical operators.

Logical operators are used to determine the logic between variables or values:

Java Bitwise Operators

Bitwise operators are used to perform binary logic with the bits of an integer or long integer.

Note: The Bitwise examples above use 4-bit unsigned examples, but Java uses 32-bit signed integers and 64-bit signed long integers. Because of this, in Java, ~5 will not return 10. It will return -6. ~00000000000000000000000000000101 will return 11111111111111111111111111111010

In Java, 9 >> 1 will not return 12. It will return 4. 00000000000000000000000000001001 >> 1 will return 00000000000000000000000000000100

Test Yourself With Exercises

Multiply 10 with 5 , and print the result.

Start the Exercise

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

• Blogs by Topic

The IntelliJ IDEA Blog

IntelliJ IDEA – the Leading Java and Kotlin IDE, by JetBrains

• Twitter Twitter
• Facebook Facebook
• Youtube Youtube

Easy Hacks: How to Handle Exceptions in Java

Previously, we explored how to throw exceptions in Java to signal error conditions in our code. But throwing exceptions is only half the story. To build robust and reliable applications, we also need to know how to handle them effectively.

In this post, we’ll explore how you can handle exceptions in Java, and we’ll also show you some techniques to manage expected and unexpected events in your projects.

Understanding exceptions

Exceptions are objects that represent errors or unexpected events that occur during program execution. When an exception is thrown, the normal flow of control is interrupted, and the program transfers control to an appropriate exception handler.

Java defines three main categories of exceptions:

• Checked exceptions – These are exceptions that the compiler requires you to handle explicitly. They typically represent recoverable errors, such as files not being found ( FileNotFoundException or IOException ), network connection issues, or business logic errors that you will want to recover from.
• Unchecked exceptions – These exceptions, also known as runtime exceptions, don’t require explicit handling. They often represent programming errors, such as attempting to access a null object ( NullPointerException ), or an invalid array index ( ArrayIndexOutOfBoundsException ).
• Errors – These exceptions are typically used by the JVM, like OutOfMemoryError , and indicate severe problems like the JVM being unable to allocate memory for an object. Recovery from such situations is generally not possible. 

The Java platform provides a rich library of exception classes to signal errors in your code. Additionally, you can create custom exception types to indicate interruptions in the normal application flow.

Methods in code that can throw checked exceptions must be annotated with the throws syntax to make information available to the caller. Either by adding throws to their own method signature (signifying the caller could also throw checked exceptions), or catch the exception and handle it. You could also re-throw the exception, as we will see later. What’s more, tools like IntelliJ IDEA can analyze whether exceptions are handled (or not), and suggest a proper resolution.

Note: Make sure to read How to Throw Java Exceptions to get a better understanding of the topic.

Handling exceptions with try...catch blocks

The try...catch block is the primary mechanism for handling Java exceptions. Code that might throw an exception is placed within the try block, and the catch block handles the exception or its inheritors as appropriate.

Here’s the basic syntax:

For example, the following code attempts to read data from a file and catches a potential FileNotFoundException :

You can have multiple catch blocks to handle different types of exceptions:

The finally block is an optional part of the try...catch construct. It executes regardless of whether an exception is thrown, unless it’s an exception that terminates the JVM, such as the one thrown after invoking System.exit() . The finally block is ideal for cleanup tasks like closing files, streams, database connections, or releasing other resources. Note that try...finally is also possible, without catch .

While the try...catch...finally construct provides a robust mechanism for handling exceptions and ensuring resource cleanup, a more concise and streamlined approach exists: try...with...resources . Let’s see how it works!

Resource cleanup with try...with...resources

Java 7 introduced the try...with...resources construct, simplifying exception handling when working with resources that need to be closed. Files, streams, database connections, and other closable resources will be closed automatically, even if an exception occurs, eliminating the need for explicit cleanup in a finally block.

Any object that implements java.lang.AutoCloseable , which includes all objects that implement java.io.Closeable , can be used as a resource.

Here’s the syntax for try...with...resources :

The following example reads the first line from a file. It uses an instance of FileReader and BufferedReader to read data from the file. FileReader is a resource that must be closed after the program is finished using it in order to prevent resource leaks and allow other programs to access the file:

In this example, the FileReader used by the BufferedReader resource is automatically closed when the try block finishes, regardless of whether an exception occurs or not. This eliminates the need for a finally block to explicitly close the reader. 

In IntelliJ IDEA, use the Fix Anything action ( Alt+Enter on Windows/Linux, ⌥⏎ on macOS) after the IDE warns about using a closable resource without try...with...resources to automatically wrap the resource with this construct:

As a more elaborate example, consider using a JDBC database connection, executing a query on it, and working with the result set. The Connection , PreparedStatement , and ResultSet objects being used all have to be closed in the finally block. Here’s what that code would look like with try...catch...finally :

Yikes! Here’s some equivalent code with try...with...resources , where the three closable objects are instantiated in the try statement:

Now that’s much more readable! Note that there is a difference between this example and the original code: the try...with...resources version doesn’t catch exceptions from the calls to close() on the resource. If you also need to catch those exceptions, you’ll have to resort to using try...finally and catch the exception when calling close() in the finally block, much like in the original code.

Exception propagation

When an exception is thrown within a method and not caught locally, it is propagated up the call stack to the calling method. This process continues until a matching catch block is found or the exception reaches the top of the call stack, causing the program to terminate. Exception propagation allows for centralized exception handling, where exceptions can be caught and dealt with at a higher level in the application.

Here’s an example illustrating exception propagation:

In this example, methodB() attempts to open a non-existent file, throwing a FileNotFoundException . Since methodB() doesn’t handle the exception, it is propagated to methodA() , which also doesn’t have a catch block. The exception is further propagated to the main method, which catches the exception and prints an error message.

This demonstrates how exceptions can be handled at different call stack levels, allowing for flexible and centralized error management.

Re-throwing exceptions

In some cases, you might want to catch an exception within a method but then re-throw it to be handled further up the call stack. This can be useful in several situations:

• Performing additional actions before passing the exception – You might want to log the exception, perform some cleanup, or add additional context before letting another part of the program handle it.
• Converting to a more specific exception type – You might catch a general exception and then re-throw it as a more specific exception type that provides more information about the error.
• Hide implementation-specific examples – Imagine building a framework to store data in different database systems. Instead of surfacing exceptions for specific database engines, your framework may catch all those and throw a common exception type from your framework.

Here’s an example of re-throwing an exception:

In this example, the processFile() method catches a FileNotFoundException but then re-throws it. This allows the calling method to handle the exception if needed, while still logging the error message within processFile() itself.

When re-throwing exceptions, you can re-throw the same exception object or create a new exception. If you create a new exception, you can include the original exception as the cause so methods up the call stack still have access to the original exception:

Best practices for exception handling

When handling exceptions, there are three key best practices. Let’s start with the most important: Don’t leave catch blocks empty . While it’s tempting to write code that is more “fire-and-forget”, and Java requires you to catch checked exceptions, you will lose out on valuable information and cause problems for your application. Don’t do this! At a minimum, log your exceptions so you can potentially handle them better based on the information in the logs.

With Java Exception Breakpoints in IntelliJ IDEA, you can have the debugger suspend program execution on any caught/uncaught exception, which may help you identify exceptions handled in an empty catch block. You can enable/disable Java Exception breakpoints for all exceptions or specific exception types using the Run | View Breakpoints menu ( Ctrl+Shift+F8 on Windows/Linux, ⌘⇧F8 on macOS).

When debugging, IntelliJ IDEA will suspend your program whenever an exception that matches the breakpoint settings is thrown:

Another best practice would be to handle exceptions at the appropriate level . Catch exceptions at the level in the call stack where you can meaningfully handle them. Don’t catch exceptions just for the sake of catching them. If you have a utility function to read a file, you can catch IOException directly if it makes sense. However, it might be more meaningful to handle file-related exceptions at a higher level where the caller can decide how to proceed (e.g. retry, or prompt the user to provide a different file).

Lastly, avoid catching overly broad exceptions . Be specific about the exceptions you catch. Avoid catching generic exceptions like Exception, as this can mask other potential errors.

In this post, we’ve explored the essential aspects of exception handling in Java. We learned how to use try...catch blocks to gracefully handle checked and unchecked exceptions, ensuring that our programs don’t crash unexpectedly. With try...catch...finally and try...with...resources , it’s possible to gracefully close resources like files, streams, database connections, and more. We also looked at exception propagation and re-throwing exceptions.

Remember to ensure there are no empty catch blocks, at the minimum log exceptions, handle exceptions at the appropriate level, and avoid catching overly broad exceptions. With these practices in mind, you can write cleaner, more maintainable, and user-friendly Java code.

Give it a try in the most loved Java IDE!

Subscribe to IntelliJ IDEA Blog updates

By submitting this form, I agree that JetBrains s.r.o. ("JetBrains") may use my name, email address, and location data to send me newsletters, including commercial communications, and to process my personal data for this purpose. I agree that JetBrains may process said data using third-party services for this purpose in accordance with the JetBrains Privacy Policy . I understand that I can revoke this consent at any time in my profile . In addition, an unsubscribe link is included in each email.

Thanks, we've got you!

Discover more

Java Frameworks You Must Know in 2024

Many developers trust Java worldwide because it is adaptable, secure, and versatile, making it perfect for developing various applications across multiple platforms. It also stands out for its readability and scalability. What are frameworks? Why do you need them? Since Java has a long history…

Java Annotated Monthly – April 2024

Welcome to this month’s Java Annotated Monthly, where we’ll cover the most prominent updates, news, and releases in March. This edition is truly special because it introduces a new section – Featured content, where we invite influential people from the industry to share a personal selection of inter…

Java 22 and IntelliJ IDEA

Java 22 is here, fully supported by IntelliJ IDEA 2024.1, allowing you to use these features now! Java 22 has something for all - from new developers to Java experts, features related to performance and security for big organizations to those who like working with bleeding edge technology, from addi…

Getting Started with Databases in IntelliJ IDEA 

Have you ever wondered how IntelliJ IDEA handles databases? Well, today is the perfect opportunity to find out in our database tutorial on initial setups and first steps.   All of the features you’ll need when working with databases are available out of the box in IntelliJ IDEA Ultimate…

01 Career Opportunities

• Top 50 Java Interview Questions and Answers
• Java Developer Salary Guide in India – For Freshers & Experienced

02 Beginner

• Hierarchical Inheritance in Java
• Arithmetic operators in Java
• Unary operator in Java
• Relational operators in Java

Assignment operator in Java

• Logical operators in Java
• Primitive Data Types in Java
• Multiple Inheritance in Java
• Parameterized Constructor in Java
• Constructor Chaining in Java
• What is a Bitwise Operator in Java? Type, Example and More
• Constructor Overloading in Java
• Ternary Operator in Java
• For Loop in Java: Its Types and Examples
• Best Java Developer Roadmap 2024
• While Loop in Java
• What are Copy Constructors In Java? Explore Types,Examples & Use
• Do-While Loop in Java
• Hybrid Inheritance in Java
• Single Inheritance in Java
• Top 10 Reasons to know why Java is Important?
• What is Java? A Beginners Guide to Java
• Differences between JDK, JRE, and JVM: Java Toolkit
• Variables in Java: Local, Instance and Static Variables
• Data Types in Java - Primitive and Non-Primitive Data Types
• Conditional Statements in Java: If, If-Else and Switch Statement
• What are Operators in Java - Types of Operators in Java ( With Examples )
• Java VS Python
• Looping Statements in Java - For, While, Do-While Loop in Java
• Jump Statements in JAVA - Types of Statements in JAVA (With Examples)
• Java Arrays: Single Dimensional and Multi-Dimensional Arrays
• What is String in Java - Java String Types and Methods (With Examples)

03 Intermediate

• OOPs Concepts in Java: Encapsulation, Abstraction, Inheritance, Polymorphism
• What is Class in Java? - Objects and Classes in Java {Explained}
• Access Modifiers in Java: Default, Private, Public, Protected
• Constructors in Java: Types of Constructors with Examples
• Polymorphism in Java: Compile time and Runtime Polymorphism
• Abstract Class in Java: Concepts, Examples, and Usage
• What is Inheritance in Java: Types of Inheritance in Java
• Exception handling in Java: Try, Catch, Finally, Throw and Throws

04 Training Programs

• Java Programming Course
• C++ Programming Course
• MERN: Full-Stack Web Developer Certification Training
• Data Structures and Algorithms Training
• Assignment Operator In Ja..

Java Programming For Beginners Free Course

Assignment operators in java: an overview.

We already discussed the Types of Operators in the previous tutorial Java. In this Java tutorial , we will delve into the different types of assignment operators in Java, and their syntax, and provide examples for better understanding. Because Java is a flexible and widely used programming language. Assignment operators play a crucial role in manipulating and assigning values to variables. To further enhance your understanding and application of Java assignment operator's concepts, consider enrolling in the best Java Certification Course .

What are the Assignment Operators in Java?

Assignment operators in Java are used to assign values to variables . They are classified into two main types: simple assignment operator and compound assignment operator.

The general syntax for a simple assignment statement is:

And for a compound assignment statement:

Read More - Advanced Java Interview Questions

Types of Assignment Operators in Java

• Simple Assignment Operator: The Simple Assignment Operator is used with the "=" sign, where the operand is on the left side and the value is on the right. The right-side value must be of the same data type as that defined on the left side.
• Compound Assignment Operator:  Compound assignment operators combine arithmetic operations with assignments. They provide a concise way to perform an operation and assign the result to the variable in one step. The Compound Operator is utilized when +,-,*, and / are used in conjunction with the = operator.

1. Simple Assignment Operator (=):

The equal sign (=) is the basic assignment operator in Java. It is used to assign the value on the right-hand side to the variable on the left-hand side.

Explanation

2. addition assignment operator (+=) :, 3. subtraction operator (-=):, 4. multiplication operator (*=):.

Read More - Java Developer Salary

5. Division Operator (/=):

6. modulus assignment operator (%=):, example of assignment operator in java.

Let's look at a few examples in our Java Playground to illustrate the usage of assignment operators in Java:

• Unary Operator in Java
• Arithmetic Operators in Java
• Relational Operators in Java
• Logical Operators in Java

Q1. Can I use multiple assignment operators in a single statement?

Q2. are there any other compound assignment operators in java, q3. how many types of assignment operators.

• 1. (=) operator
• 1. (+=) operator
• 2. (-=) operator
• 3. (*=) operator
• 4. (/=) operator
• 5. (%=) operator

About Author

We use cookies to make interactions with our websites and services easy and meaningful. Please read our Privacy Policy for more details.

Java Tutorial

Control statements, java object class, java inheritance, java polymorphism, java abstraction, java encapsulation, java oops misc.

• Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Transact-SQL

Reinforcement Learning

R Programming

React Native

Python Design Patterns

Python Pillow

Python Turtle

Preparation

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

Cloud Computing

Data Science

Machine Learning

B.Tech / MCA

Data Structures

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

C Programming

Control System

Data Mining

Data Warehouse