can catch have return statement

public String execute() throws Exception{
    try{
        //Do blah
        return "success"; //Assuming everything goes well, return success.
    }catch (Exception e){
        e.printStackTrace();
   return "error"; //???
    }
   return "error"; // can i skip this
}

Open in new window


can we write return statement in the catch block as above?
I never seeing like above.

If yes  can i skip return stmt after catch block.

Please advise
LVL 7
gudii9Asked:
Who is Participating?

[Product update] Infrastructure Analysis Tool is now available with Business Accounts.Learn More

x
I wear a lot of hats...

"The solutions and answers provided on Experts Exchange have been extremely helpful to me over the last few years. I wear a lot of hats - Developer, Database Administrator, Help Desk, etc., so I know a lot of things but not a lot about one thing. Experts Exchange gives me answers from people who do know a lot about one thing, in a easy to use platform." -Todd S.

CPColinSenior Java ArchitectCommented:
Why ask this question? Just remove the line and see if it compiles.
0
gurpsbassiCommented:
Why ask this question? Just remove the line and see if it compiles.

I agree with CPColin.
0
it_saigeDeveloperCommented:
As a best practice you would not want to return from a catch.  However, in response to your question, consider the following:
import java.util.*;
import java.lang.*;
import java.io.*;

class Test
{
	public static void main (String[] args) throws java.lang.Exception
	{
		System.out.println("Normal operation ouput -");
		System.out.println(Test.test(false));
		System.out.println("Exceptional output -");
		System.out.println(Test.test(true));
	}
	
	public static String test(Boolean causeException)
	{
		try
		{
			System.out.println("in try");
			if (causeException)
			{
				throw new Exception();
			}
		}
		catch (Exception e)
		{
			System.out.println("in catch");
			return "return from catch";
		}
		return "returned normally";
	}
}

Open in new window

Which produces the following output -Capture.JPG-saige-
0

Experts Exchange Solution brought to you by

Your issues matter to us.

Facing a tech roadblock? Get the help and guidance you need from experienced professionals who care. Ask your question anytime, anywhere, with no hassle.

Start your 7-day free trial
Python 3 Fundamentals

This course will teach participants about installing and configuring Python, syntax, importing, statements, types, strings, booleans, files, lists, tuples, comprehensions, functions, and classes.

dpearsonCommented:
You can skip the final return step as long as:

a) You have a return at the end of the try {} block.
b) You catch all exceptions in your catch block.

So yes in this case you can skip it.

Doug
0
gudii9Author Commented:
import java.util.*;
import java.lang.*;
import java.io.*;

class Test10
{
	public static void main (String[] args) throws java.lang.Exception
	{
		System.out.println("Normal operation ouput -");
		System.out.println(Test10.test(false));
		System.out.println("Exceptional output -");
		System.out.println(Test10.test(true));
	}
	
	public static String test(Boolean causeException)
	{
		try
		{
			System.out.println("in try");
			if (causeException)
			{
				throw new Exception();
			}
		}
		catch (Exception e)
		{
			System.out.println("in catch");
			return "return from catch";
		}
		return "returned normally";
	}
}

Open in new window


i got
Normal operation ouput -
in try
returned normally
Exceptional output -
in try
in catch
return from catch


i thought below should print at end

returned normally

please advise
0
it_saigeDeveloperCommented:
The return from the catch is exiting the method, anything below it will not process.  Which is why when it enters the exceptional branch the last output is - return from catch.

If you were to add a finally block and return from it, then the program would not compile as the line - return "returned normally"; - would not be reachable; e.g.:
import java.util.*;
import java.lang.*;
import java.io.*;

class Test
{
	public static void main (String[] args) throws java.lang.Exception
	{
		System.out.println("Normal operation ouput -");
		System.out.println(Test.test(false));
		System.out.println("Exceptional output -");
		System.out.println(Test.test(true));
	}
	
