More work on classes and functions

Author: SGOTI2

lessons/functions-in-classes.md

@@ -82,11 +82,11 @@ In the example above, this line below might look a little familiar.
 ```java
 Elevator elevator = new Elevator();
 ```
-It's creating a variable! The data type of the variable here is not one of the one's you've learned before, but instead one we defined ourselves. `Elevator` is the class that the variable is. In order to make it's value the class it expects, we have to construct a new instance of the class.   
-Constructing the instance is done with teh `new` word and then the class name with parentheses. What's happening here is that we are calling the class's constructor. We didn't declare a custom constructor, so it's going to use the default functionality of purely creating a new instance of the class.  
+It's creating a variable! The data type of the variable here is not one of the one's you've learned before, but instead one we defined ourselves. `Elevator` is the class that the variable is. In order to make it's value the class it expects, we have to construct a new instance of the class, aka a object.   
+Constructing the object is done with the `new` word and then the class name with parentheses. What's happening here is that we are calling the class's constructor. We didn't declare a custom constructor, so it's going to use the default functionality of purely creating a new instance of the class.  
 You may also notice that there are 2 other classes that we construct: `DigitalInput` and `Encoder`. We didn't create those classes, however, they are provided to us via libraries. We'll discuss libraries later. In their constructing, you can see them accepting arguments. 
 
-### Objects & Instances
+### Objects
 When one constructs a class, they are merely creating a new instance of the class. Let's look at another example to see what I mean.
 ```java
 // Counter.java
@@ -109,6 +109,48 @@ public class Main {
   }
 }
 ```
+The `counter1` and `counter2` objects are diffrent instances of the counter class, and they each have their own memebers and functions. Although they are the same internally, the values of the variables within them are diffrent.
 
 ## Le Dot
-Explain what the dot does, or smthn idk. I gotta keep workin on this.
+We've been using this syntax in the examples here but I just haven't been saying anything about it yet.
+
+The dot lets us get memebers and functions in objects. For example, we can access the `count` member (aka variable) of the `counter1` object by doing: `counter1.count`. We can then use it like any other variable, assigning values or reading its value. However this only works if the memeber was set to `public`. In cases where we don't want this functionality, we would mark it as `private`.  
+You've also seen it when you do `System.out.println()`, you are calling the `println` function on the `out` object inside of the `System` object. We can make our own functions like so.
+
+```java
+// Counter.java
+class Counter {
+    private int count = 0;
+
+    public void incrementCount() {
+        count += 1;
+    }
+
+    public void decrementCount() {
+        count -= 1;
+    }
+
+    public int getCount() {
+        return count;
+    }
+}
+
+// Main.java
+public class Main {
+  public static void main(String[] args) {
+    Counter counter1 = new Counter();
+
+    counter1.increment();
+    System.out.println(counter1.getCount());  // 1
+
+    counter1.decrement();
+    System.out.println(counter1.getCount());  // 0
+
+    counter1.decrement();
+    System.out.println(counter1.getCount());  // -1
+  }
+}
+```
+Although it might seem like having memebers like `count` private just makes the code more complicated, I'd argue that it helps to protect features from unintended minipulation, particularly when we get to state machines.  
+
+The next lesson will go into some details about how java strucutres things and we'll look at code that might resemble what our robots code might look like. 

lessons/structure.md

@@ -0,0 +1,9 @@
+---
+layout: default
+title: Structure
+---
+# Java Structure
+
+> # WIP
+
+Yap yap, packages, imports, classes, enums, robot code?