void indata() {
    model = cboModelo.getSelectedItem().toString();
    try {
        amount = Integer.parseInt(txtCantidad.getText());
    } catch (NumberFormatException e) {
        // Handle it here
    }
}

This is the only workaround I can think of, and it's a bit ugly.

• Go to Window -> Preferences.
• Search for Editor.
• Unfold and select Templates.
• Select the try_catch template and remove line breaks as you deem fit.
• Apply and save.

Then, instead of using Eclipse's Surround with try-catch prompt...

• Select your line(s) that throw(s) Exception(s)
• Use the custom template: Shift-Alt-Z, then typically 7 (or whichever is the shortcut for try_catch).

The bottomline is, I do not believe the Surround with try catch default template is editable, but Eclipse (at least, Neon) does provide a template that is editable out of the box, which in turn, you can edit.

Edit

As mentioned by others, I really feel like pointing out the obvious, i.e. what you're trying to achieve is not a desirable practice. A caught exception should be handled somehow, and in its own line.

This is not an Eclipse error, it is a Java compiler error. Eclipse is merely reporting the Java compilation error for you. There is no way to "turn it off" as the code does not compile without the try/catch clause. It is a safety feature in Java that forces you to handle commonly thrown Exceptions.

Methods have Exceptions in their signature. For example, InputStream.close() throws an IOException, forcing you to handle it in a try/catch block.

public void close() throws IOException {
    ...

Throwing an Exception is a way of telling the program that a significant problem - that must be handled - has occurred.

My question is: is it possible to remove this error in eclipse and use try/catch when I need it otherwise not instead of eclipse telling me to do try/catch add.

No, it is not possible.

(Since I am already trying to avoid exception by replacing try/catch with if/else as possible).

You should generally never try to replace try/catch blocks with if/else blocks. They are two distinct features with distinct purposes.

Exceptions are an essential Java feature. Read about it and understand it.

Have a look at the stacktrace. You can find inyside an Eclipse tab somewhere, or print it directly when you catch the exception:

catch (Exception ex){
    ex.printStackTrace();
}

Inspecting the stacktrace is the fast and most secure way to find your error quickly. Even if you set a breakpoint (or worst use some print to locate the last statement executed) you won't be able to determine exactly where the exception occurred. In fact the exception could have been raised a lot deeper inside your calls stack, not necessarily in the first method called after the breakpoint.

Yes it's possible, open Eclipse Preference and then Java > Code Style > Code Templates. There you select Code > Catch block body. Here you can edit your try/catch block.

Add myCustomLogger.LogMe(Log.getStackTraceString(${exception_var}));

Yes, you can change the default code added by Eclipse.

1. In Preferences, navigate to Java>Code Style>Code Templates.
2. Under Code, select Catch block body.
3. Press the Edit button to change the code. When finished, press the OK button.

Consider adding a TODO comment in the default catch block. For example, the default includes:

     // ${todo} Auto-generated catch block

From the documentation it is clear, it does not gives exception for the wrong file name supplied to FileWriter, it rather creates new file if it is not present. Also if it is not able to create a file at a desired location, then it throws IOException. Just check at the location, it should have created files there.

Constructs a FileWriter object given a file name with a boolean indicating whether or not to append the data written.

Parameters: fileName String The system-dependent filename. append boolean if true, then data will be written to the end of the file rather than the beginning. Throws: IOException if the named file exists but is a directory rather than a regular file, does not exist but cannot be created, or cannot be opened for any other reason

Explanation

From the Java documentation:

[The try block] contains one or more legal lines of code that could throw an exception. (The catch and finally blocks are explained in the next two subsections.)

An exception is a special kind of object. When you write new Exception(), you are creating a new exception object. When you write throw new Exception() you are creating a new error, and then throwing it to the nearest try-catch block, aborting the rest of your code.

When you throw an exception, it gets caught by the try-catch block that it's nested in (inside of). That is, assuming the proper catch block for that exception is registered. If the code is not wrapped in a try-catch block, the program with automatically shut down as soon as an error is thrown. Use a try-catch around any code or method that can throw an error, especially because of user input (within reason).

Some exceptions have to be caught, others are optional to catch. (checked vs. unchecked).

When you add throws to a method signature, you are announcing to other methods that if they call that method, it has the potential to throw a checked exception (it is not necessary for unchecked). Notice how it's throws not throw. It's not doing an action, it's describing that it sometimes does an action.

You use this functionality when you don't want to catch the error inside that method, but want to allow the method's that call your method to catch the error themselves.

Exceptions are a way to make your program respond coherently to unexpected or invalid situations and are especially useful when user input is required, though it's also useful in other situations such as File input/output.

Examples

public CircleWithException() throws InvalidRadiusException {
       this(1.0);
}

Here, the CircleWithException() has the potential to throw an InvalidRadiusException (presumably, the this(1.0) sometimes throws an InvalidRadiusException.)

The code calling this method should have:

try {
    new CircleWithException(); // This calls the method above
} catch (InvalidRadiusException e) { // The object "e" is the exception object that was thrown.
    // this is where you handle it if an error occurs
}

As I said before, an Exception is just a specific type of object that extends Exception

/* Invalid radius class that contains error code */
public class InvalidRadiusException extends Exception {
     private double radius;

/** Construct an exception */
public InvalidRadiusException(double radius) {
       super("Invalid radius " + radius);
       this.radius = radius;
}

/** Return the radius */
public double getRadius() {
    return radius;
 }
}

The above code defines a new type of Exception specific to your program/application. There are many predefined exceptions in the Java Standard Library, but often you need to create your own.

To throw this exception, you first create an InvalidRadiusException object and then throw it:

throw new InvalidRadiusException(1.0);