Exceptions and Assertions

Author: turingfly

Java-8/src/exceptionsAndAssertions/Assertions.java

@@ -0,0 +1,38 @@
+package exceptionsAndAssertions;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 11, 2017 11:25:30 AM
+ * 
+ *         An assertion is a Boolean expression that you place at a point in
+ *         your code where you expect something to be true.
+ * 
+ *         assert boolean_expression; 
+ *         assert boolean_expression: error_message;
+ * 
+ *         If assertions are disabled, Java skips the assertion and goes on in
+ *         the code. 
+ *         If assertions are enabled and the boolean expression is
+ *         true, then our assertion has been validated and nothing happens. The
+ *         program continues to execute in its normal manner. 
+ *         If assertions are enabled and the boolean expression is false, then 
+ *         our assertion is invalid and a java.lang.AssertionError is thrown.
+ *         
+ *         1. Internal Invariants You assert that a value is within a certain constraint. 
+ *         assert x < 0 is an example of an internal invariant.
+ *         2. Class Invariants You assert the validity of an object’s state. 
+ *         Class invariants are typically private methods within the class that return a boolean. 
+ *         The upcoming Rectangle class demonstrates a class invariant.
+ *         3. Control Flow Invariants You assert that a line of code you assume is unreachable is never reached. 
+ *         The upcoming TestSeasons class demonstrates a control  ow invariant.
+ *         4. Preconditions You assert that certain conditions are met before a method is invoked.
+ *         5. Post Conditions You assert that certain conditions are met after a method executes successfully.
+ */
+public class Assertions {
+	public static void main(String[] args) {
+		int numGuests = -5;
+		assert numGuests > 0;
+		System.out.println(numGuests);
+	}
+}

Java-8/src/exceptionsAndAssertions/CommonExceptionTypes.java

@@ -1,8 +1,5 @@
 package exceptionsAndAssertions;
 
-import java.io.FileNotFoundException;
-import java.text.NumberFormat;
-
 /**
  * 
  * @author chengfeili 
@@ -40,12 +37,28 @@ public void runtimeException() {
 
 		// IllegalArgumentException
 		throw new IllegalArgumentException("must not be negative");
+		
+		// ArrayStoreException
+		
+		// DateTimeException
+		
+		// MissingResourceException
+		
+		// IllegalStateException
+		
+		// UnsupportedOperationException
 	}
 
 	public void checkedException() {
 		// FileNotFoundException // subclass of IOExcepption
 
 		// IOException;
+		
+		// ParseException  Converting a String to a number
+		
+		// NotSerializableException
+		
+		// SQLException
 	}
 
 	public void errors() {

Java-8/src/exceptionsAndAssertions/CreatingCustomExceptions.java

@@ -0,0 +1,25 @@
+package exceptionsAndAssertions;
+
+/**
+ * 
+ * @author chengfeili
+ * Jun 11, 2017 10:42:54 AM
+ *
+ *	extend Exception(for checked)
+ *	extend RuntimeException(for unchecked)
+ *
+ */
+
+public class CreatingCustomExceptions extends Exception {
+	public CreatingCustomExceptions() {
+		super();
+	}
+
+	public CreatingCustomExceptions(Exception e) {
+		super(e);
+	}
+
+	public CreatingCustomExceptions(String message) {
+		super(message);
+	}
+}

Java-8/src/exceptionsAndAssertions/TryWithResources.java

@@ -0,0 +1,112 @@
+package exceptionsAndAssertions;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 11, 2017 11:21:42 AM
+ *
+ *         Remember that only a try-with-resources statement is permitted to
+ *         omit both the catch and finally blocks. A traditional try statement
+ *         must have either or both.
+ */
+public class TryWithResources {
+	/**
+	 * 
+	 * The new try-with-resources statement automatically closes all
+	 * resources opened in the try clause. This feature is also
+	 * known as automatic resource management, because Java
+	 * automatically takes care of the closing.
+	 *             
+	 * The resources created in the try clause are only in scope within the try block. 
+	 */
+	public void newApproach(Path path1, Path path2) throws IOException {
+		try (BufferedReader in = Files.newBufferedReader(path1); 
+				BufferedWriter out = Files.newBufferedWriter(path2)) {
+			out.write(in.readLine());
+		}
+	}
+}
+
+/**
+ * AutoCloseable
+ * 
+ * You can’t just put any random class in a try-with-resources statement. Java
+ * commits to closing automatically any resources opened in the try clause.
+ *
+ */
+class TurkeyCage implements AutoCloseable {
+	public void close() {
+		System.out.println("Close gate");
+	}
+
+	public static void main(String[] args) {
+		try (TurkeyCage t = new TurkeyCage()) {
+			System.out.println("put turkeys in");
+		}
+	}
+}
+
+/**
+ * 
+ * What happens if the try block also throws an exception? Java 7 added a way to
+ * accumulate exceptions. When multiple exceptions are thrown, all but the first
+ * are called suppressed exceptions.
+ *
+ */
+class JammedTurkeyCage implements AutoCloseable {
+	public void close() throws IllegalStateException {
+		throw new IllegalStateException("Cage door does not close");
+	}
+	// print 
+	// caught: turkeys ran off 
+	// Cage door does not close
+	public static void main(String[] args) {
+		try (JammedTurkeyCage t = new JammedTurkeyCage()) {
+			throw new IllegalStateException("turkeys ran off");
+		} catch (IllegalStateException e) {
+			System.out.println("caught: " + e.getMessage());
+			for (Throwable t : e.getSuppressed())
+				System.out.println(t.getMessage());
+		}
+	}
+}
+
+/**
+ * 
+ * Resources are closed after the try clause ends and before any catch/finally clauses.
+ * Resources are closed in the reverse order from which they were
+ * created.
+ *
+ * Print: 
+ * Close: 2 
+ * Close: 1 
+ * ex 
+ * finally
+ */
+class Auto implements AutoCloseable {
+	int num;
+
+	Auto(int num) {
+		this.num = num;
+	}
+
+	public void close() {
+		System.out.println("Close: " + num);
+	}
+
+	public static void main(String[] args) {
+		try (Auto a1 = new Auto(1); Auto a2 = new Auto(2)) {
+			throw new RuntimeException();
+		} catch (Exception e) {
+			System.out.println("ex");
+		} finally {
+			System.out.println("finally");
+		}
+	}
+}

Java-8/src/exceptionsAndAssertions/UsingMultiCatch.java

@@ -0,0 +1,37 @@
+package exceptionsAndAssertions;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDate;
+import java.time.format.DateTimeParseException;
+
+/**
+ * 
+ * @author chengfeili
+ * Jun 11, 2017 10:45:57 AM
+ *
+ */
+public class UsingMultiCatch {
+	public static void main(String[] args) {
+		try {
+			Path path = Paths.get("a.txt");
+			String text = new String(Files.readAllBytes(path));
+			LocalDate date = LocalDate.parse(text);
+			System.out.println(date);
+		} catch (DateTimeParseException | IOException e) {
+			e.printStackTrace();
+			throw new RuntimeException(e);
+		}
+		
+		/**
+		 *
+		try {
+			throw new IOException();
+			} catch(IOException | RuntimeException e) {
+			e = new RuntimeException(); // DOES NOT COMPILE
+			}
+		*/
+	}
+}