DEV Community: Deepikandas

#33 Known is a drop Mark calculating system - Mini Project

Deepikandas — Sun, 26 Apr 2026 21:01:24 +0000

Mark calculating system

package twelfth;

import java.util.InputMismatchException;
import java.util.Scanner;

public class TwelfthMark {
    static String School = "Good Hope Higher secondary school";
    String name;
    int marks[] = new int[6];

    public void getName(Scanner sc) {
        while (true) {
            System.out.println("Enter the student name");
            name = sc.nextLine();
            if (!name.isBlank()) {
                break;

            }
            System.out.println("\"Name cannot be empty\"");
        }
    }

    public void printScore(double sum) {
        System.out.println("Total mark scored " + sum);
        System.out.printf("Average :%.2f\n", (sum / 6));
        double percentage = (sum / 600) * 100.0;
        System.out.printf("Percentage: %.2f%%", percentage);

    }

    public static void main(String[] args) {
        String group1[] = { "Biology", "English", "Tamil", "Maths", "Physics", "Chemistry" };
        String group2[] = { "Computer Science", "English", "Tamil", "Maths", "Physics", "Chemistry" };
        String group3[] = { "Accountancy", "English", "Tamil", "Business Studies", "Computer Science/Math",
                "Economics" };
        TwelfthMark twelfth = new TwelfthMark();
        Scanner sc = new Scanner(System.in);

        twelfth.getName(sc);

        System.out.println("Enter the group name-a.1st Group b.2nd Group c.3rd Group");

        String group = sc.nextLine();
        double sum = 0;

        switch (group.toLowerCase()) {
        case "1st Group", "a", "1" -> {
            try {
                for (int i = 0; i <= 5; i++) {
                    System.out.println("Enter the mark of  " + group1[i]);

                    twelfth.marks[i] = sc.nextInt();

                    sum = sum + twelfth.marks[i];
                }
                twelfth.printScore(sum);
            } catch (InputMismatchException e) {
                System.out.println("\"Enter only numbers\"");

            }
        }
        case "2nd Group", "b", "2" -> {
            try {
                for (int i = 0; i <= 5; i++) {
                    System.out.println("Enter the mark of  " + group2[i]);

                    twelfth.marks[i] = sc.nextInt();

                    sum = sum + twelfth.marks[i];

                }
                twelfth.printScore(sum);
            } catch (InputMismatchException e) {
                System.out.println("Enter only numbers");
            }

        }

        case "3rd Group", "c", "3" -> {
            try {
                for (int i = 0; i <= 5; i++) {
                    System.out.println("Enter the mark of  " + group3[i]);

                    twelfth.marks[i] = sc.nextInt();

                    sum = sum + twelfth.marks[i];
                }
                twelfth.printScore(sum);
            } catch (InputMismatchException e) {
                System.out.println("Enter only numbers");
            }
        }
        default -> System.out.println("Enter valid group ");
        }

        sc.close();
    }
}

#32 Known is a drop! Exceptional Handling in JAVA Summary

Deepikandas — Tue, 21 Apr 2026 02:47:48 +0000

🔹 1. What is exception handling in Java?

Exception handling is a mechanism in Java used to handle runtime errors so that the normal flow of the program is not disrupted.

🔹 2. What is an exception?

An exception is an unexpected event that occurs during program execution and disrupts normal flow.

🔹 3. Difference between Error and Exception?

Error
Serious system-level issue
Cannot be handled
Example: OutOfMemoryError, StackOverflowError
Exception
Can be handled using try-catch
Example: IOException, NullPointerException
🔹** 4. Explain exception hierarchy in Java?**

Throwable
├── Error
└── Exception
├── Checked Exception
└── Unchecked Exception (RuntimeException)
🔹 5. What are checked exceptions?

Checked exceptions are compile-time exceptions that must be handled using try-catch or declared using throws.

Examples:

IOException
FileNotFoundException
SQLException
🔹 6. What are unchecked exceptions?

Unchecked exceptions occur at runtime and are not forced by the compiler.

Examples:

ArithmeticException
NullPointerException
ArrayIndexOutOfBoundsException
NumberFormatException
🔹 7. Difference between checked and unchecked exceptions?

🔹** 8. What is try-catch block?**

try contains risky code
catch handles exceptions
🔹 9. What is finally block?

