Die Anleitung zu Java Exception

View more Tutorials:

1- Was ist Exception?

Zuerst sehen wir das unten  Beispiel:

Im Beispiel gibt es eine fehlerhafte Code wegen der Devision durch 0. Die Devision durch O ergibt eine Ausnahme : ArithmeticException
HelloException.java
package org.o7planning.tutorial.exception;

public class HelloException {

	public static void main(String[] args) {

		System.out.println("Three");

		// Diese Division hat kein Problem.
		int value = 10 / 2;

		System.out.println("Two");

		// Diese Division hat kein Problem.
		value = 10 / 1;

		System.out.println("One");

		// Diese Division hat ein Problem (durch 0 dividieren).
		// Der Fehler passiert hier.
		value = 10 / 0;

		// Und die folgende Code wird nicht durchgeführt
		System.out.println("Let's go!");

	}

}
Ergebnis des Beispiel:

Sie können die Fehler Warnung auf den Bildschirm  Console, Die Warnung ist sehr klar und detailiert, sie zeigt wo liegt die Fehler (in welcher Zelle in Code)
Sehen Sie die Thread von Programm durch das Beispiel.
  • Das Programm läuft normal von dem Schritt (1),(2) bis  (5)
  • Bei Schritt (6) findet der Fehler von Devision durch 0 statt.
  • Das Programm tritt die Funktion main aus und die Code Zelle (7) wird nicht durchgeführt

Wir korrigieren die Code von dem obengenannten Beispiel

HelloCatchException.java
package org.o7planning.tutorial.exception;

public class HelloCatchException {

	public static void main(String[] args) {

		System.out.println("Three");

		// Diese Division hat ganz kein Problem.
		int value = 10 / 2;

		System.out.println("Two");

		// So geht es auch diese Division.
		value = 10 / 1;

		System.out.println("One");

		try {
			// Diese Division hat ein Problem (durch 0 dividieren). 
			// Der Fehler passiert hier.
			value = 10 / 0;

			// Die Code wird nicht implementiert.
			System.out.println("Value =" + value);

		} catch (ArithmeticException e) {
			// Die Code in catch werden implementiert.
			System.out.println("Error: " + e.getMessage());

			// Die Code in catch werden implementiert.
			System.out.println("Ignore...");

		}

		// Diese Code wird implementiert.
		System.out.println("Let's go!");

	}

}
Ergebnis des Beispiel
Wir erklären durch das folgende Beispiel die Thread des Programms.
  • Die Schritte (1)-(5) sind ganz normal.
  • Die Ausnahme passiert bei dem Schritt (6), das Problem sind die Devision durch 0.
  • Sofort führt sie die Befehl in catch durch, die Schritt (7) wird ignoriert.
  • Die Schritte (8),(9) werden durchgeführt.
  • Die Schritte (10) wird durchgeführt.

2- Das hierarchische System der Ausnahme (Exception)

Das ist die hierarchische Diagramm von Exception im Java.
  • Class im höchste Level ist Throwable
  • Die 2 direkte Tochterclass sind Error und Exception.
In dem Zweig  Exception gibt es einen kleinen Zweig RuntimeException, der als Ausnahme bei der Zeitpunkt von Complier durch Java gecheckt wird. Die Bedeutung von gescheckt und nichtgecheckt bei der Zeitpunkt von Complier wird in die nächsten Beispiele
Beachten Sie: Ihre custom Class soll die Inheritance aus 2 Zweige Error oder Ex ception geschrieben werden, nicht direkt aus Throwable geschrieben.

Error

Wenn die dynamic Link fehlt oder ein ernstes Problem in der Virtuelle Maschine passiert, wird ein Error benachrichtigt. Die typischen Programm Java soll die Error nicht zeichen. Darüber hinaus ist es unwahrscheinlich, dass das typische Java Programm die Error wirft
Zum Beispiel über die dynamic Link : Sie rufen nach der Bibliothek, aber die Bibliothek mangelt an class, oder methode... in diesem Fall wird Error geworfen.

Exceptions

Meiste Programm, das die Error werfen und fangen, sind die Kinder der class Exception. Die Exception zeigt ein Problem aber das Programm ist nicht systematisch ernst. Meiste von Ihnen geschriebenen Programms werfen und fangen Exception.

     Class Exception hat viele Tochterclass, die in der Java package definiert werden. Die Nachwuchs für die Ausnahme können passieren. Zum Beispiel NegativeArraySizeException wird geworfen wenn Sie ein Array zu erstellen versuchen. aber mit der negativen Element

    Ein Ausnahmeclass hat eine besondere Bedeutung in der Java Sprache: RuntimeException.

Runtime Exceptions

