self define exceptions

fishercoder1534 · fishercoder1534 · commit cb20cde3e78e · 2016-08-06T10:51:10.000-07:00
diff --git a/RandomProblems/src/sporadic/exceptionsCanBeSelfDefined/SteveSunException.java b/RandomProblems/src/sporadic/exceptionsCanBeSelfDefined/SteveSunException.java
@@ -0,0 +1,32 @@
+package sporadic.exceptionsCanBeSelfDefined;
+
+/**
+ * Base exception for all kinds of exceptions that I wrote myself for fun.
+ * 
+ * This turns out to be a standard way to define a self-defined exception: you
+ * should define these four constructors!
+ */
+
+public class SteveSunException extends RuntimeException {
+
+    /**
+     * 
+     */
+    private static final long serialVersionUID = 1L;
+
+    public SteveSunException() {
+        super();
+    }
+
+    public SteveSunException(String message) {
+        super(message);
+    }
+
+    public SteveSunException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public SteveSunException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/RandomProblems/src/sporadic/exceptionsCanBeSelfDefined/UnderstandExceptionTryCatch.java b/RandomProblems/src/sporadic/exceptionsCanBeSelfDefined/UnderstandExceptionTryCatch.java
@@ -0,0 +1,54 @@
+package sporadic.exceptionsCanBeSelfDefined;
+
+/**
+ * This is a simple program to help myself better understand what it really
+ * means to catch/throw an exception.
+ * 
+ * "catch" means to catch the possible exception while executing that method, if
+ * the potential exception is not caught in time, the calling method will be
+ * interrupted, and all the calling trace up to the main method will be
+ * interrupted subsequently, then the whole program is interrupted/stopped.
+ * 
+ * But with catch statement, the possible exception is caught, or in other
+ * words, the exception is being handled/taken care of. Thus the calling method
+ * and the whole program could continue. Cool! p.s. swallow the exception just
+ * means not to catch it.
+ * 
+ * This "catch" block can be kind of equivalent to "throws" statement in the
+ * method definition/declaration, I can do either one, It's just that "throws"
+ * cannot catch that exception, but it lets the compiler be aware that it's
+ * possible that this method will throw an exception.
+ * 
+ * However, with a "throw" statement, I throw this caught exception back to the
+ * running program, this way, the program will be interrupted/stopped again!
+ */
+
+public class UnderstandExceptionTryCatch {
+
+	private static void divide(int a, int b) {
+		try {
+			System.out.println(a / b);
+		} catch (ArithmeticException ae) {
+			System.out.println("It enters ArithmeticException branch.");
+			ae.printStackTrace();
+			// throw ae;
+		} catch (RuntimeException re) {
+			System.out.println("It enters RuntimeException branch.");
+			re.printStackTrace();
+			// throw re;
+		} catch (Exception e) {
+			System.out.println("It enters Exception branch.");
+			e.printStackTrace();
+			// throw e;
+		} catch (Throwable t) {
+			System.out.println("It enters Throwable branch.");
+			t.printStackTrace();
+			// throw t;
+		}
+	}
+
+	public static void main(String[] args) {
+		divide(2, 0);
+		System.out.println("That's the end of the program!");
+	}
+}