	public static String test(Boolean causeException)
	{
		try
		{
			System.out.println("in try");
			if (causeException)
			{
				throw new Exception();
			}
		}
		catch (Exception e)
		{
			System.out.println("in catch");
			return "return from catch";
		}
		finally
		{
			System.out.println("in finally");
			return "return from finally";
		}
		// the following line of code is now unreachable; because of this the program will not compile.
		return "returned normally";
	}
}

Open in new window

However, commenting out the line - return "returned normally"; - allows for the program to be compiled.  Running this new version gives the following output -Capture.JPGThe reason you get this output is because the finally branch executes *always*.  This is why I started my last comment with -
As a best practice you would not want to return from a catch.
-saige-
0
gudii9Author Commented:
let me try
0
gudii9Author Commented:
import java.util.*;
import java.lang.*;
import java.io.*;

class Test
{
	public static void main (String[] args) throws java.lang.Exception
	{
		System.out.println("Normal operation ouput -");
		System.out.println(Test.test(false));
		System.out.println("Exceptional output -");
		System.out.println(Test.test(true));
	}
	
	public static String test(Boolean causeException)
	{
		try
		{
			System.out.println("in try");
			if (causeException)
			{
				throw new Exception();
			}
		}
		catch (Exception e)
		{
			System.out.println("in catch");
			return "return from catch";
		}
		finally
		{
			System.out.println("in finally");
			return "return from finally";
		}
		// the following line of code is now unreachable; because of this the program will not compile.
		//return "returned normally";
	}
}

Open in new window


i too got compilation error at last line
return "returned normally";

when i commented that as above i got output as below
Normal operation ouput -
in try
in finally
return from finally
Exceptional output -
in try
in catch
in finally
return from finally
0
gudii9Author Commented:
import java.util.*;
import java.lang.*;
import java.io.*;

class Test
{
	public static void main (String[] args) throws java.lang.Exception
	{
		System.out.println("Normal operation ouput -");
		System.out.println(Test.test(false));
		System.out.println("Exceptional output -");
		System.out.println(Test.test(true));
	}
	
	public static String test(Boolean causeException)
	{
		try
		{
			System.out.println("in try");
			if (causeException)
			{
				throw new Exception();
			}
		}
		catch (Exception e)
		{
			System.out.println("in catch");
			return "return from catch";
		}
		finally
		{
			System.out.println("in finally");
			return "return from finally";
		}
		// the following line of code is now unreachable; because of this the program will not compile.
		//System.out.println("outside of try catch finally");
		//return "returned normally";
	}
}

Open in new window


i cannot put sysout also as last line?
//System.out.println("outside of try catch finally");
Please advise
0
gudii9Author Commented:
i expected output as below

Normal operation ouput -
in try
in finally
return from finally
Exceptional output -
in try
in catch
return from catch
in finally
return from finally

not like below

Normal operation ouput -
in try
in finally
return from finally
Exceptional output -
in try
in catch
in finally
return from finally

i wonder why below not printed

return from catch
0
it_saigeDeveloperCommented:
Let me try to explain this a different way.

Your expected results do not occur because the block of code encapsulated in the finally branch will *ALWAYS* process.  Since the finally branch includes a return statement, then the return statement in the catch block is ignored.  Whether you believe it or not, this also means that a return statement from the try branch will also be ignored.  Consider the following:
public class Test{

	public static void main (String[] args) throws java.lang.Exception
	{
		System.out.println("Normal operation ouput -");
		System.out.println(Test.test(false));
		System.out.println("Exceptional output -");
		System.out.println(Test.test(true));
	}
	
	public static String test(Boolean causeException)
	{
		try
		{
			System.out.println("in try");
			if (causeException)
			{
				throw new Exception();
			}
			return "return from try";
		}
		catch (Exception e)
		{
			System.out.println("in catch");
			return "return from catch";
		}
		finally
		{
			System.out.println("in finally");
			return "return from finally";
		}
		// the following line of code is now unreachable; because of this the program will not compile.
		// return "returned normally";
	}
}