Class RuntimeException vertretet die Ausnahme bei dem Laufen des Programms. Ein Beispiel:  die Ausnahme der Laufenzeit    NullPointerException passiert wenn Sie die Methode oder Field eines Object durch ein Reference n ull zugreifen. Mit diese Ausnahme ist es besser, die Objekt nicht null zu checken als die Ausnahme zu finden
Denn die Ausnahme von der Laufenzeit ist sehr üblich und es ist nicht effizient wenn wir versuchen,sie zu fangen oder bestimmen. Die Complier der Java checkt während der Code Komplierung diese Ausnahme nicht
Java definiert einige class  RuntimeException. Sie können die sowie Ausnahme fangen (catch) wie die übliche Fangen. Die Methode, die RuntimeException werfen können, erfordert auf ihre Definition nicht zu melden. Außerdem können Sie die untergeordneten class   RuntimeException für Sie erstellen

3- Die Ausnahme durch try-catch fangen

Wir schreiben eine Exception - die Inherintance aus class Exception.
AgeException.java
package org.o7planning.tutorial.exception.basic;

public class AgeException extends Exception {

  public AgeException(String message) {
      super(message);
  }

}
TooYoungException.java
package org.o7planning.tutorial.exception.basic;

public class TooYoungException extends AgeException {

 public TooYoungException(String message) {
     super(message);
 }

}
TooOldException.java
package org.o7planning.tutorial.exception.basic;

public class TooOldException extends AgeException {

 public TooOldException(String message) {
     super(message);
 }

}
Und class AgeUtils hat die static methode zur Prüfung der Alter
AgeUtils.java
package org.o7planning.tutorial.exception.basic;

public class AgeUtils {

	// Diese Methode prüft das Alter.
	// Wenn das Alter weniger als 18 ist, 
	// wird sie eine Ausnahme TooYoungException werfen
	// Wenn das Alter mehr als 40 ist, 
	// wird sie eine Ausnahme TooOldException werfen
	public static void checkAge(int age) throws TooYoungException, TooOldException {
		if (age < 18) {
			// Wenn das Alter weniger als 18 ist, wird eine Ausnahme geworfen
			// Diese Methode endet hier.
			throw new TooYoungException("Age " + age + " too young");
		} else if (age > 40) {
			// Wenn das Alter mehr als 40 ist, wird eine Ausnahme geworfen.
			// Diese Methode endet hier.
			throw new TooOldException("Age " + age + " too old");
		}
		// Wenn das Alter im Raum vom 18-40 liegt, wird die Code geläuft
		System.out.println("Age " + age + " OK!");
	}
}

Checked Exception & Unchecked Exception:

  • AgeException ist das Kind von Exception, TooOldException und TooYoungException sind 2 direkt untergeordneten Class von AgeException, so sind sie "Checked Exception"
  • In der method AgeUtils.checkAge(int) werden die Ausnahmen geworfen. So sollen Sie durch die Keywort "throws" auf die Meldung der method die Ausnahmen listen. Oder können Sie in Überblick die Ausnahme melden
    • throws Exception.
  • Bei dem Ort, wo AgeUtils.checkAge(int) benutzen, sollen wir auch die Ausnahmen fangen oder außer Zyklus werfen
"Checked exception" wird von "Java Compiler" geprüft.
Sie haben 2 Behandlungsoption:
  1. Weiter ins die außere Zyklus werfen
  2. Durch try-catch fangen und lösen
TryCatchDemo1.java
package org.o7planning.tutorial.exception.basic;

public class TryCatchDemo1 {

	public static void main(String[] args) {

		// Beginnen einzustellen.
		System.out.println("Start Recruiting ...");
		// Das Alter prüfen.
		System.out.println("Check your Age");
		int age = 50;

		try {

			AgeUtils.checkAge(age);

			System.out.println("You pass!");

		} catch (TooYoungException e) {

			// hier etwas machen ..
			System.out.println("You are too young, not pass!");
			System.out.println(e.getMessage());

		} catch (TooOldException e) {
			// hier etwas machen
			System.out.println("You are too old, not pass!");
			System.out.println(e.getMessage());

		}

	}
}
das Beispiel unten: Wir werden durch eine Ausnahme in dem höheren Level die gemeinsame Ausnahmen fangen. In höheren Level werden diese Ausnahme und anderen untergeordneten Ausnahme gefangen
TryCatchDemo2.java
package org.o7planning.tutorial.exception.basic;

public class TryCatchDemo2 {

