从构造函数中调用时，关键字“ super”如何工作？

Question

import java.io.*;

class MyException1
{
static String str="";

 public static void main(String args[])
 {
 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
 System.out.println("Enter your food");


 try{
 str=br.readLine();
 }catch(IOException e){
 System.out.println("Exception has been occurred"+e);
 }


 try{
 checkFood();
 }catch(BadException be){
 System.out.println("Exception"+be);
 }
 }


 private static void checkFood() throws BadException
 {

 if(str.equals("Rotten")|| str.equals("")){
 System.out.println("Bad food");
 //throw new BadException();
 throw new BadException("Not Eatable");
 }else{
 System.out.println("Good food !! enjoy");

 }
 }
}



class BadException extends Exception
{
String food;

 BadException()
 {
 super(); 
 food="invalid";
 System.out.println(food);
 }

 BadException(String s)
 {
 super(s); 
 food=s;
 }

 public String getError()
 {
 return food;
 }

}

In the program, how is it that this public String getError() returns the food variable? I have not called it anywhere?

If I remove the line super(s); , then "Not Eatable" does not get printed. But if I leave that line in, then it does get printed out. How does this program flow work?

Answer 1

If I remove the line super(s);, then "Not Eatable" does not get printed. But if I leave that line in, then it does get printed out. How does this program flow work?

super(s) will call the "super class" constructor that takes a string. Just like if you had called new Exception("Not Eatable") . This constructor for Exception adds a message to the exception, so when you print it out, it will contain that text.

This has nothing to do with the variable food . You could remove the line food=s; , and the message would still print out correctly.

See this tutorial on the keyword super :

http://download.oracle.com/javase/tutorial/java/IandI/super.html

If you're still confused about how super works, then think about this. You can recode BadException with this code, and your program will still do exactly the same thing:

class BadException extends Exception
{
 BadException(String s)
 {
  super(s);
 }
}

This will also do the same thing:

class Test extends Throwable
{
 String message;
 Test(String msg)
 {
  message = msg;
 }
 public String toString() {
  return "BadException: " + message;
 }
}

class BadException extends Test
{
 BadException(String s)
 {
  super(s);
 }
}

Answer 2

When you throw new BadException("not eatable"); you're instantiating a new BadException, which sets its member variable food to the string "not eatable". Then the call to getError() will return that string.

It would be better style to to get rid of the food member variable and just make a call to super(String) since there is a constructor Exception(String message)

Answer 3

"super(s);" calls the super-class's constructor that takes one String. That is the Exception class.

If you take out "super(s);", then the compiler will implicitly put a "super();" call in there, because the super class has a default constructor. (That's why it's called a default constructor -- because it will get called by default if you don't specify anything else!)

Since that's the same as calling "super(null);", the message (which is in the variable "s") doesn't get passed up to the super class, and thus it isn't there to print out ..