Open in new window

Which produces the following output:Capture.JPGSince the finally is returning the results, then every statement following the end of the finally branch is rendered unreachable.  This means that your attempt to print to the console is ignored because you have returned from the method.

Ultimately though, I refer you back to my original statement:
As a best practice you would not want to return from a catch.
-saige-
0
gudii9Author Commented:
As a best practice you would not want to return from a catch.
How about try and finally? can we return from those ? please advise
0
gudii9Author Commented:
Your expected results do not occur because the block of code encapsulated in the finally branch will *ALWAYS* process.  Since the finally branch includes a return statement, then the return statement in the catch block is ignored.  Whether you believe it or not, this also means that a return statement from the try branch will also be ignored

i do not know this. so we can only have one return statement from method right?
if return is there in finally already then it is useless to have in try , catch right
0
it_saigeDeveloperCommented:
Whether it is legal or not depends upon the language (Java allows for you to return from a finally whereas C# does not).  However lets consider the *smell* of this (or the artifact otherwise).
public class Test{

     public static void main(String []args){
        System.out.println("Artifact Producing Practices");
        System.out.println(Test.ArtifactAdd(2, 2));
        System.out.println(Test.ArtifactAdd(10, 1));
        System.out.println("Best Practices");
        System.out.println(Test.BestPracticeAdd(2, 2));
        System.out.println(Test.BestPracticeAdd(10, 1));
     }
     
     public static String ArtifactAdd(int lhs, int rhs)
     {
         try
         {
             if (lhs % 10 != 0 || rhs % 10 != 0)
             {
                 return lhs + " + " + rhs + " = " + (lhs + rhs);
             }
             else
             {
                 throw new Exception();
             }
         }
         catch (Exception e)
         {
             // In all honesty we should never ever ever get here, but for the sake of argument a parameter that is divisible by 10 requires special treatment.
             return lhs + " + " + rhs + " = " + (lhs + rhs);
         }
         finally
         {
             return "2 + 2 = " + (2 + 2);
         }
     }
     
     public static String BestPracticeAdd(int lhs, int rhs)
     {
         String result = "";
         try
         {
             if (lhs % 10 != 0 || rhs % 10 != 0)
             {
                 result = lhs + " + " + rhs + " = " + (lhs + rhs);
             }
             else
             {
                 throw new Exception();
             }
         }
         catch (Exception e)
         {
             // In all honesty we should never ever ever get here, but for the sake of argument a parameter that is divisible by 10 requires special treatment.
             result = lhs + " + " + rhs + " = " + (lhs + rhs);
         }
         finally
         {
             if (lhs % 10 == 0 || rhs % 10 == 0)
             {
                 result = "Special treatment applied - " + result;
             }
         }
         return result;
     }
}

Open in new window

Produces the following results -Capture.JPGOn the outside we can look at this and say, why that makes no sense whatsoever, why would I forcibly return a result that is improper, to which there may be a perfectly valid reason.  However, by the standards of best practices or recommended practices or even just logic in general, you would want to perform the following steps:

1. Declare and initialize a result variable.

2. *[b]Try[/b]* to do something to your result variable (using parameters if needed).

3. *[b]Catch[/b]* any exceptional behaviour.

In catching exceptional behaviour you have to decide if the exceptional behaviour affects the result variable or output of your method and act accordingly

4. *[b]Finally[/b]*, perform any tasks to complete the operation.

In general this includes cleanup/destruction/disposal of any objects that are no longer required (obviously not including anything that the returned object [your result variable] depends upon).  Ultimately though, this is optional, you do not have to have a finally step as finally is generally regarded as a cleanup routine, or something that you want to always happen no matter whether the try processes normally or an exceptional course is taken.

5. Return your result variable.

-saige-
0
gudii9Author Commented:
Artifact Producing Practices
2 + 2 = 4
2 + 2 = 4
Best Practices
2 + 2 = 4
Special treatment applied - 10 + 1 = 11

i got output as above when i ran as below
public class Test{

     public static void main(String []args){
        System.out.println("Artifact Producing Practices");
        System.out.println(Test.ArtifactAdd(2, 2));
        System.out.println(Test.ArtifactAdd(10, 1));
        System.out.println("Best Practices");
        System.out.println(Test.BestPracticeAdd(2, 2));
        System.out.println(Test.BestPracticeAdd(10, 1));
     }
     
     public static String ArtifactAdd(int lhs, int rhs)
     {
         try
         {
             if (lhs % 10 != 0 || rhs % 10 != 0)
             {
                 return lhs + " + " + rhs + " = " + (lhs + rhs);
             }
             else
             {
                 throw new Exception();
             }
         }
         catch (Exception e)
         {
             // In all honesty we should never ever ever get here, but for the sake of argument a parameter that is divisible by 10 requires special treatment.
             return lhs + " + " + rhs + " = " + (lhs + rhs);
         }
         finally
         {
             return "2 + 2 = " + (2 + 2);
         }
     }
     
     public static String BestPracticeAdd(int lhs, int rhs)
     {
         String result = "";
         try
         {
             if (lhs % 10 != 0 || rhs % 10 != 0)
             {
                 result = lhs + " + " + rhs + " = " + (lhs + rhs);
             }
             else
             {
                 throw new Exception();
             }
         }
         catch (Exception e)
         {
             // In all honesty we should never ever ever get here, but for the sake of argument a parameter that is divisible by 10 requires special treatment.
             result = lhs + " + " + rhs + " = " + (lhs + rhs);
         }
         finally
         {
             if (lhs % 10 == 0 || rhs % 10 == 0)
             {
                 result = "Special treatment applied - " + result;
             }
         }
         return result;
     }
}

Open in new window


i di dnot understand the output what it is saying. please advise
0
it_saigeDeveloperCommented:
In laymens terms...  When you add 2 + 2, you are supposed to get 4.  This is correct with both methods...

When you add 10 + 1, you are supposed to get 11.  The first method incorrectly returns 2 + 2 = 4 (because of the finally method)...  The second method appends text in front of the correct result (as an example of what a finally can be used for but not needed)...

In all honesty, the second method could be rewritten without the finally...  It's not needed...  An example of a proper Addition method -
public static String Add(int lhs, int rhs)
{
	String result = "";
	try
	{
		result = lhs + " + " + rhs + " = " + (lhs + rhs);
	}
	catch (Exception e)
	{
		result = lhs + " + " + rhs + " could not be determined.";
	}
	return result;
}

Open in new window


-saige-
0
gudii9Author Commented:
you mean BestPracticeAdd() should be replaced with Add() as above right.
public class Test{

     public static void main(String []args){
        System.out.println("Artifact Producing Practices");
        System.out.println(Test.ArtifactAdd(2, 2));
        System.out.println(Test.ArtifactAdd(10, 1));
        System.out.println("Best Practices");
        System.out.println(Test.Add(2, 2));
        System.out.println(Test.Add(10, 1));
     }
     
     public static String ArtifactAdd(int lhs, int rhs)
     {
         try
         {
             if (lhs % 10 != 0 || rhs % 10 != 0)
             {
                 return lhs + " + " + rhs + " = " + (lhs + rhs);
             }
             else
             {
                 throw new Exception();
             }
         }
         catch (Exception e)
         {
             // In all honesty we should never ever ever get here, but for the sake of argument a parameter that is divisible by 10 requires special treatment.
             return lhs + " + " + rhs + " = " + (lhs + rhs);
         }
         finally
         {
             return "2 + 2 = " + (2 + 2);
         }
     }
     
     public static String Add(int lhs, int rhs)
     {
     	String result = "";
     	try
     	{
     		result = lhs + " + " + rhs + " = " + (lhs + rhs);
     	}
     	catch (Exception e)
     	{
     		result = lhs + " + " + rhs + " could not be determined.";
     	}
     	return result;
     }
}

Open in new window

when i modified i got below output
Artifact Producing Practices
2 + 2 = 4
2 + 2 = 4
Best Practices
2 + 2 = 4
10 + 1 = 11
0
gudii9Author Commented:
In laymens terms...  When you add 2 + 2, you are supposed to get 4.  This is correct with both methods...

When you add 10 + 1, you are supposed to get 11.  The first method incorrectly returns 2 + 2 = 4 (because of the finally method)...

i am bit not clear 2+2 should give 4 only right. why it is incorrect
0
it_saigeDeveloperCommented:
It is incorrect because it will only return 2 + 2 = 4, regardless of the parameters.

-saige-
0
gudii9Author Commented:
public class Test{

     public static void main(String []args){
        System.out.println("Artifact Producing Practices");
        System.out.println(Test.ArtifactAdd(2, 2));
        System.out.println(Test.ArtifactAdd(10, 1));
        System.out.println("Best Practices");
        System.out.println(Test.Add(2, 2));
        System.out.println(Test.Add(10, 1));
     }
     
     public static String ArtifactAdd(int lhs, int rhs)
     {
         try
         {
             if (lhs % 10 != 0 || rhs % 10 != 0)
             {
                 return lhs + " + " + rhs + " = " + (lhs + rhs);
             }
             else
             {
                 throw new Exception();
             }
         }
         catch (Exception e)
         {
             // In all honesty we should never ever ever get here, but for the sake of argument a parameter that is divisible by 10 requires special treatment.
             return lhs + " + " + rhs + " = " + (lhs + rhs);
         }
         finally
         {
             return "2 + 2 = " + (2 + 2);
         }
     }
     
     public static String Add(int lhs, int rhs)
     {
     	String result = "";
     	try
     	{
     		result = lhs + " + " + rhs + " = " + (lhs + rhs);
     	}
     	catch (Exception e)
     	{
     		result = lhs + " + " + rhs + " could not be determined.";
     	}
     	return result;
     }
}

Open in new window


i wonder why i am getting warning as attached. please advise
warning.png
0
gudii9Author Commented:
In laymens terms...  When you add 2 + 2, you are supposed to get 4.  This is correct with both methods...

When you add 10 + 1, you are supposed to get 11.  The first method incorrectly returns 2 + 2 = 4 (because of the finally method)...

i am not clear on why first method is incorectly returning 4 instead of 11 due to finally. I have not understood this. please advise
0
gudii9Author Commented:
is it becuase in case of first method finally has return so the return from try and return from catch are ignored and all the time return from finally only called whether code flow goes to try or catch block .
Is my above understanding is correct. please advise
0
it_saigeDeveloperCommented:
Refer to: http:/Q_28660752.html#a40739072 and http:/Q_28660752.html#a40763444
...the finally branch executes *always*...
You are really overthinking this.  It is a simple concept.  You try to do something (*TRY*)...  In case of a failure you do something else (*CATCH*)...  Regardless of which task you complete you always do this (*FINALLY*)...

-saige-
0
gudii9Author Commented:
It is a simple concept.  You try to do something (*TRY*)...  In case of a failure you do something else (*CATCH*)...  Regardless of which task you complete you always do this (*FINALLY*)...

i got above clearly.


Since the finally branch includes a return statement, then the return statement in the catch block is ignored.  Whether you believe it or not, this also means that a return statement from the try branch will also be ignored.  

Above is bit new to me. Based on above explanation now understand why i got below output


Artifact Producing Practices
2 + 2 = 4
2 + 2 = 4
Best Practices
2 + 2 = 4
10 + 1 = 11
0
It's more than this solution.Get answers and train to solve all your tech problems - anytime, anywhere.Try it for free Edge Out The Competitionfor your dream job with proven skills and certifications.Get started today Stand Outas the employee with proven skills.Start learning today for free Move Your Career Forwardwith certification training in the latest technologies.Start your trial today
Java EE

From novice to tech pro — start learning today.