"Today we finished the labs on matrix manipulation that we began shortly after talking about your test review handout. We began these two sessions by reviewing extension and super calls. Specifically, we emphasized that super can be a constructor method call or an object depending on the context in which it is being used [super() vs. super., respectively]. This was key to solving that problem. We also discussed pointers in that handout, which are the memory locations in which data structures are stored. Whenever any object is created in Java, a pointer to that object is created. The gibberish numbers and letters that print when you type System.out.print(objectName) without a valid .toString() method represent the pointer, or memory address, for that object. When using the simple assignment operator = on such objects, the pointer for the target object will be changed. As a consequence, two object labels can sometimes become linked to the same block of memory, such that changes to the block through one object label will be reflected in .get()-type calls to the other object label. Using the simple assignment operator with complex objects is sometimes called passing by address. To figure out the presently stored value of object labels whose memory locations are shifting, just follow the pointers; if the object is pointing to its own unique memory, it will be unaffected by modifications to other objects. If that object label is at some point assigned the memory location of another object label, those object labels will become linked to the same object in memory. With respect to matrices, a key point of consideration with matrices is that a matrix in Java is an array of arrays. Thus, when we take matrix[index], we get the indexth array in matrix, and when we take matrix[index][arrayIndex], we get the arrayIndex'th element of the indexth array of matrix. Thus, matrices are accessed via calls of the form matrix[row][column]. In your mind, you can logically consider a matrix as matrix[] (array of arrays), although you may never write it that way because Java will be confused. The primary focus of the labs was building matrices, analyzing their contents (counting them, finding maximums, identifying magic squares, etc.), and displaying matrices. In an abstract sense, we came to see that manipulating and displaying matrices is almost exactly the same as managing arrays, except that there is an extra field which references the index of each array that comprises a matrix, which often demands some sort of nested looping in order to access the entire structure. We were also reminded to pay attention to our bounds. In a couple situations we needed to avoid attempting certain modifications by using conditionals to determine when our modifications would and would not occur. This is a recurring theme throughout programming, and thus worth remembering."