Fixing polymorphism notes.

Author: Clément

source/code/projects/Polymorphism1/Polymorphism1/Class2.cs

@@ -0,0 +1,12 @@
+class Class2 : Class1
+{
+    public string Property2 { get; set; }
+    
+    public Class2(string p1P, string p2P, string a1P){
+      base.SetAttribute1(a1P);
+      // The following would not work.
+      // attribute1 = a1P;
+      base.Property1 = p1P;
+      Property2 = p2P;
+    }
+}

source/code/projects/Polymorphism1/Polymorphism1/ClassHelper.cs

@@ -6,13 +6,9 @@ static void Main()
     object1.SetAttribute1("Test");
     object1.Property1 = "Test";
 
-    Class2 object2 = new Class2();
-    object2.SetAttribute1("Test");
-    object2.Property1 = "Test";
-    object2.Property2 = "Test";
-
-    ClassHelper.Method1(object1);
-    ClassHelper.Method1(object2);
-    ClassHelper.Method2(object2);
+    Class2 object2 = new Class2("property1", "property2", "attribute1");
+    object2.SetAttribute1("Attribute1");
+    object2.Property1 = "Property1";
+    object2.Property2 = "Property2";
   }
 }

source/code/projects/Polymorphism1/Polymorphism1/Program.cs

@@ -16,11 +16,11 @@ While the example below is abstract, it can be easily instantiated to e.g., a `C
 
 Consider the following two classes:
 
-```
+```{download="./code/projects/Polymorphism1.zip"}
 !include code/projects/Polymorphism1/Polymorphism1/Class1.cs
 ```
 
-```
+```{download="./code/projects/Polymorphism1.zip"}
 !include code/projects/Polymorphism1/Polymorphism1/Class2.cs
 ```
 
@@ -43,32 +43,35 @@ Note, however, that
 
 Stated differently, an object in `Class2` *is a(n object in)* `Class1`, but the converse is not true: an object in `Class1` *is not* an object in `Class2`.
 
+
+In addition, observe that the `Class2` constructor *cannot* access `class1`'s `attribute1` directly, since it is marked as `private`: it needs to use the `SetAttribute1` method.
+
 ## Polymorphism and References
 
 Note that a `Class1` object can be created using a `Class2` constructor, since an object in `Class2` *is a(n object in)* `Class1`.
 Formally, we can write:
 
 ```
-Class1 object3 = new Class2();
+Class1 test = new Class2("property1", "property2", "attribute1");
 ```
 
-and then manipulate `object3` like any other *object from `Class1` (it is, in a way, "truncated").
+and then manipulate `test` like any other *object from `Class1` (it is, in a way, "truncated").
 In particular, we can use
 
 ```
-object3.Property1 = "Test";
+test.Property1 = "Test";
 ```
 
-but `object3.Property2 = "Test";` would not compile *since we would be trying to access a property of `Class2` with a `Class1` object.*
-Remember that an object in `Class1` *is not* an object in `Class2`, and that the way we declared it, `object3` *is* a `Class1` object.
+but `test.Property2 = "Test";` would not compile *since we would be trying to access a property of `Class2` with a `Class1` object.*
+Remember that an object in `Class1` *is not* an object in `Class2`, and that the way we declared it, `test` *is* a `Class1` object.
 
 ## Solving Ambiguity by Overriding
 
 ### For Methods
 
 Now, consider the following class implementation and usage:
 
-```
+```{download="./code/projects/Polymorphism2.zip"}
 !include code/projects/Polymorphism2/Polymorphism2/Class.cs
 ```