Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to Java
The Complete Hierarchy Tree
All exceptions and errors in Java form a class hierarchy rooted at Throwable:
Example
java.lang.Object
│
▼
java.lang.Throwable
/ \
/ \
java.lang.Error java.lang.Exception
│ │
┌───────────────┼───────────────┐ │
│ │ │ ├── IOException
│ │ │ ├── SQLException
VirtualMachineError │ LinkageError ├── ClassNotFoundException
│ ThreadDeath │ ├── InterruptedException
│ │ ClassNotFound ├── ReflectiveOperationException
├── StackOverflow DefError │
│ Error │ └── RuntimeException
│ NoClassDef │
├── OutOfMemory FoundError ┌────────┼─────────────┐
│ Error │ │ │
│ NullPointer Arithmetic ClassCast
└── InternalError Exception Exception Exception
│
IndexOutOf IllegalArgument
BoundsExc. Exception
│ │
ArrayIndex NumberFormat
OutOfBounds Exception
Exception
Understanding Each Level
Level 1: java.lang.Object
Every class in Java extends Object. Throwable is no exception.
Level 2: java.lang.Throwable
The root of all errors and exceptions. Only objects of type Throwable (or its subclasses) can be thrown with the throw keyword and caught with catch.
java example
public class ThrowableDemo {
public static void main(String[] args) {
try {
// You can catch Throwable (but usually shouldn't)
throw new Throwable("I am a Throwable");
} catch (Throwable t) {
System.out.println("Class: " + t.getClass().getName());
System.out.println("Message: " + t.getMessage());
System.out.println("Is Exception? " + (t instanceof Exception));
System.out.println("Is Error? " + (t instanceof Error));
}
}
}Output:
Example
Class: java.lang.Throwable
Message: I am a Throwable
Is Exception? false
Is Error? false
Level 3a: java.lang.Error (DO NOT CATCH)
Errors represent serious problems that an application should NOT attempt to handle. They're typically caused by the JVM environment.
Example
public class ErrorExamples {
// StackOverflowError - infinite recursion
static void infiniteRecursion() {
infiniteRecursion(); // No base case!
}
// OutOfMemoryError - heap exhaustion
static void exhaustMemory() {
java.util.List<int[]> list = new java.util.ArrayList<>();
while (true) {
list.add(new int[1_000_000]); // Keep allocating
}
}
public static void main(String[] args) {
// Example 1: StackOverflowError
try {
infiniteRecursion();
} catch (StackOverflowError e) {
System.out.println("StackOverflowError caught!");
System.out.println("(But you shouldn't normally catch this)");
}
// Example 2: OutOfMemoryError
try {
exhaustMemory();
} catch (OutOfMemoryError e) {
System.out.println("OutOfMemoryError caught!");
System.out.println("(Program state is unreliable now)");
}
}
}
Output:
Example
StackOverflowError caught!
(But you shouldn't normally catch this)
OutOfMemoryError caught!
(Program state is unreliable now)
Common Errors:
| Error | Cause |
|---|---|
StackOverflowError | Infinite recursion or very deep call stack |
OutOfMemoryError | JVM cannot allocate more heap memory |
VirtualMachineError | JVM is broken or out of resources |
NoClassDefFoundError | Class was available at compile-time but not at runtime |
ExceptionInInitializerError | Static initializer threw an exception |
LinkageError | Class dependency issues |
Level 3b: java.lang.Exception (HANDLE THESE)
Exceptions represent conditions that a program should handle. They branch into two categories:
Checked vs Unchecked Exceptions
Example
Exception
/ \
Checked Exceptions RuntimeException (Unchecked)
(Compile-time) (Runtime)
│ │
┌────┼────┐ ┌─────┼──────┐
│ │ │ │ │ │
IOExc SQLExc ClassNF NPE ArithE ClassCast
Checked Exceptions (Compile-Time)
The compiler forces you to handle these. If you don't use try-catch or declare throws, the code won't compile.
java example
import java.io.*;
import java.sql.*;
public class CheckedExceptions {
// ❌ WON'T COMPILE without throws or try-catch
// static void readFile() {
// FileReader reader = new FileReader("test.txt"); // IOException
// }
// ✅ Option 1: Declare with throws
static void readFile1() throws IOException {
FileReader reader = new FileReader("test.txt");
reader.close();
}
// ✅ Option 2: Handle with try-catch
static void readFile2() {
try {
FileReader reader = new FileReader("test.txt");
reader.close();
} catch (IOException e) {
System.out.println("Cannot read file: " + e.getMessage());
}
}
public static void main(String[] args) {
readFile2();
// Common checked exceptions:
System.out.println("Common Checked Exceptions:");
System.out.println(" - IOException (file/network I/O problems)");
System.out.println(" - SQLException (database problems)");
System.out.println(" - ClassNotFoundException (reflection)");
System.out.println(" - InterruptedException (thread interruption)");
System.out.println(" - FileNotFoundException (specific file missing)");
System.out.println(" - ParseException (date/number parsing)");
}
}Output:
Example
Cannot read file: test.txt (No such file or directory)
Common Checked Exceptions:
- IOException (file/network I/O problems)
- SQLException (database problems)
- ClassNotFoundException (reflection)
- InterruptedException (thread interruption)
- FileNotFoundException (specific file missing)
- ParseException (date/number parsing)
Unchecked Exceptions (Runtime Exceptions)
These extend RuntimeException. The compiler does NOT force you to handle them. They usually indicate programming bugs.
Example
public class UncheckedExceptions {
public static void main(String[] args) {
System.out.println("=== Common Unchecked Exceptions ===\n");
// 1. NullPointerException
try {
String str = null;
int len = str.length();
} catch (NullPointerException e) {
System.out.println("1. NullPointerException: " + e.getMessage());
}
// 2. ArrayIndexOutOfBoundsException
try {
int[] arr = {1, 2, 3};
int val = arr[5];
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("2. ArrayIndexOutOfBoundsException: " + e.getMessage());
}
// 3. ArithmeticException
try {
int result = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("3. ArithmeticException: " + e.getMessage());
}
// 4. ClassCastException
try {
Object obj = "Hello";
Integer num = (Integer) obj;
} catch (ClassCastException e) {
System.out.println("4. ClassCastException: " + e.getMessage());
}
// 5. NumberFormatException
try {
int num = Integer.parseInt("abc");
} catch (NumberFormatException e) {
System.out.println("5. NumberFormatException: " + e.getMessage());
}
// 6. IllegalArgumentException
try {
Thread.sleep(-1);
} catch (IllegalArgumentException e) {
System.out.println("6. IllegalArgumentException: " + e.getMessage());
} catch (InterruptedException e) {
// Required for Thread.sleep
}
// 7. IllegalStateException
try {
java.util.Iterator<String> it = new java.util.ArrayList<String>().iterator();
it.remove(); // Can't remove before next()
} catch (IllegalStateException e) {
System.out.println("7. IllegalStateException: " + e.getMessage());
}
// 8. StringIndexOutOfBoundsException
try {
String s = "Hello";
char c = s.charAt(10);
} catch (StringIndexOutOfBoundsException e) {
System.out.println("8. StringIndexOutOfBoundsException: " + e.getMessage());
}
}
}
Output:
| 1. NullPointerException | Cannot invoke "String.length()" because "str" is null |
| 2. ArrayIndexOutOfBoundsException | Index 5 out of bounds for length 3 |
| 3. ArithmeticException | / by zero |
| 4. ClassCastException | class java.lang.String cannot be cast to class java.lang.Integer |
| 5. NumberFormatException | For input string: "abc" |
| 6. IllegalArgumentException | timeout value is negative |
| 7. IllegalStateException | null |
| 8. StringIndexOutOfBoundsException | String index out of range: 10 |
Why Two Categories?
| Aspect | Checked | Unchecked |
|---|---|---|
| Extends | Exception (not RuntimeException) | RuntimeException |
| Compiler check | YES — must handle or declare | NO — optional handling |
| Typical cause | External factors (files, network, DB) | Programming bugs |
| When to use | Things beyond your control | Preventable logical errors |
| Examples | IOException, SQLException | NullPointerException, ClassCastException |
| Fix approach | Handle gracefully | Fix the code logic |
Exploring the Hierarchy Programmatically
Example
public class HierarchyExplorer {
public static void main(String[] args) {
System.out.println("=== Exception Hierarchy Explorer ===\n");
// Check various exceptions
Exception[] exceptions = {
new java.io.IOException("IO"),
new RuntimeException("Runtime"),
new NullPointerException("NPE"),
new java.io.FileNotFoundException("FNF"),
new IllegalArgumentException("IAE"),
new NumberFormatException("NFE"),
new ArrayIndexOutOfBoundsException("AIOOBE"),
};
for (Exception e : exceptions) {
System.out.printf("%-40s | Checked: %-5s | Parent: %s%n",
e.getClass().getSimpleName(),
isChecked(e) ? "YES" : "NO",
e.getClass().getSuperclass().getSimpleName());
}
System.out.println("\n--- Inheritance Chain for NumberFormatException ---");
printHierarchy(new NumberFormatException());
System.out.println("\n--- Inheritance Chain for FileNotFoundException ---");
printHierarchy(new java.io.FileNotFoundException());
}
static boolean isChecked(Exception e) {
return !(e instanceof RuntimeException);
}
static void printHierarchy(Object obj) {
Class<?> clazz = obj.getClass();
int depth = 0;
while (clazz != null) {
System.out.println(" ".repeat(depth) + "└── " + clazz.getName());
clazz = clazz.getSuperclass();
depth++;
}
}
}
Output:
| IOException | Checked | YES | Parent: Exception |
| RuntimeException | Checked | NO | Parent: Exception |
| NullPointerException | Checked | NO | Parent: RuntimeException |
| FileNotFoundException | Checked | YES | Parent: IOException |
| IllegalArgumentException | Checked | NO | Parent: RuntimeException |
| NumberFormatException | Checked | NO | Parent: IllegalArgumentException |
| ArrayIndexOutOfBoundsException | Checked | NO | Parent: IndexOutOfBoundsException |
Throwable Class Methods
All exceptions inherit these methods from Throwable:
java example
public class ThrowableMethods {
public static void main(String[] args) {
try {
methodA();
} catch (Exception e) {
// 1. getMessage() - returns the detail message
System.out.println("getMessage(): " + e.getMessage());
// 2. toString() - class name + message
System.out.println("toString(): " + e.toString());
// 3. getCause() - returns the cause (chained exception)
System.out.println("getCause(): " + e.getCause());
// 4. getStackTrace() - array of stack trace elements
System.out.println("\nStack Trace Elements:");
for (StackTraceElement elem : e.getStackTrace()) {
System.out.printf(" %s.%s() at line %d%n",
elem.getClassName(), elem.getMethodName(),
elem.getLineNumber());
}
// 5. printStackTrace() - prints to System.err
System.out.println("\nprintStackTrace():");
e.printStackTrace(System.out); // Redirect to stdout for demo
}
}
static void methodA() {
methodB();
}
static void methodB() {
// Exception chaining
try {
int result = 10 / 0;
} catch (ArithmeticException cause) {
throw new RuntimeException("Calculation failed", cause);
}
}
}Output:
| getMessage() | Calculation failed |
| toString() | java.lang.RuntimeException: Calculation failed |
| getCause() | java.lang.ArithmeticException: / by zero |
| java.lang.RuntimeException | Calculation failed |
| at ThrowableMethods.methodB(ThrowableMethods.java | 34) |
| at ThrowableMethods.methodA(ThrowableMethods.java | 28) |
| at ThrowableMethods.main(ThrowableMethods.java | 5) |
| Caused by | java.lang.ArithmeticException: / by zero |
| at ThrowableMethods.methodB(ThrowableMethods.java | 32) |
Catching at Different Hierarchy Levels
java example
import java.io.*;
public class CatchHierarchy {
public static void main(String[] args) {
// A catch block catches the specified type AND all its subclasses
// catch(Exception e) catches ALL exceptions
// catch(RuntimeException e) catches all unchecked exceptions
// catch(IOException e) catches IOException and FileNotFoundException
System.out.println("=== Polymorphic Exception Catching ===\n");
// Test 1: Catching with parent type
try {
throw new FileNotFoundException("test.txt not found");
} catch (IOException e) { // Catches FileNotFoundException too!
System.out.println("Caught as IOException: " + e.getClass().getSimpleName());
System.out.println(" Message: " + e.getMessage());
System.out.println(" Is FileNotFoundException? " + (e instanceof FileNotFoundException));
}
System.out.println();
// Test 2: Catching with grandparent type
try {
throw new NumberFormatException("bad number");
} catch (Exception e) { // Catches everything!
System.out.println("Caught as Exception: " + e.getClass().getSimpleName());
System.out.println(" Is RuntimeException? " + (e instanceof RuntimeException));
System.out.println(" Is IllegalArgumentException? " + (e instanceof IllegalArgumentException));
System.out.println(" Is NumberFormatException? " + (e instanceof NumberFormatException));
}
}
}Output:
| Caught as IOException | FileNotFoundException |
| Message | test.txt not found |
| Caught as Exception | NumberFormatException |
Practical Application: Exception Hierarchy in Method Design
Example
import java.util.*;
public class ExceptionDesign {
// Use specific exception types for different error conditions
static double calculateAverage(int[] numbers) {
if (numbers == null) {
throw new NullPointerException("Array cannot be null");
}
if (numbers.length == 0) {
throw new IllegalArgumentException("Array cannot be empty");
}
int sum = 0;
for (int n : numbers) {
sum += n;
}
return (double) sum / numbers.length;
}
public static void main(String[] args) {
// Test cases demonstrating hierarchy-based catching
Object[][] tests = {
{null, "null array"},
{new int[]{}, "empty array"},
{new int[]{10, 20, 30}, "valid array"},
};
for (Object[] test : tests) {
int[] arr = (int[]) test[0];
String desc = (String) test[1];
try {
double avg = calculateAverage(arr);
System.out.printf("%-15s → Average: %.2f%n", desc, avg);
} catch (NullPointerException e) {
System.out.printf("%-15s → NULL ERROR: %s%n", desc, e.getMessage());
} catch (IllegalArgumentException e) {
System.out.printf("%-15s → ARGUMENT ERROR: %s%n", desc, e.getMessage());
} catch (RuntimeException e) {
// Catch-all for any other runtime exception
System.out.printf("%-15s → RUNTIME ERROR: %s%n", desc, e.getMessage());
}
}
}
}
Output:
| null array | NULL ERROR: Array cannot be null |
| empty array | ARGUMENT ERROR: Array cannot be empty |
| valid array | Average: 20.00 |
Common Mistakes
1. Catching Throwable or Error
java example
// ❌ BAD: Don't catch Throwable
try {
// code
} catch (Throwable t) {
// Catches Errors too! You can't recover from OutOfMemoryError
}
// ❌ BAD: Don't catch Error
try {
// code
} catch (Error e) {
// Usually pointless - JVM state is compromised
}
// ✅ GOOD: Catch Exception at most
try {
// code
} catch (Exception e) {
// Catches all recoverable exceptions
}2. Not Understanding Inheritance in Catches
java example
// ❌ COMPILE ERROR: IOException is parent of FileNotFoundException
try {
// code
} catch (IOException e) {
// Catches FileNotFoundException too!
} catch (FileNotFoundException e) {
// UNREACHABLE! Compile error
}
// ✅ CORRECT: Most specific first
try {
// code
} catch (FileNotFoundException e) {
// Specific handling for file not found
} catch (IOException e) {
// General IO handling for other IO problems
}Interview Questions
Q1: Draw the Java Exception hierarchy.
Answer: Object → Throwable → branches into Error (unrecoverable: StackOverflowError, OutOfMemoryError) and Exception (recoverable). Exception branches into checked exceptions (IOException, SQLException) and RuntimeException (unchecked: NullPointerException, ArithmeticException).
Q2: What is the difference between checked and unchecked exceptions?
Answer: Checked exceptions (extend Exception but not RuntimeException) are verified at compile-time — you must handle or declare them. Unchecked exceptions (extend RuntimeException) are not checked by the compiler — they indicate bugs that should be fixed in code. External issues → checked; code bugs → unchecked.
Q3: Is NumberFormatException checked or unchecked? What's its hierarchy?
Answer: Unchecked. Hierarchy: NumberFormatException → IllegalArgumentException → RuntimeException → Exception → Throwable → Object.
Q4: Can we catch Error in Java? Should we?
Answer: Technically yes (Error extends Throwable). But you should NOT because: (1) Errors indicate the JVM/system is in an unrecoverable state, (2) catching OutOfMemoryError doesn't guarantee you have memory to handle it, (3) program behavior after catching an Error is unpredictable.
Q5: Why does Java have checked exceptions? Are they controversial?
Answer: Checked exceptions force developers to consider failure scenarios at compile time, making code more robust. However, they're controversial because they can clutter code, force boilerplate handlers, and violate encapsulation (implementation details leak through method signatures). Many modern languages (Kotlin, Scala) don't have checked exceptions.
Q6: What class should you extend to create a custom checked exception vs unchecked?
Answer: Extend Exception for a custom checked exception. Extend RuntimeException for a custom unchecked exception. Choose checked when callers can meaningfully recover; choose unchecked for programming errors.
Q8: What is the difference between ClassNotFoundException and NoClassDefFoundError?
A: ClassNotFoundException (checked) occurs when Class.forName() or ClassLoader can't find the class at runtime. NoClassDefFoundError (Error) occurs when the class was available at compile time but missing at runtime (e.g., deleted JAR). The former is recoverable; the latter usually isn't.
Q9: Can you catch Error in Java?
A: Technically yes — catch(Error e) or catch(Throwable t) compiles and runs. However, you generally SHOULD NOT because Errors represent unrecoverable conditions (OutOfMemoryError, StackOverflowError). Catching them may leave the JVM in an inconsistent state. Exception: sometimes catching OutOfMemoryError to log before shutdown.
Q10: Why is RuntimeException unchecked while IOException is checked?
A: RuntimeExceptions indicate programming bugs (null pointer, bad index) that could be prevented with proper code — forcing try-catch would clutter code without benefit. Checked exceptions (IOException, SQLException) represent external failures that even correct code can't prevent — the compiler ensures you handle or propagate them.
Q11: What are the most common RuntimeExceptions in Java?
A: NullPointerException (accessing null reference), ArrayIndexOutOfBoundsException (invalid array index), ClassCastException (invalid cast), IllegalArgumentException (bad method argument), IllegalStateException (method called at wrong time), NumberFormatException (invalid string-to-number), ConcurrentModificationException (collection modified during iteration).
Q12: How do you decide whether to make a custom exception checked or unchecked?
A: Make it checked (extend Exception) when the caller can reasonably recover and SHOULD be forced to handle it (e.g., InsufficientBalanceException). Make it unchecked (extend RuntimeException) when it indicates a programming error or when forcing callers to handle it provides no benefit (e.g., InvalidConfigurationException).
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Exception Hierarchy in Java.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, exception, handling, hierarchy
Related Java Master Course Topics
Continue learning this concept
Exception HandlingException Handling Best PracticesComplete guide to exception handling best practices in Java — anti-patterns to avoid, proper exception design, logging strategies, retry patterns, and production-grade error handling techniques.Exception HandlingCustom Exceptions in JavaComplete guide to creating custom exceptions in Java — when to create them, checked vs unchecked custom exceptions, best practices, exception chaining, and real-world patterns for enterprise applications.Exception HandlingFinally Block in JavaComplete guide to the finally block in Java — guaranteed execution, resource cleanup, try-catch-finally flow, try-with-resources (Java 7+), and edge cases where finally may not execute.Exception HandlingException Handling IntroductionComplete guide to Exception Handling in Java covering what exceptions are, why they occur, the exception handling mechanism, types of errors, and how JavaException Handlingthrow and throws Keywords in JavaComplete guide to throw and throws keywords in Java — how to manually throw exceptions, declare checked exceptions, method signatures, exception propagation, and real-world patterns.Exception HandlingTry-Catch Block in JavaComplete guide to try-catch blocks in Java covering syntax, multiple catch blocks, nested try, multi-catch (Java 7+), exception propagation, and practical examples with output.