class Demo
{
public static void main(String s[])
{
System.out.println("hello java frm Demo");
}
}
class Demo1
{
public static void main(String s[])
{
System.out.println("hello java frm Demo1");
String z={" "};
Demo.main();
}
}
Easy: there is no exception-handling in C.
java exception
Here is a code snippet illustrating exception handling: try { int a= 3 / 0 ; } catch ( ArithmeticException e ) { System.out.println ("An ArithmeticException has occured"); } finally { // some code }
Exception handling should be used in Java in all cases where you as a programmer suspect that your code might throw some exceptions or create errors that might look ugly when a user is using the application. In such cases you use exception handling to catch and handle the exception and exit gracefully. You use the try - catch block in Java for exception handling.
Thorwable
Exception handling is largely the same for both. The only real difference is that C++ has no 'finally' clause which always executes whether an exception occurs or not. Another difference is that Java throws exceptions and errors, but errors cannot be handled since programs cannot handle errors -- such as the JVM out of memory error.
In Java, Exception Handling is Explicit. The Programmer has to write code that will ensure that the exceptions are caught and appropriately handled
Exceptions are thrown when Java encounters an error. They are a fundamental part of the Java error handling system. In a nutshell, Java will throw an Exception when it encounters an error so that an exception handler can "handle" the error. For instance, if a calculator program is given the command "1/0", Java can throw an ArithmeticException which could be reported back to the user.Some common types are:ArithmeticException - thrown when arithmetic error has occurred, like dividing by 0IOException - thrown when an input or output error has occurred, like a file not foundArrayIndexOutOfBoundsException - thrown when a nonexistent element of an array is requested, like arr[-1]NullPointerException - thrown when some operation if performed on an object whose value is nll.
sometimes there are situations where the program is vary long which can make error debugging a long process so java provides a facility to make user defined exception handling suppose we are dividing two numbers a/b and if the user enters the value of b 0, the user wants to display an error of your own so the user can do this by using exception handling
Runtime Error Cannot be Rectified but Runtime Exception can.
try{ statements; } catch(Exception e) { message }
Yes, in Java, you can create custom error types by extending the Error class or its subclasses. This allows you to define specific error conditions for your application. However, it's generally recommended to extend the Exception class instead, as Error is intended for serious issues that a reasonable application should not try to catch. Custom exceptions provide better error handling and recovery mechanisms in your code.