Minor fixes to the static lab

Mostly the word "the"

Author: etremel

labs/Static/readme.md

@@ -4,14 +4,14 @@ title: Using static keyword
 
 # Static classes
 
-One use case for static classes is creating utility classes (or "helper class")
+One use case for static classes is creating utility classes (or "helper classes")
 that contain related and frequently-used methods; making those methods easily callable
-anywhere in the program. Some examples of static classes in C\# are `Math` and `Console` class.
+anywhere in the program. Some examples of static classes in C\# are the `Math` and `Console` classes.
 
-Pay attention to how these classes are used: 
+Pay attention to how these classes are used:
 
-- `Console` object is never instantiated before use
-- `WriteLine` method is called referring to the _name of the class_ (not object identifier)
+- A `Console` object is never instantiated before use
+- The `WriteLine` method is called referring to the _name of the class_ (not an object identifier)
 
 ```
 using System;
@@ -30,13 +30,13 @@ using System;
 
 class Program {
     static void Main() {
-        Console test = new Console();       
+        Console test = new Console();
     }
 }
 ```
 
 Indeed, it is _not possible_ to instantiate an object when a class is declared `static`.
-Further, if a class is declared static, all its members (attributes, methods, constructors, etc.) must also be declared `static`. 
+Further, if a class is declared static, all its members (attributes, methods, constructors, etc.) must also be declared `static`.
 
 ## Static Calculator
 
@@ -45,41 +45,41 @@ In your IDE create a new project. Then add a new class file called Calculator.cs
 In Calculator.cs:
 
 #. Declare a `static` class and name it `Calculator`.
-#. Add 5 `public` methods to `Calculator` class. Each method takes 2 arguments `x` and `y` of type `double`:
-    #. `Add` method that returns result of `x + y`.
-    #. `Subtract` method that returns result of `x - y`.
-    #. `Multiply` method that returns result of `x * y`.
-    #. `Divide` method that returns result of `x / y`.
-    #. `Modulo` method that returns result of `x % y`.
+#. Add 5 `public` methods to the `Calculator` class. Each method takes 2 arguments `x` and `y` of type `double`:
+    #. `Add` method that returns the result of `x + y`.
+    #. `Subtract` method that returns the result of `x - y`.
+    #. `Multiply` method that returns the result of `x * y`.
+    #. `Divide` method that returns the result of `x / y`.
+    #. `Modulo` method that returns the result of `x % y`.
 
-After implementing `Calculator`, 
+After implementing `Calculator`,
 
-#. Open the file that contains program's `Main` method
+#. Open the file that contains the program's `Main` method
 #. Paste the following code inside `Main` method:
 
     ```
     double x = 10d, y = 2d;
-    
+
     Console.WriteLine($"{x} + {y} = {Calculator.Add(x, y)}");
     Console.WriteLine($"{x} - {y} = {Calculator.Subtract(x, y)}");
     Console.WriteLine($"{x} * {y} = {Calculator.Multiply(x, y)}");
     Console.WriteLine($"{x} / {y} = {Calculator.Divide(x, y)}");
-    Console.WriteLine($"{x} % {y} = {Calculator.Modulo(x, y)}");      
+    Console.WriteLine($"{x} % {y} = {Calculator.Modulo(x, y)}");
     ```
-    
-    Again, notice how 
-    - no instance of `Calculator` is created before use, and 
+
+    Again, notice how
+    - no instance of `Calculator` is created before use, and
     - each `Calculator` method is called referring to the _name of the class_.
 
 #. Execute the program
-    - If your implementation of `Calculator` class matches the instructions, you will see meaningful output after executing the program. 
+    - If your implementation of `Calculator` class matches the instructions, you will see meaningful output after executing the program.
     - Otherwise review the instructions again and retrace your implementation steps to resolve any issues.
 
 # Static members in a non-static class
 
 A non-static class can contain both static and non-static class members.
 
-Study the following program implementation but \*do not\* execute it. 
+Study the following program implementation but \*do not\* execute it.
 After reading through the implementation, answer the questions below.
 
 Student.cs
@@ -90,28 +90,28 @@ using System;
 class Student {
 
     private int id;
-    private string name; 
+    private string name;
     private static string universityName = "Augusta University";
     private static int studentCount;
 
     public Student(int id, string name){
         this.id = id;
         this.name = name;
         studentCount++;
-    } 
+    }
 
     public static void DisplayStudentCount(){
         // does this work? uncomment to check
         // Console.WriteLine(name);
-        
+
         Console.WriteLine($"Number of students: {studentCount}");
     }
 
     public override string ToString(){
         return $"id: {id}\n"+
                $"name: {name}\n"+
                $"university: {universityName}";
-    }  
+    }
 }
 ```
 
@@ -129,37 +129,37 @@ class Program {
 
         Student.DisplayStudentCount(); // first time
 
-        Student bob = new Student(1112, "Bob");        
+        Student bob = new Student(1112, "Bob");
         Console.WriteLine(bob);
 
         Student.DisplayStudentCount(); // second time
     }
 }
 ```
 
-#. How many non-static attributes does `Student` class have?
-#. How many static attributes does `Student` class have?
-#. How many non-static methods does `Student` class have?
-#. How many static methods does `Student` class have?
+#. How many non-static attributes does the `Student` class have?
+#. How many static attributes does the `Student` class have?
+#. How many non-static methods does the `Student` class have?
+#. How many static methods does the `Student` class have?
 
 #. What is the output of each of the following lines in "Program.cs":
     #. `Console.WriteLine(alice);`
     #. `Student.DisplayStudentCount(); // first time`
     #. `Console.WriteLine(bob);`
     #. `Student.DisplayStudentCount(); // second time`
 
-#. if the `studentCount` attribute was \*not\* `static`, what would be the output of: 
+#. If the `studentCount` attribute was \*not\* `static`, what would be the output of:
     #. `Student.DisplayStudentCount(); // first time`
-    #. `Student.DisplayStudentCount(); // second time` 
-    
+    #. `Student.DisplayStudentCount(); // second time`
+
 #. When a class contains both static and non-static members, is it possible to refer to non-static members inside a static method?
-   For example, if we try to refer to `name` attribute inside `DisplayStudentCount`, will it work? Why or why not?
-      
+   For example, if we try to refer to  the `name` attribute inside `DisplayStudentCount`, will it work? Why or why not?
+
 Check your answers by creating a matching program in your IDE and executing it.
 
 To check the last question, in Student.cs, uncomment the following line and verify its behavior matches your answer:
 
 ```
 // Console.WriteLine(name);
-```` 
+````