The finally block always executes whether an exception occurs or not. It is used for cleanup operations.

🔹 10. Difference between throw and throws?

🔹 11. What is throw keyword?

Used to manually create an exception.

throw new ArithmeticException("Error");
🔹 12. What is throws keyword?

Used to declare exceptions in method signature and delegate handling to caller.

void read() throws IOException
🔹 13. Why do we use throws?

To inform the caller that a method may generate a checked exception.

🔹 14. Can we handle exceptions without try-catch?

Yes, using throws, but it delegates responsibility to the caller and may cause runtime crash if not handled.

🔹** 15. What happens if exception is not handled?**

Program terminates abnormally and JVM prints stack trace.

🔹 16. What is stack trace?

A stack trace shows the sequence of method calls that led to an exception, helping in debugging.

🔹 17. Can we have multiple catch blocks?

Yes, but each catch must handle a different exception type.

🔹** 18. Can finally block be skipped?**

Generally no — it always executes, except in cases like:

System.exit()
JVM crash
🔹 19. Can we throw multiple exceptions using throw?
No, throw can throw only one exception at a time.

🔹 20. Real-world use of exception handling?

Used in:

File handling
Database operations
API calls
Input validation
Network communication
⭐ BONUS INTERVIEW ONE-LINERS

🔥 Checked = compiler forces handling
🔥 Unchecked = programming mistake
🔥 throw = create exception
🔥 throws = declare exception
🔥 finally = always executes
🔥 try-catch = handles runtime failure

#31 Known is a drop- Exception Handling Programs- Java

Deepikandas — Tue, 21 Apr 2026 01:52:35 +0000

ArithmeticException **

**ArrayIdexOutOfBounds Exception:

NumberFormat Exception

NullPointer Exception

FileNotFound Exception

StringIndexOutOfBounds Exception

NegativeArraySize Exception

#30 Known is a Drop! Tricky questions- Exception Handling Part 4

Deepikandas — Tue, 21 Apr 2026 01:23:08 +0000

Q1.
try {

} finally {

}

No compile error.
try should be followed either by catch or finally

Q2.
try {

} catch(Exception e) {

}

No compilation error.
try followed by catch

Q3.
try {

} catch(Exception e) {

} finally {

}

Answer: This is the right order: 
if catch is present ,then it must be followed by try.1.try 2.catch 3.finally

4.try {

} catch(ArithmeticException e) {

} catch(Exception e) {

}

Ans: multiple catch allowed.
catch with Exception should be last of all other exceptions.

Q5.
try {

} catch(Exception e) {

} catch(ArithmeticException e) {

}
Answer: compile error.
Catch(Exception e) should be last .

Q6.
try {

} finally {

} catch(Exception e) {

}
Answer: compile error.
Catch() block cannot be after finally block

Q7.try {

} catch(Exception e) {

} finally {

} finally {

}

Ans: Multiple finally not allowed

Q8.
try {

} catch(ArithmeticException e) {

} finally {

} catch(Exception e) {

}
Answer: cath block is after finally block.compile error

Q9.try {

}
Ans: Compile error.
Either finally or catch block should follow

Q10.
catch(Exception e) {

}
Ans: catch block cannot be alone without try block

Q11.
11.
finally {

}

Ans: finally block cannot alone without try block

Q12.
try {

} catch(ArithmeticException e) {

} catch(ArithmeticException e) {

}
Ans: cannot have two catch blocks for the same exception type.

Q13.
try {

} catch(Exception e) {

} catch(RuntimeException e) {

}

Catch block with Exception should be last .

Q14.
try {

} catch(RuntimeException e) {

} catch(Exception e) {

}
Answer: Valid

15.
try {

} finally {

} finally {

}
Ans: Multiple finally block not allowed

#29 - Exception Handling Throw & Throws Keyword Part3

Deepikandas — Tue, 21 Apr 2026 00:38:39 +0000

Throw keyword:
JVM automatically throws system-generated exceptions. All those exceptions are called implicit exceptions.
If we want to throw an exception manually or explicitly, for this, Java provides a keyword throw.

In Java exception handling, we use throw keyword to throw a single exception explicitly. It is followed by an instance variable.
Using throw keyword, we can throw either checked or unchecked exception in Java.
The keyword throw raises an exception by creating a subclass object of Exception explicitly.
We mainly use throw keyword to throw custom exception on the basis of some specified condition.
We use keyword throw inside the body of method or constructor to invoke an exception.
With the help of throw keyword, we cannot throw more than one exception at a time