	public static void main(String[] args) {

		// Beginnen einzustellen
		System.out.println("Start Recruiting ...");
		// Ihr Alter prüfen.
		System.out.println("Check your Age");
		int age = 15;

		try {
			// Das kann eine Ausnahme TooOldException oder TooYoungException werfen
			AgeUtils.checkAge(age);

			System.out.println("You pass!");

		} catch (AgeException e) {
			// Wenn die Ausnahme passiert wie das Typ von AgeException, 
			// wird das Block catch geläuft
			System.out.println("Your age invalid, you not pass");
			System.out.println(e.getMessage());

		}
	}
}
Sie können die unterschiedlichen Ausnahmen in einer catch zu behandeln sammeln wenn sie die gleiche Behandlungsweise in der Logic Ihres Programms haben
TryCatchDemo3.java
package org.o7planning.tutorial.exception.basic;

public class TryCatchDemo3 {

	public static void main(String[] args) {

		System.out.println("Start Recruiting ...");

		System.out.println("Check your Age");
		int age = 15;

		try {
			// Das kann die Ausnahme TooOldException oder TooYoungException verursachen
			AgeUtils.checkAge(age);

			System.out.println("You pass!");

		} catch (TooYoungException | TooOldException e) {
			// Viele Ausnahme in catch fangen
			System.out.println("Your age invalid, you not pass");
			System.out.println(e.getMessage());

		}
	}

}

4- Der Block try-catch-finally

Oben gewöhnen wir an dem Error fangen durch try-catch. Die volle Behandlung mit der Ausnahme ist try-catch-finally.
try {

   // hier etwas machen
} catch (Exception1 e) {

   // hier etwas machen
} catch (Exception2 e) {

   // hier etwas machen
} finally {

   // Das Block finally wird immer implementiert.
   // Hier etwas machen
}
TryCatchFinallyDemo.java
package org.o7planning.tutorial.exception.basic;

public class TryCatchFinallyDemo {

	public static void main(String[] args) {

		String text = "001234A2";

		int value = toInteger(text);

		System.out.println("Value= " + value);

	}

	public static int toInteger(String text) {
		try {

			System.out.println("Begin parse text: " + text);

			// Das kann die Ausnahme NumberFormatException verursachen.
			int value = Integer.parseInt(text);

			return value;

		} catch (NumberFormatException e) {

			// Falls 'text' nicht eine Zahl ist, wird das Block catch implementiert werden.
			System.out.println("Number format exception " + e.getMessage());

			// Wenn NumberFormatException passiert, gibt es 0 rück
			return 0;

		} finally {

			System.out.println("End parse text: " + text);

		}
	}

}
Dies ist der Ablauf des Programm . Block finally wird immer durchgeführt.

5- Eine Ausnahme (Exception) in einer anderen Ausnahme packen

Wir brauchen einige Class für die Darstellung dieses Beispiel:
  • Person: Bezeichnung der Bewerber einer Firma mit den Informationen
    • Name, Alter, Geschlecht.
  • GenderException: Ausnahme der Geschlecht.
  • ValidateException: Ausnahme der Schätzung der Bewerber .
  • ValidateUtils: Class mit static method schätzt, ob die Bewerber die Anforderung befriedigen.
    • Die Leute in der Alter von 18-40
    • Männlich.
Person.java
package org.o7planning.tutorial.exception.wrap;

public class Person {

  public static final String MALE = "male";
  public static final String FEMALE = "female";

  private String name;
  private String gender;
  private int age;

  public Person(String name, String gender, int age) {
      this.name = name;
      this.gender = gender;
      this.age = age;
  }

  public String getName() {
      return name;
  }

  public void setName(String name) {
      this.name = name;
  }

  public String getGender() {
      return gender;
  }

  public void setGender(String gender) {
      this.gender = gender;
  }

  public int getAge() {
      return age;
  }

  public void setAge(int age) {
      this.age = age;
  }
}
GenderException.java
package org.o7planning.tutorial.exception.wrap;

// Die Ausnahme von dem Geschlecht
public class GenderException extends Exception {
 
      public GenderException(String message)  {
    	  super(message);
      }
}
Class ValidateException packen eine andere Exception ein.
ValidateException.java
package org.o7planning.tutorial.exception.wrap;

public class ValidateException extends Exception {
	
	// Die Ausnahme einpacken
	public ValidateException(Exception e)  {
		super(e);
	}

}
ValidateUtils.java
package org.o7planning.tutorial.exception.wrap;

import org.o7planning.tutorial.exception.basic.AgeUtils;

public class ValidateUtils {

	// Die Methode zur Prüfung einer Person.
	public static void checkPerson(Person person) throws ValidateException {
		try {

			// Das Alter prüfen.
			// Gültig wenn zwischen 18-40
			// Diese Methode kann TooOldException,TooYoungException werfen.
			AgeUtils.checkAge(person.getAge());

		} catch (Exception e) {

			//  Wenn nicht gültig, die Ausnahme durch ValidateException einpacken und werfen (throw).
			throw new ValidateException(e);

		}

		// Wenn diese Person die Frau ist, d.h es ist nicht gültig
		if (person.getGender().equals(Person.FEMALE)) {

			GenderException e = new GenderException("Do not accept women");
			throw new ValidateException(e);

		}
	}

}
WrapperExceptionDemo.java
package org.o7planning.tutorial.exception.wrap;

