It passes

src/main/java/rocks/zipcode/AlphaCharDocument.java

@@ -1,20 +1,24 @@
 package rocks.zipcode;
 
 import java.io.IOException;
+import java.util.regex.Pattern;
 
 /**
  * @author leon on 16/11/2018.
  */
 public class AlphaCharDocument extends Document {
-    public AlphaCharDocument(String fileName) throws IOException {
+    public AlphaCharDocument(String fileName) {
         super(fileName);
     }
 
     @Override
     public void write(String contentToBeWritten) {
+        if (isAlpha(contentToBeWritten)) {
+            super.write(contentToBeWritten);
+        } else throw new IllegalArgumentException("Only alpha, baby");
     }
 
     private Boolean isAlpha(String s) {
-        return null;
+        return Pattern.matches("[a-zA-Z\\s]*", s);
     }
 }

src/main/java/rocks/zipcode/Document.java

@@ -1,64 +1,103 @@
 package rocks.zipcode;
 
 import java.io.*;
-import java.nio.file.Files;
-import java.util.Arrays;
 import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * @author leon on 16/11/2018.
  */
 public class Document implements DocumentInterface {
 
-    private final FileWriter fileWriter;
     private final File file;
 
-    public Document(String fileName) throws IOException {
+    public Document(String fileName) {
         this(new File(fileName));
     }
 
-    public Document(File file) throws IOException {
+    public Document(File file) {
         this.file = file;
-        this.fileWriter = new FileWriter(file);
     }
 
     @Override
     public void write(String contentToBeWritten) {
+        BufferedWriter fileWriter = null;
+        try {
+            fileWriter = new BufferedWriter(new FileWriter(file));
+            fileWriter.write(contentToBeWritten);
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            if (fileWriter != null) {
+                try {
+                    fileWriter.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+
+        }
     }
 
     @Override
-    public void write(Integer lineNumber, String valueToBeWritten) {
+    public void write(Integer lineNumber, String valueToBeWritten) throws IllegalStateException {
+        List<String> textList = toList();
+        textList.set(lineNumber,valueToBeWritten);
+        String newText = String.join("\n", textList);
+        write(newText);
     }
 
     @Override
     public String read(Integer lineNumber) {
-        return null;
+        return toList().get(lineNumber);
     }
 
     @Override
     public String read() {
-        return null;
+        Stream<String> textStream = getStringStream();
+        return textStream.map(s -> s.toString()).collect(Collectors.joining("\n"));
+    }
+
+    private Stream<String> getStringStream() {
+        BufferedReader buffy = null;
+        try {
+            buffy = new BufferedReader(new FileReader(file));
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+        return buffy.lines();
     }
 
     @Override
     public void replaceAll(String stringToReplace, String replacementString) {
+        String newString = read().replaceAll(stringToReplace,replacementString);
+        write(newString);
     }
 
     @Override
     public void overWrite(String content) {
+        this.write(content);
     }
 
     public List<String> toList() {
-        return null;
+        Stream<String> textStream = getStringStream();
+        return textStream.collect(Collectors.toList());
     }
 
     @Override
     public File getFile() {
-        return null;
+        return file;
     }
 
     @Override
     public String toString() {
-        return null;
+        String fileName = file.getPath();
+        String contentToBeWritten = read();
+        return new StringBuilder(fileName)
+                .append("{")
+                .append(contentToBeWritten)
+                .append("}")
+                .toString();
     }
 }

src/main/java/rocks/zipcode/DocumentInterface.java

@@ -1,6 +1,7 @@
 package rocks.zipcode;
 
 import java.io.File;
+import java.io.IOException;
 import java.util.List;
 
 /**
@@ -13,7 +14,7 @@ public interface DocumentInterface {
 
     String read(Integer lineNumber);
 
-    String read();
+    String read() throws IOException;
 
     void replaceAll(String stringToReplace, String replacementString);
 

src/main/java/rocks/zipcode/NumericCharDocument.java

@@ -1,20 +1,24 @@
 package rocks.zipcode;
 
 import java.io.IOException;
+import java.util.regex.Pattern;
 
 /**
  * @author leon on 16/11/2018.
  */
 public class NumericCharDocument extends Document {
-    public NumericCharDocument(String fileName) throws IOException {
+    public NumericCharDocument(String fileName) {
         super(fileName);
     }
 
     @Override
     public void write(String contentToBeWritten) {
+        if (isNumeric(contentToBeWritten)) {
+            super.write(contentToBeWritten);
+        } else throw new IllegalArgumentException("Only numeric, baby");
     }
 
     private Boolean isNumeric(String s) {
-        return null;
+        return Pattern.matches("[\\d\\s]*", s);
     }
 }

src/main/java/rocks/zipcode/SpecialCharDocument.java

@@ -1,20 +1,24 @@
 package rocks.zipcode;
 
 import java.io.IOException;
+import java.util.regex.Pattern;
 
 /**
  * @author leon on 18/11/2018.
  */
 public class SpecialCharDocument extends Document {
-    public SpecialCharDocument(String fileName) throws IOException {
+    public SpecialCharDocument(String fileName) {
         super(fileName);
     }
 
     @Override
     public void write(String contentToBeWritten) {
+        if (isSpecialCharacters(contentToBeWritten)) {
+            super.write(contentToBeWritten);
+        } else throw new IllegalArgumentException("Only special, baby");
     }
 
     private Boolean isSpecialCharacters(String s) {
-        return null;
+        return Pattern.matches("[\\W_]*", s);
     }
 }