What is throws in Java?

The throws keyword is used in a method declaration to indicate that the method might not handle an exception itself and instead passes the responsibility to the caller method.

It acts as a warning signal to the programmer:

“This method may generate an exception. Handle it where you call it.”
Why do we use throws?

We use throws because:

Some exceptions cannot or should not be handled immediately
The caller may be better suited to handle the error
It helps in writing clean and modular code
🧠 Syntax of throws
returnType methodName() throws ExceptionType {
// risky code

Difference between Throw and Throws in Java
There are some key difference between throw and throws keyword in Java. They are as:

The keyword throw is used to throw an exception explicitly, while the throws clause is used to declare an exception.
Throw is followed by an instance variable, while throws is followed by the name of exception class.
We use throw keyword inside method body to call an exception, while the throws clause is used in method signature.
With throw keyword, we cannot throw more than one exception at a time, while we can declare multiple exceptions with throws.

#28 - Exception Handling -Checked Exception - part2

Deepikandas — Sun, 19 Apr 2026 17:46:13 +0000

*Checked Exception in Java *

A checked exception is an exception that is checked at compile time by the compiler to ensure it is either handled using try-catch or declared using throws.
If a method can cause a checked exception, Java forces you to handle it before the program runs.

Important concept

✔ Even if the file path is correct
✔ Even if the file exists
❌ Compiler still requires handling because it’s a checked exception

*Why compiler forces checked exceptions
*
👉 Because checked exceptions represent predictable runtime problems that are likely to happen, so Java wants you to handle them before the program runs.
Predictable problems

Checked exceptions usually come from situations like:

file may not exist (IOException)
database may fail (SQLException)
class may not load (ClassNotFoundException)
Call Stack Behavior in Java Exception Handling

In Java, when an exception occurs (like ArrayIndexOutOfBoundsException), the method where the error happens immediately stops execution. If that method does not handle the exception using try-catch, the exception is passed upward through the call stack.

The call stack is the chain of method calls (e.g., printArray → main → JVM). Each level is checked for a matching catch block. If printArray() does not handle the exception, it is passed to main(), where it may be caught. If no method handles it, the JVM terminates the program and prints a stack trace.

This upward movement of the exception from one method to another is called stack unwinding or propagation up the call stack.

#27 Exception Handling in JAVA -part1

Deepikandas — Sun, 19 Apr 2026 16:16:16 +0000

What is an Exception?
An unwanted or unexpected event that interrupts or disturbs the normal flow of the program is called an Exception.
Example:

Exception Hierarchy in Java:
Java exceptions can be of several types and all exception types are organized in a fundamental hierarchy as shown below.

Exception Vs Errors
Errors
Errors are serious problems that occur due to system-level failures and are generally beyond the control of the application. They are not meant to be caught or handled by the program.

Caused by JVM or system failures
Programs are usually unable to recover

Types of Exception:

Built-in EXception:
1. Checked Exception:

Checked exceptions are those exceptions that the compiler checks at compile time to ensure they are either handled using try-catch or declared using throws, so that the program can run smoothly without unexpected runtime failures.
All exceptions in Java that are not subclasses of RuntimeException (and its subclasses) and not subclasses of Error (and its subclasses) are classified as checked exceptions. 2. Unchecked Exception: The exception which is not checked by the compiler is called Unchecked exception. This exception occurs during the run time of the program execution. All Runtime exception and its child classes, Error and its child classes fall under Unchecked exceptions. Exception Handling:
Exception handling by JVM:

2.Exception handling by Programmer using code:
In Java, a programmer can handle exceptions via five keywords: try, catch, finally, throw and throws.
1.try..catch
try:
A try block is used to enclose risky code that might throw an exception.
Java runs the code inside try
If an error occurs, control moves to catch
If no error occurs, catch is skipped
catch:
A catch block is used to handle and respond to exceptions that occur inside a try block.
If an exception occurs in try, control moves to catch
catch prevents program from crashing
It defines what to do when an error happens

Remaining Statements in try Block Are Not Executed
When an exception happens inside a try block, the normal flow is interrupted. The remaining statements in the try block are skipped. Control immediately moves to the matching catch block to handle the error. After handling, the program continues with the code after the try-catch.

2.try..catch...finally
finally:

A block that always runs after try-catch execution, even if an exception occurs or not.
finally is a block that always executes after try (and catch, if present)
finally ensures important cleanup tasks (like closing files, releasing resources, and closing connections) always run. Can try exist without catch? A try block must be followed by at least one of these: catch finally

Nested try:
How it works (simple)
If error happens in inner try, inner catch handles it
If inner catch cannot handle it, it goes to outer catch
Each try has its own catch block

Common Exception
Exception is the common parent class of most exceptions in Java.
It can be used to catch both checked and unchecked exceptions.
It does not include Error types (like OutOfMemoryError).

#26 Tricky questions in Arrays-JAVA

Deepikandas — Tue, 07 Apr 2026 01:57:18 +0000

1.Default values assigned
Arrays are the only objects even though inside method,default values are given


public class Arrays {
    public static void main(String[] value) {
        int[] arr = new int[3];
        System.out.println(arr[0] + " " + arr[1] + " " + arr[2]);
    }

}
Output:
0 0 0

2.ArrayIndexOutOfBoundsException

public class Arrays {
    public static void main(String[] value) {
        int[] arr = new int[3];
        System.out.println(arr[3]);

    }

}
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
    at Module4/arrays.Arrays.main(Arrays.java:6)

4.Demonstrating Array Reference Behavior:

public class Arrays {
    public static void main(String[] value) {
        int[] a = {1, 2, 3};
        int[] b = a;
        b[0] = 100;
        System.out.println( "value of []a:"+a[0]);
    }

}
Output:
value of []a100

5.a and b point to different array objects, even though they have the same elements

public class Arrays {
    public static void main(String[] value) {
        int[] a = {1, 2, 3};
        int[] b = {1, 2, 3};
        System.out.println(a);
        System.out.println(b);
        System.out.println(a == b);
    }

}
output:
[I@65b3120a
[I@6f539caf
false

6.NullPointerException


public class Arrays {
    public static void main(String[] value) {
        int[] arr = null;
        System.out.println(arr.length);
    }

}
Exception in thread "main" java.lang.NullPointerException: Cannot read the array length because "arr" is null
    at Module4/arrays.Arrays.main(Arrays.java:6)

7.NegativeArraySizeException


public class Arrays {
    public static void main(String[] value) {
        int[] arr = new int[-5];
    }

}
Exception in thread "main" java.lang.NegativeArraySizeException: -5
    at Module4/arrays.Arrays.main(Arrays.java:5)

#25 Known is a drop! Arrays in Java

Deepikandas — Tue, 07 Apr 2026 01:43:33 +0000

Arrays:
A collection of elements of the same type stored under a single name, accessible by numeric indices, with a fixed size.
Key Points About Arrays
Fixed size:
Once created, the number of elements cannot change.

Example: int[] numbers = new int[5]; → can only hold 5 integers.
Same type elements:
All elements must be of the same data type (e.g., int, String, boolean).
Indexed access:
Elements are accessed using indices, starting from 0.
Example: numbers[0] → first element, numbers[4] → fifth element.
Declaration syntax:
type[] arrayName; // preferred style
type arrayName[]; // also valid
Initialization examples:
// Using 'new' keyword
int[] nums = new int[5];

// Using array literal
int[] nums2 = {1, 2, 3, 4, 5};
Memory layout:
Arrays are contiguous in memory, which allows fast index-based access.
Multidimensional arrays:
int[][] matrix = {
{1, 2, 3},
{4, 5, 6}
};
Access element: matrix[0][2] → 3
Looping through Array :


    for(int i = 0; i < arr.length; i++)
    {
        System.out.println(arr[i]);
    }

Is Array an Object?
When you create an array, Java allocates it on the heap.
The array variable actually holds a reference (like a pointer) to that object.
Because it’s an object, it inherits methods from java.lang.Object, such as:
hashCode()
toString()
clone()
getClass()
Behind the scenes:
int[] numbers = {1, 2, 3};
This is called an array initializer (or array literal).
Even though you didn’t explicitly write new int[3], Java implicitly creates an array object on the heap behind the scenes.
So numbers still holds a reference to an array object.

//getClass(); instanceof
package arrays;

public class Arrays {
    public static void main(String[] value) {
        int arr[]= {23,89,90,78};
        System.out.println(arr.getClass());
        System.out.println(arr instanceof Object);
    }

}
Output:
class [I
true

What is a runtime class?

The runtime class is the actual class of the object in memory at runtime.
It may be a standard Java class, your own user-defined class, or even an array type. 2️⃣ Examples of runtime classes that are NOT predefined User-defined class

class Student { }

Student s = new Student();
System.out.println(s.getClass()); // class Student
Student is not a predefined Java class—it’s created by the programmer.

Runtime class is Student.
Array objects

int[] numbers = {1, 2, 3};
System.out.println(numbers.getClass()); // class [I
[I → array of integers

There is no class literally named [I in your code.
Arrays are runtime objects created by the JVM, automatically

#24 known is a drop! main method in JAVA

Deepikandas — Sat, 04 Apr 2026 21:43:11 +0000

It's the entry point for your application and will subsequently invoke all the other methods required by your program.

Modifiers in main method:
The modifiers public and static can be written in either order (public static or static public)
public → JVM must access it from outside the class.
If you make it non-public, JVM cannot access it, and you’ll get an error.
static → JVM can call it without creating an object of the class.
Return type of main()
main method signature is void
It does not return anything to the JVM directly.
That’s why the return type is void.

Returning a value to the OS
When you call:
System.exit(0);

String args[]

The main method accepts a single argument: an array of elements of type String.
Each string in the array is called a command-line argument.
These are used to give input during run time.
Actually not during run time, before the program runs itself ,we give input.

All syntax are correct:

public static void main(String... args)
public static void main(String[] value)
static public void main(String[] args)

In cmd prompt:
We have to give values to command line arguments at the time of run.
eg: java filename input1 input2

🟩input1 is stored in args[0],
input2 is stored in args[1].

🟩all inputs are taken in the form of Strings.

To parse the string values:
🟩 if we want to perform any arithmetic operations,
we have to parse the value using Integer.parseInt(String args[0])
i.e., converting String to primitive int type

🟩 Same for other float values, boolean. We have to parse using corresponding Wrapper class parse method.

*In Eclipse * Right click->Run configurations->select Arguments tab-> enter values separated by space.(not commas in between)

*How Scanner class differs from command line arguements? * If we use Scanner class, we can inform the user to enter values as inputs are fed during run time
but using command line args, we cannot prompt.

Can main be overloaded?
✅ Yes. You can define multiple main methods with different parameters in the same class.
JVM behavior:
The JVM only automatically calls public static void main(String[] args) as the program entry point.
Overloaded main methods are not called automatically; they must be called explicitly from the standard main or elsewhere.

public static void main(String[] args) { }      // standard entry
public static void main(int number) { }         // overloaded
public static void main(String message) { }     // overloaded
public static void main(int a, int b) { }       // overloaded

main Can Be in Multiple Classes:

Each class can have its own main method.
You can choose which class to run from the command line.

#23 Known is a Drop! Nested for loop in JAVA with examples-

Deepikandas — Fri, 03 Apr 2026 13:18:11 +0000

What is a Nested for Loop?

A nested loop means:
👉 A for loop inside another for loop
Outer loop → controls rows
Inner loop → controls columns/repetitions inside each row

Example 1:
Print
1 1 1 1 1
1 1 1 1 1


public class NestedForLoop {

    public static void main(String[] args) {
        for(int row=1;row<=2;row++) {
            for(int column=1;column<=5;column++) {
                System.out.print(1+" ");
            }
            System.out.println();
        }

    }

}
Output:
1 1 1 1 1 
1 1 1 1 1

Example 2: Print
1 1 1 1 1
2 2 2 2 2

package nestedForLoop;

public class NestedForLoop {

    public static void main(String[] args) {
        for(int row=1;row<=2;row++) {
            for(int column=1;column<=5;column++) {
                System.out.print(row+" ");
            }
            System.out.println();
        }

    }

}
**Output:**
1 1 1 1 1 
2 2 2 2 2

Example 3:Print
1 2 3 4 5
1 2 3 4 5

public class NestedForLoop {

    public static void main(String[] args) {
        for(int row=1;row<=2;row++) {
            for(int column=1;column<=5;column++) {
                System.out.print(column+" ");
            }
            System.out.println();
        }
    }
}
Output:
1 2 3 4 5 
1 2 3 4 5

Example 4:Print
1 2 3 4 5 6
1 2 3 4 5 6
1 2 3 4 5 6
1 2 3 4 5 6

public class NestedForLoop {

    public static void main(String[] args) {
        for(int row=1;row<=4;row++) {
            for(int column=1;column<=6;column++) {
                System.out.print(column+" ");
            }
            System.out.println();
        }
    }
}
output:
1 2 3 4 5 6 
1 2 3 4 5 6 
1 2 3 4 5 6 
1 2 3 4 5 6

Example 5:
print
& & & & &

& & & & &

& & & & &

public class NestedForLoop {

    public static void main(String[] args) {
        for(int row=1;row<=3;row++) {
            for(int column=1;column<=5;column++) {
                System.out.print("&  ");
            }
            System.out.println();
        }
    }
}

output:
& & & & &   
& & & & &                  
& & & & &

Example 6:
Print
& & & & &

& & & &

& & &
& &
&

public class NestedForLoop {

    public static void main(String[] args) {
        for(int row=5;row<=5&& row!=0;row--) {
            for(int column=1;column<=row;column++) {
                System.out.print("&  ");
            }
            System.out.println();
        }
    }
}

& & & & &   
& & & &                 
& & &
& &
&

//Using count variable;
public class NestedForLoop {

    public static void main(String[] args) {
        int count=5;
        for(int row=1;row<=5;row++) {
            for(int column=1;column<=count;column++) {
                System.out.print("*  ");
            }
                count--;

            System.out.println();
        }
    }
}

Example 7:
Print
&
& &

& & &

& & & &
& & & & &

public class NestedForLoop {

    public static void main(String[] args) {
        int count=1;
        for(int row=1;row<=5;row++) {
            for(int column=1;column<=count;column++) {
                System.out.print("*  ");
            }
                count++;

            System.out.println();
        }
    }
}

#23 Known is a drop! Scanner class JAVA

Deepikandas — Tue, 31 Mar 2026 12:29:15 +0000

Scanner class
The Scanner class is used to get user input, and it is found in the java.util package.
Purpose:
1. Read user input (keyboard)

Works with System.in
Example: nextInt(), nextLine()

2. Read data from files

Can read text files line by line

3. Read different data types

int → nextInt()
double → nextDouble()
String → next(), nextLine()
boolean → nextBoolean()

4. Parse/split input
Parsing = breaking a big input into small pieces (tokens)
Tokens can be:
words
numbers
symbols
When a user types:John 25 3.75
It’s just a line of text to Java.
We need a way to separate it into meaningful pieces:

"John" → String
25 → int
3.75 → double

Scanner does this automatically.
Input Types:

import java.util.Scanner;

public class ScannerInput {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter Your name : ");
        String  name= sc.nextLine();
        System.out.println("Enter the Tamil mark: ");
        int tamil=sc.nextInt();
        System.out.println("Enter the English mark: ");
        int english=sc.nextInt();
        System.out.println("Enter the Science mark: ");
        int sci=sc.nextInt();
        System.out.println("Enter the Math mark: ");
        int math=sc.nextInt();
        System.out.println("Your average 345mark is "+(tamil+english+sci+math)/4);

    }

}
output:
Enter Your name : 
K
Enter the Tamil mark: 
67
Enter the English mark: 
89
Enter the Science mark: 
90
Enter the Math mark: 
90
Your average 345mark is 84

Why Scanner needs System.in?
Scanner sc = new Scanner(System.in);
Scanner’s purpose
Scanner is a high-level utility class in java.util.
It can read tokens, lines, integers, doubles, etc., from a source.
It handles all the parsing and splitting of input for you.
Data source requirement
Scanner needs something to read from:
Could be a file → new Scanner(new File("data.txt"))
Could be a string → new Scanner("1 2 3")
Could be the keyboard → new Scanner(System.in)

close():
Purpose
Frees system resources used by a resource (like file, stream, or scanner).
Stops further use of that resource.
When to use
Files, network streams, database connections: Always close (or use try-with-resources) to avoid real resource leaks.
Scanner(System.in): Usually don’t close, because closing also closes System.in and you can’t read from the keyboard anymore.
Effects of closing
Releases memory and system handles.
After closing, calling methods on the resource can throw exceptions (IOException, IllegalStateException).