diff --git a/part_4/exercise_1/exercise_1.md b/part_4/exercise_1/exercise_1.md
new file mode 100644
index 0000000000000000000000000000000000000000..3302516f541076ce86933216e5c3759a98140d92
--- /dev/null
+++ b/part_4/exercise_1/exercise_1.md
@@ -0,0 +1,202 @@
+In the project template for the exercise, there is an implementation in the [exercise1](https://gitlab.utu.fi/open-programming/advanced-course-in-object-oriented-programming-part-4/-/tree/main/exercise1) folder that includes the classes `Zipper` and `TestZipper`.
+The use of these classes is demonstrated in the `Exercise1` class. Your task is to interpret the given implementation and answer the following questions:
+
+## a) Go through each class in the implementation and describe which class construct it represents. Look carefully to find all the classes. The exercise intentionally includes code that appears difficult to increase the challenge of identification.
+
+### Answer:
+1. Class constructs in `Exercise1`:
+ - _Basic class_: `Exercise1`.
+
+
+2. Class constructs in `TestZipper`:
+ - _Basic class_: `TestZipper`.
+ - _Anonymous class_: a new class that extends `Handler`.
+ - _Function literals_: `s -> !s.isBlank()`: object of an anonymous class that implements interface `java.util.function.Predicate`.
+
+
+3. Class constructs in `Zipper`:
+ - _Basic class_: `Zipper`.
+ - _Static inner class_: `Handler`.
+
+## b) For each construct, explain why that particular construct was chosen. Describe which features of the construct are used why, and why another construct would not be suitable for the task.
+
+### Answer:
+1. **Class constructs in `Exercise1`**:
+ - _Basic class_: `Exercise1`:
+
+ It is chosen because it's a simple class.
+ Feature: inheritance.
+
+ + There is no relationship with other classes -> `Static Inner Class`, `Nested Class`, `Anonymous Class`, `Function literals and interfaces`, `Closed class` are not suitable.
+ + There is no predefined values -> `Enum` is not suitable.
+ + We can also use `Record` as there is no property in the class.
+
+
+2. **Class constructs in `TestZipper`**:
+ - _Basic class_: `TestZipper`:
+
+ It is chosen because it's a simple class that is expected to extend another class.
+ Feature: inheritance.
+
+ + `Static Inner Class`, `Nested Class` are not suitable as the parent class has not known (and does not need to know) the implementation of its child class.
+ + There is no child class -> `Closed class` is not suitable.
+ + `Function literals and interfaces` is not suitable as there is no interface in this case.
+ + There is no predefined values -> `Enum` is not suitable.
+ + Can not use `Record` as `Records` cannot extend any other class.
+ + We can also use `Anonymous Class` in the `Exercise1` instead, but then it'll be more complex.<br /><br />
+
+ - _Anonymous class_: a new class that extends `Handler`.
+
+ It is chosen because there is no desire to define a new specific class (as we have already had the TestZipper).
+ Feature: can be created anywhere inside the class.
+
+ + There is no desire to define a new class -> `Basic class`, `Record`, `Enum`, `Static Inner Class`, `Nested Class`, `Closed class` are not suitable.
+ + `Function literals and interfaces` is not suitable as there is no interface in this case.<br /><br />
+
+ - _Function literals_: `s -> !s.isBlank()`: object of an anonymous class that implements interface `java.util.function.Predicate`.
+
+ It is chosen because we don't want to create a new class that implements an interface which has only 1 method.
+ Feature: apply literal to case where the class is an interface defining a single method.
+
+ + There is no desire to define a new class -> `Basic class`, `Record`, `Enum`, `Static Inner Class`, `Nested Class`, `Closed class` are not suitable.
+ + We can use `Anonymous Class`, but it's longer, not easy to read, more complex.
+
+
+3. **Class constructs in `Zipper`**:
+ - _Basic class_: `Zipper`.
+
+ It is chosen because it's an abstract class (as we want to extend the funtionality).
+ Feature: inheritance.
+
+ + There is no parent class -> `Static Inner Class`, `Nested Class` are not suitable.
+ + We don't want (don't concern) to limit the child class -> `Closed class` is not suitable.
+ + `Anonymous Class`, `Function literals and interfaces`, `Enum`, `Records` are not suitable as we want to extend our class.<br /><br />
+
+ - _Static inner class_: `Handler`.
+
+ It is chosen because there is a relationship between `Zipper` and `Handler` and we want to be able to create a new instance of `Handler` without creating a new instance of `Zipper`, we also want to be able to extend the `Handler`.
+ Features:
+ Inner and outer classes are syntactically related.
+ The inner class has no connection to the (outer classes) outer objects.
+
+ + `Basic class` is not suitable as there is no meaning when the `Handler` exists without the `Zipper`.
+ + `Nested Class` is not suitable as we want to be able to create a new instance of `Handler` without creating a new instance of `Zipper`.
+ + We don't want (don't concern) to limit the child class -> `Closed class` is not suitable.
+ + `Anonymous Class`, `Function literals and interfaces`, `Enum`, `Records` are not suitable as we want to extend our class.
+
+## c) It is said that the temporary directory has a finite lifespan. How does the concept of the directory's lifespan relate to the classes defined in the implementation?
+
+### Answer:
+- In the class `Zipper`, the temporary directory is created in the constructor. In our case, a new temporary directory is created when an instance of `TestZipper` is created, it's because the constructor of `TestZipper` call the constructor of `Zipper`.
+- The `Zipper` implements interface `java.lang.AutoCloseable` (with `close()` method). The `TestZipper` extends `Zipper` -> `TestZipper` also implements `java.lang.AutoCloseable` and inherits the `close()` method of `Zipper`. When the `close()` method is called, the directory and its files are deleted.
+- In the `Exercise1` constructor, an instance of `TestZipper` is created, and it's also the resource of `try-with-resources` (as it implements `java.lang.AutoCloseable`). The `try-with-resources` statement ensures that each resource is closed at the end of the statement -> `TestZipper::close()` method is called at the end of the statement -> `Zipper::close()` is called -> temporary directory is deleted.
+- The flow is:
+```
+ `Exercise` ------- new TestZipper(zipFile) -----------------> `TestZipper` ----- super(zipFile) ------> `Zipper` -----------> temporary directory is created.
+ `Exercise` ------- finish try with resource, call close() --> `TestZipper` ----- close() -------------> `Zipper` -----------> delete temporary directory.
+```
+
+## d) Why does the class signature for Handler include the keywords protected abstract static class Handler and how can the word static be appropriate in this context?
+
+### Answer:
+- `protected`: because we want to use the `Handler` in a subclass of `Zipper` that is outside `Zipper` package. For example: use `Handler` in `fi.utu.tech.ooj.exercise4.exercise2.TestZipper2` which does not have the same package: `fi.utu.tech.ooj.exercise4.exercise1`.
+- `abstract`: because we want the child class implements the method `handle()`.
+- `static`: the application still works without the `static` keyword.
+ + The reasons for `static` are reusability, and separation of concern as we want to create a subclass of `Handler` without the need to create a subclass of `Zipper`.
+ + For example if we want to handle both file and directory:
+
+`FileHandler.java` similar to before:
+```java
+package fi.utu.tech.ooj.exercise4.exercise1;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.regex.Pattern;
+
+public class FileHandler extends Zipper.Handler {
+ private final Path tempDirectory;
+
+ public FileHandler(Path file, Path tmpDirectory) {
+ super(file);
+ this.tempDirectory = tmpDirectory;
+ }
+
+ @Override
+ public void handle() throws IOException {
+ var regex = Pattern.compile("\\W");
+ var contents = Files.readString(file);
+ var lines = Files.readAllLines(file);
+ var firstLine = lines.isEmpty() ? "unknown" : lines.getFirst();
+ var words = regex.splitAsStream(contents).filter(s -> !s.isBlank()).map(String::toLowerCase).toList();
+
+ System.out.printf("""
+
+ Originally was fetched from %s.
+ The founded file is %s.
+ The file contains %d lines.
+ The file contains %d words.
+ Possible title of the work: %s
+
+ """,
+ tempDirectory,
+ file.getFileName(),
+ lines.size(),
+ words.size(),
+ firstLine
+ );
+ }
+}
+```
+<br />
+
+`DirectoryHandler.java`:
+```java
+package fi.utu.tech.ooj.exercise4.exercise1;
+
+import java.io.IOException;
+import java.nio.file.Path;
+
+public class DirectoryHandler extends Zipper.Handler {
+ private final Path tempDirectory;
+
+ public DirectoryHandler(Path file, Path tempDirectory) {
+ super(file);
+ this.tempDirectory = tempDirectory;
+ }
+
+ @Override
+ public void handle() throws IOException {
+ System.out.println("Directory: " + tempDirectory);
+ }
+}
+
+```
+<br />
+
+`TestZipper.java`:
+```java
+package fi.utu.tech.ooj.exercise4.exercise1;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+class TestZipper extends Zipper {
+ TestZipper(String zipFile) throws IOException {
+ super(zipFile);
+ }
+
+ @Override
+ protected Handler createHandler(Path file) {
+ if (Files.isDirectory(file)) {
+ return new DirectoryHandler(file, tempDirectory);
+ }
+
+ return new FileHandler(file, tempDirectory);
+ }
+}
+
+```
+
+So, now we have `FileHandler` and `DirectoryHandler`, they are separate, each class has each responsibility, and it's easy for testing.
\ No newline at end of file