Add dms lecture notes

docs/lectures/dms/01_java_collections.md

@@ -0,0 +1,135 @@
+# Java Collections
+
+Week 3 (Oct 5th)
+
+**Part 1**
+
+In java a *collection* is an object that represents a group of objects.
+The collections API is a unified framework for representing and manipulating collections independently of their implementation.
+
+An *API* (application programming interface) is an interface protocol between a client and a server, intended to simplify the client side software.
+
+A *library* contains re-usable chunks of code.
+
+**Java Collections framework**
+- We have container objects that contain objects
+- All containers are either "collections" or "maps"
+- All containers provide a common set of method signatures, in addition of their unique set of method signatures
+
+*Collection* - Something that holds a dynamic collection of objects
+*Map* - Defines mapping between keys and objects (two collections)
+*Iterable* - Collections are able to return an iterator objects that can scan over the contents of a collection one object at a time
+
+NOTE: Vector is a legacy structure in Java replaced with *ArrayList*
+      Stack is now *ArrayDeque*
+
+`LinkedList(Collection<? extends E> c)` - means some type that either is E or a subtype of E. The `?` is a wildcard.
+
+```java
+public static void main(String[] args) {
+     LinkedList list = new LinkedList();
+     list.add("string");
+     String s = (String)list.getFirst();
+     System.out.println(s);
+}
+```
+
+This is bad coding practice, the collection constructor are not able to specify the type of objects the collection is intended to contain. A `ClassCastException` will be thrown if we attempt to cast the wrong type.
+
+```java
+public static void main(String[] args) {
+     LinkedList<String> list = new LinkedList<>();
+     list.add("string");
+     String s = list.getFirst();
+     System.out.println(s);
+}
+```
+
+This is a type safe collection using generics.
+- Classes support generics by allowing a type variable to be included in their declaration.
+- The `<>` show the same type as stated (in this case string)
+- You cannot type a collection with a primitive data type eg int
+
+**HashMap Class**
+- A HashMap is a hash table based implementation of the map interface. This implementation provides all if the optional map operations, and permits null values and the null key.
+
+```java
+public static void main(String[] args) {
+     HashMap<String, Integer> userData = new HashMap<>();
+	 userData.put("Emma", 30);
+	 userData.put("John", null);
+	 userData.put("Millie", 17);
+
+	 Set<String> keys = userData.keySet();
+
+	 for (String key:keys){
+	 	System.out.println(key + "=" userData.get(key));
+	 }
+}
+```
+
+```
+Emma = 30
+John = null
+Millie = 17
+```
+
+**Part 2**
+
+__Relationships between objects__
+
+*Aggregation* - The object exists outside the other. It is created outside so it is passed as an argument.
+An animal object *is part of* a compound object (semantically) but the animal object can be shared and if the  compound object is deleted, the animal object isn't deleted.
+
+```java
+public class Compound {
+	private Animal dog;
+
+	public void setAnimal(Animal dog){
+		this.dog = dog;
+	}
+}
+```
+
+![Image](assets/1.png)
+
+*Composition* - The object only exists if the parent object exists, if the parent object is deleted then so is the child object.
+The zoo object owns the compound object. If the zoo object is deleted then the compound object is also deleted.
+
+```java
+public class Zoo {
+	private Compound dogArea = new Compound();
+}
+```
+
+![Image](assets/2.png)
+
+**Inheritance**
+A way of forming new classes based on existing classes. Has a "is-a" relationship.
+
+*Polymorphism* - A concept in object oriented programming. Method overloading and method overriding are two types of polymorphism.
+- *Method Overloading* - Methods with the same name co-exist in the same class but they must have different method signatures. Resolved during compile time (static binding).
+- *Method Overriding* - Methods with the same name is declared in parent and child class. Resolved during runtime (dynamic binding).
+
+```java
+public class Child extends Parent {
+	public Child(String name){
+		super(name);
+	}
+	
+	@Override
+	Public void eat() {
+		chew();
+	}
+}
+```
+
+The super keyword called the parent class' constructor.
+
+![Image](assets/3.png)
+
+**What is the difference between an abstract class and an interface**
+- Java abstract class can have instance methods that implement a default behaviour. May contain non-final variables.
+- Java interfaces have methods that are implicitly abstract and cannot have implementations. Variables are declared final by default.
+
+Interfaces are less restrictive when it comes to inheritance, interfaces can have many levels of inheritance where as a class can only have one level.