public class WrapperExceptionDemo {

	public static void main(String[] args) {

		// Ein Kandidat.
		Person person = new Person("Marry", Person.FEMALE, 20);

		try {

			// Die Ausnahme kann hier passieren.
			ValidateUtils.checkPerson(person);

		} catch (ValidateException wrap) {

			// Den echten Grund nehmen.
			// Es kann TooYoungException, TooOldException, GenderException sein.
			Exception cause = (Exception) wrap.getCause();

			if (cause != null) {
				System.out.println("Not pass, cause: " + cause.getMessage());
			} else {
				System.out.println(wrap.getMessage());
			}

		}
	}

}

6- RuntimeException und die Sub-Klasse

Class RuntimeException und die untergeordneten class sind   "Unchecked exception". Sie wird von Java Complier bei der Komplierung nicht geprüft. In einigen Fall können Sie Ihre Exception aus Inheritance dieses Zweig schreiben. Einige Ausnahme im Zweig, die im Java sich vorhanden, können ignoriert werden.

Unten sind einige class von Zweig  RuntimeException (Natürlich sind das nicht alles).
Machen wir einige Beispiele für die Behandlung derselber Ausnahme.

6.1- NullPointerException

Hier ist die meist übliche Ausnahme und verursacht oft die Fehler für Programm.  Die Error wird geworfen wenn Sie method rufen oder in field eines noch nicht erstellten Object ( null object) zugreifen
NullPointerExceptionDemo.java
package org.o7planning.tutorial.exception.runtime;

public class NullPointerExceptionDemo {

	// Zum Beispiel: Das ist eine Methode, die das null String zurückgeben kann.
	public static String getString() {
		if (1 == 2) {
			return "1==2 !!";
		}
		return null;
	}

	public static void main(String[] args) {

		// Das ist eine Variable, deren Referenz nicht null ist.
		String text1 = "Hello exception";

		// Die Aufruf auf die Methode um die Länge des String zu entnehmen.
		int length = text1.length();

		System.out.println("Length text1 = " + length);

		// Das ist eine Variable mit dem null Referenz.
		String text2 = getString();

		// Die Aufruf auf die Methode um die Länge des String zu entnehmen.
		// NullPointerException wird hier passieren.
		// Das ist die Ausnahme, die in runtime auftritt (das Typ RuntimeException).
		// Der Kompiler (compiler) vom Java zwangt Sie bei der Compile-time sie zu fangen (catch)
		length = text2.length(); // ==> exception!

		System.out.println("Finish!");
	}

}
Ergebnis des Beispiel
In der Praxis können Sie wie die Behandlung der anderen Ausnahmen die  try-catch für das Error fangen zu behandeln. Allerdings sollen wir normalerweise prüfen, vor Benutzung  die Object nicht null zu bewähren.

Sie können die Code wie folgend korrigieren um NullPointerException zu vermeiden
// Die Methode getString() gibt eine Wert null zurück. 
// Das ist ein Objekt mit der null Referenz.
String text2 = getString();

// Prüfen um text2 nicht null sicherzustellen.
// Statt der Benutzung von try-catch.
if (text2 != null) {
  length = text2.length();
}

6.2- ArrayIndexOfBoundException

Das ist die Ausnahme wenn Sie die Element, deren Index im Array nicht gültig ist, zuzugreifen versuchen. Zum Beispiel Array hat 10 Elemente, Sie greifen aber die Element mit Index 20 zu.
ArrayIndexOfBoundsExceptionDemo.java
package org.o7planning.tutorial.exception.runtime;

public class ArrayIndexOfBoundsExceptionDemo {

	public static void main(String[] args) {

		String[] strs = new String[] { "One", "Two", "Three" };
		// Der Zugang zum Element in Index 0.
		String str1 = strs[0];

		System.out.println("String at 0 = " + str1);

		// Der Zugang zum Element in Index 5
		// ArrayIndexOfBoundsException passiert hier
		String str2 = strs[5];

		System.out.println("String at 5 = " + str2);

	}

}
Um ArrayIndexOfBoundsException zu vermeiden sollen Sie die Array prüfen anstatt Sie try-catch benutzen.
if (strs.length > 5) {
   String str2 = strs[5];
   System.out.println("String at 5 = " + str2);
} else {
   System.out.println("No elements with index 5");
}

View more Tutorials: