Various examples of having errors thrown relative to the Error class

[Robert Liguori]

The Error class is the superclass for over 30 classes; http://docs.oracle.com/javase/7/docs/api/

I though it would be nice to create a thread that highlighted how different errors can be produced.

I'm starting this thread with the easy OutOfMemoryError condition. If anyone wants to add examples for different types of errors, go for it!

Error produced: OutOfMemoryError
Error message seen: Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

Code to produce error:

public void forceOutOfMemoryError() {
    Integer counter = 0;
    ArrayList<Integer> unstoppable = new ArrayList<>();

    while (true) {
      unstoppable.add(counter);
      counter++;
      if (counter % 10000 == 0) {
        System.out.println(counter);
      }
    }
  }
}

[Rohtak Dev]

Hi ,

I have tried to create java.lang.AbstractMethodError from table 9-4 as mentioned in the exercise.
Here's how i was able to create the error:


here's the code:
#1 created and compiled an interface

package com.rohtakdev.chapter9;

public interface Glass{}

#2 Implemented that interface and compiled it.

package com.rohtakdev.chapter9;

import com.rohtakdev.chapter9.Glass;

public class GlassCup implements Glass{
}

#3 Then changed interface to have a new method and compiled; didn't compile inplementing class.

package com.rohtakdev.chapter9;

public interface Glass{
public void something();
}

#4 created a class with main method, initialized class and called new interface method.

package com.rohtakdev.chapter9;

import com.rohtakdev.chapter9.Glass;
import com.rohtakdev.chapter9.GlassCup;

public class MainGlass{
public static void main(String[] args){
try{
Glass glass = new GlassCup();
glass.something();
}catch(AbstractMethodError ame){
System.out.println("caught exception "+ ame);
}
}
}

I was able to successfully catch the exception.

Thanks for a great book.

[Ortell Johnson]

Forced Assertion Error!!!

Whenever using assertions you need to make them visible by sending the -ea flag to the command-line.
And, the -ea flag needs to come directly after the java command.
This took me a long time to determine the problem! In the end there was no problem at all. I had placed the -ea flag after the class name and the JVM was not recognizing the flag.

This is what the incorrect command looked like:

java AssertionErrorClass -ea

This is what the successful command looked like:

java -ea AssertionErrorClass

Here is the code I wrote to force the assertion error:

/**
 * This is Exercise 9-5 in the OCA Java SE7 Book on page 368
 * Created by Kent O. Johnson
 * This forces an Assertion Error to occur
 * 2-22-2013
 */
 
 public class AssertionErrorClass {
	public static void main(String[] args) {
		AssertionErrorClass aec = new AssertionErrorClass();
		aec.forceAssertionError();
		System.out.println(aec.numberisSix(10));
		
	}//end main method
	
	int test = 0;
	
	public AssertionErrorClass() {
		this.test = 10;
	}//end constructor
	
	public void forceAssertionError() {
		assert numberisSix(test):"number is not six";		
	}//end assertion error tester method
	
	public boolean numberisSix(int number){
		return number==6;
	}//end boolean checker method "numberisSix" 
 }//end class AssertionErrorClass

Finally, here is the error from my command prompt!

 c:\dev\training\java\oca\ch09>java -ea AssertionErrorClass
Exception in thread "main" java.lang.AssertionError: number is not six
        at AssertionErrorClass.forceAssertionError(AssertionErrorClass.java:23)
        at AssertionErrorClass.main(AssertionErrorClass.java:11)

Thank you Mr. Liguori and thank you to your co-author Mr. Finegan! This book was exactly what I needed.
I enjoyed the exercises that told me to go to the Java API or to do my own thing. The open ended question model, put with some of the more structured questions, stimulated my critical thinking about how to answer the question.

I will be finished with Chapter 10 by Saturday and plan to take the exam next week!

[Geroen Joris]

StackOverflowError, which is quite easy to recreate. Just think of a recursive function which creates a huge stack in the VM, and it'll ultimately crash. I've did it with the Fibonacci sequence, with Integer.MAX_VALUE.

package eu.droidit;

/**
 * Runner to recreate a StackOverflowError
 * 
 * Done with a recursive function using the Fibonacci sequence.
 * http://en.wikipedia.org/wiki/Fibonacci_number
 * 
 * @author Geroen Joris - DroidIT
 * @link www.droidit.eu
 *
 */

public class StackOverflowErrorRunner {

	public static void main(String[] args) {
		fibonacciSequenceToTriggerStackOverflowError(Integer.MAX_VALUE);
	}

	private static int fibonacciSequenceToTriggerStackOverflowError(int maxValue) {
		return fibonacciSequenceToTriggerStackOverflowError(maxValue - 1) 
				+ fibonacciSequenceToTriggerStackOverflowError(maxValue - 2);
	}

}

[Eduardo Ucha]

Hello,

I have chosen the NoClassDefFoundError, I used the exercise that I had to do a personal exception to do this.
I have a MainClass.java and a MiException.java and I compile it.

javac MiException.java MainClass.java

Before I run the program I do a dir (I am running in windows), and I get:

27/03/2013 09:08 <DIR> .
27/03/2013 09:08 <DIR> ..
27/03/2013 09:08 704 MainClass.class
27/03/2013 09:05 391 MainClass.java
27/03/2013 09:08 372 MiException.class
27/03/2013 08:30 255 MiException.java
4 archivos 1.722 bytes
2 dirs 183.944.970.240 bytes libres

I am going to delete the MiException.class file.

del MiException.class

and then i run the program.

java MainClass

Then i get my exception

Exception in thread "main" java.lang.NoClassDefFoundError: MainClass (wrong name
: com/ocaj/exam/tutorial/MainClass)
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClass(Unknown Source)
at java.security.SecureClassLoader.defineClass(Unknown Source)
at java.net.URLClassLoader.defineClass(Unknown Source)
at java.net.URLClassLoader.access$100(Unknown Source)
at java.net.URLClassLoader$1.run(Unknown Source)
at java.net.URLClassLoader$1.run(Unknown Source)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at sun.launcher.LauncherHelper.checkAndLoadMain(Unknown Source)

Thanks for the book.

[Tom McGovern]

/**
 * The following code causes a StackOverflowError,
 * through a recursive call to a parameterized class constructor.
 */
public class StackOverflow {
    // a counter is used to identify each instance of the StackOverflow object
    private int count;
    
    /* start the whole thing off:
     *   using the parameterized construtor to create
     *   the first StackOverflow object with count = 0
     */
    public static void main(String[] args) {
        StackOverflow so = new StackOverflow(0);
    }

    // parameterized constructor
    public StackOverflow(int count) {
        this.count = count;
        /* announce the creation of the object,
         * displaying the instance count identifier
         */
        System.out.println("StackOverflow object " + this.count + " created");
        try {
            /* try to create another StackOverflow object using
             * a recursive call to the StackOverflow constructor
             * incrementing the count identifier
             */
            StackOverflow sc = new StackOverflow(this.count + 1);
        } catch (StackOverflowError e) {
            /* catch, and display the name of, the StackOverflowError object
             * 
             *   java.lang.StackOverflowError
             * 
             * caught by the object
             */
            System.out.print("\n" + e.toString());
            System.out.println(" caught by StackOverflow object " + this.count);
        } finally {
            /* use the finally block before control is passed back
             * to the previous object.
             */
            System.out.print("Finally! StackOverflow object " + this.count);
        }
        System.out.println(" is done");
    }
}

[Mike Rocha]

IOError
Thrown when a serious I/O error has occurred

Issue: I wanted to upload my ascii input file mentioned below, but this web app prohibits it
Question: can someone let me know how to do it (if it's possible)?

---

1Z0-803 OCA Java SE 7 Study Guide
Ch. 9, p. 364a, Exercise 9-5
Section 8, Item 5
Recognize common exception classes and categories
Illustrates: [difficulty in] creating an error condition

---

This class (Exercise9_5) tries to force an IOError through the following steps.

It opens a connection to the input file stored on a thumb drive.

It enters a slow loop to read a character at a time from the file.

During the slow loop, I pull the thumb drive on which the input file resides.

I expect the sudden abscence of the thumb drive to produce an IOError.

Result: I could not force an IOError. However, I did empirically verify the default buffer size.

---

Use this directory structure to build with the command lines I supply below.
(Dir structure from DOS command "tree /a ." - I had to substitute dots for spaces to get the proper alignment)
Q:\
+---src
|...+---main
|.......+---java
\---target
....+---classes
....+---generated-docs

Put the source in Q:\src\main\java\Exercise9_5.java

Put the input file on a thumb drive in something like F:\Exercise9_5.txt

To compile this source file ...
Q:\src\main\java>javac -d ..\..\..\target\classes Exercise9_5.java
To run the compiled byte code ...
Q:\src\main\java>java -cp ..\..\..\target\classes Exercise9_5
To create the javadocs for this class ...
Q:\src\main\java>javadoc -d ..\..\..\target\generated-docs -private Exercise9_5.java

---

Some comments:

Sorry I couldn't actually produce the IOError. I'm still trying different ways to force one ... will post it when I find it.

I thought others might benefit from seeing my employment of the book's lessons in my code.

I spent a lot of time figuring out how to "javadoc" my code. Others might benefit from what I learned by looking at the example docs in my code.

1Z0-803 preparation summary

I began the book 13 Feb 2013 ... reached this example 26 Apr 2013

Spent 1 hour studying in the morning on average 4 days a week.

2 to 3 hours studying in the evening on average 2 nights a week.

Spent 6 to 8 hours studying on weekends on average

My goal was to practice coding as much as possible, to the point where I can compile in my head.

Toward my goal, I typed in, compiled, corrected (when necessary), and ran every example in the book.

Result
I feel confident about taking the test
Will practice with Enthuware starting in a day or 2.
This book is a valuable learning tool.

Finally, here's my code

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
 * <hr>
 * <b>1Z0-803 OCA Java SE 7 Study Guide</b><br>
 * Ch. 9, p. 364a, Exercise 3-3<p>
 * Section 8, Item 5<br>
 * Recognize common exception classes and categories<p>
 * <u>Illustrates</u>: [difficulty in] creating an error condition<p>
 * <hr>
 * This class tries to force an <code>IOError</code> through the following steps.<p>
 * <ol>
 *   <li>It opens a connection to the input file stored on a thumb drive.</li>
 *   <li>It enters a slow loop to read a character at a time from the file.</li>
 *   <li>During the slow loop, I pull the thumb drive on which the input file resides.</li>
 *   <li>I expect the sudden abscence of the thumb drive to produce an IOError.</li>
 * </ol><p>
 * Result: I could <b>not</b> force an IOError. However, I did empirically verify the default buffer size.<p>
 * <hr>
 * Notes about input file:
 * <ul>
 *   <li>The "input" file, with name <code>Exercise9_5.txt</code>, holds only ASCII characters.</li>
 *   <li>The input file contains 10 sections.</li>
 *   <li>Each section consists of 27 lines, 102 characters each, for a sub-total of 2754 <code>char</code>s.</li>
 *   <li>So, the 10 sections contain a total of 27540 <code>char</code>s. I (roughly) confirmed this with
 *       a counter that gave a <code>char</code> count of 27538.</li>
 *   <li>I purposely made the input file with this many <code>char</code>s. It is about 3 times the size of 
 *       (what I read is) the
 *       default buffer size for commonly used JSE7 IO classes (8k). This gave me enough <code>char</code>s
 *       to verify the default buffer size for myself empirically.</li>
 * </ul><br>
 * <hr>
 * Notes about using this example:
 * <ul>
 *   <li>This source file resides in <code>Q:\src\main\java\Exercise9_5.java</code>
 *   <li>The input file resides on a thumb drive at <code>F:\Exercise9_5.txt</code>
 *   <li>I execute the command lines from the directory <code>Q:\src\main\java</code> 
 *       (see "Notes about command lines:" below)
 *   <li>I use the Maven recommended directory structure convention. For this project, 
 *       it exists as follows...</li>
 * <pre>
 *  Q:\
 *  +---src
 *  |   +---main
 *  |   |   +---assembly
 *  |   |   +---config
 *  |   |   +---filters
 *  |   |   +---java
 *  |   |   |   +---com
 *  |   |   |   |   \---ocajexam
 *  |   |   |   |       +---craft_simulator
 *  |   |   |   |       \---tutorial
 *  |   |   |   |           \---planets
 *  |   |   |   \---logs
 *  |   |   +---resources
 *  |   |   +---scripts
 *  |   |   \---webapp
 *  |   +---site
 *  |   \---test
 *  |       +---filters
 *  |       +---java
 *  |       \---resources
 *  \---target
 *      +---classes
 *      |   \---com
 *      |       \---ocajexam
 *      |           \---tutorial
 *      +---docs
 *      +---generated-docs
 *      |   \---resources
 *      +---iutest-classes
 *      +---test-classes
 *      \---test-reports
 * </pre>
 * </ul>
 * <hr>
 * Notes about command lines:
 * <ul>
 *   <li>To compile this source file ...<br>
 *       <code>Q:\src\main\java>javac -d ..\..\..\target\classes Exercise9_5.java</code></li>
 *   <li>To run the compiled byte code ...<br>
 *       <code>Q:\src\main\java>java -cp ..\..\..\target\classes Exercise9_5</code></li>
 *   <li>To create the javadocs for this class ...<br>
 *       <code>Q:\src\main\java>javadoc -d ..\..\..\target\generated-docs -private Exercise9_5.java</code></li>
 * </ul><br>
 */
public class Exercise9_5 {
	/**
	 * the name of our input file kept on a thumb drive
	 */
	private static final String INPUT_FILENAME = "F:\\Exercise9_5.txt";
	
	/**
	 * my explicit, no-arg, public constructor
	 */
	public Exercise9_5() {
		super();
	}
	
	/**
	* The entry point for this exercise class.<p>
	* @param args the standard array of <code>String</code> objects for method <code>main</code>
	*/
	public static void main (String[] args) {

		// need a static local instance of this class to call non-static methods
		Exercise9_5 ch9ex95 = new Exercise9_5();

		System.out.println();

		// Print section header
		System.out.println("********************************************");
		System.out.println("********* IOError using FileReader *********");
		System.out.println("********************************************");
		
		System.out.println();
		
		System.out.println("ch9ex95.forceIOErrorFR();");
		
		System.out.println();
		
		ch9ex95.forceIOErrorFR(INPUT_FILENAME);

	}
	
	/**
	 * This method facilitates trying to force an <code>IOError</code> using 
	 * a <code>FileReader</code>.<p> A call to <code>Thread.sleep(1)</code> by this
	 * method slows
	 * the loop just enough to give you time to pull the thumb drive in an attemp
	 * to force the <code>IOError</code>.
	 * @param filename the absolute path and filename to the input file.
	 */
	private void forceIOErrorFR(String filename) {
		int count = 0;
		try (FileReader fr = new FileReader(filename)) {
			while (fr.ready()) {
				System.out.print((char)fr.read());
				Thread.sleep(1);
				count++;
			}
		} catch (FileNotFoundException fnfe) {
			System.out.println("Caught a FileNotFoundException: trying to open file \"" + INPUT_FILENAME);
		} catch (IOException ioe) {
			System.out.println("Caught an IOException: count-->" + count + "<--");
			ioe.printStackTrace();
		} catch (InterruptedException ie) {
			System.out.println("Caught an InterruptedException");
		} finally {
			System.out.println();
			System.out.println("forceIOErrorFR(): in finally, counted -->" + count + "<-- chars");
		}
	} // end forceIOErrorFR()
}