CS 112D Lecture Notes - Object-Oriented Programming (OOP)

OOP Basics

• class - a datatype to define an object. (Classification.) Your book is sloppy and often calls these "objects".
• object - a variable storing an instance of a class. An object is a special kind of variable that is like a package containing many things inside. It has multiple values inside it, and it also can have functions as part of it. These values are called attributes, properties, instance variables, or member variables; these functions are called methods, or member functions.
• Members of a class are the data (attributes) and functions (methods) within a class
• Encapsulation is combining into a single unit both the data and the functions that operate on the class data (the class's members). Such a unit is called an object.
• Object-oriented programming (OOP) is a programming style based on defining your own classes and using them to encapsulate and manipulate data.
• Instantiation is the process of creating a new object (an instance of a class)
• An object is a single instance of a class
  Example: We could define a rectangle class. When we assign values to each of the data members of the class, we have instantiated (defined) a specific rectangle object.
• Information Hiding - An object’s member functions typically provide the only way to access its data. If you want access to an object’s member data, you call a member function in the object’s class. The data is hidden from non-member functions.
• Interface - The way a class is instantiated and used. The interface consists of the set of public class members and what they're used for. It's the information one needs to utilize a class.
• Implementation - The way a class works "under the hood". The implementation is the private code (hidden information) which makes the interface work.
• Deprecation - Deprecation is the process of making a feature obsolete. This can relate to classes or any other aspect of programming. If you get a compiler warning saying so-and-so is deprecated, it means you should avoid using this feature, because it's no longer the best way to do things.

Polymorphism

• One of the major advantages of object oriented programming is what's called polymorphism. To understand what that is, let's look at some definitions:
• Inheritance - When one class is derived from another. This is the "a-kind-of" relationship -- when a specific class is defined which is a kind of a more general class of objects (e.g. a circle is a kind of shape).
• Parent or Super-class - A class whose member variables and functions are inherited by another class (by its child class).
• Child or Derived Class, or Sub-class - A class which inherits some of its member variables and functions from another class (from its parent class). The VB keyword Inherits is used when defining a sub-class.
• Polymorphism - The ability to treat a class like its parent class. So a function can be written to take a parameter of a particular parent class, but this function may be called with an argument of any of that class's derived classes. Since the derived classes get some of their behavior from their parent, this behavior can be used in a general way by such a function.
• You can test whether an object is of a particular type with the TypeOf...Is operator. . The syntax is

     TypeOf <object expression> Is <TypeName>

  When TypeName specifies an interface type then the TypeOf ... Is operator returns true if the object implements the interface type. When the TypeName is a class type then the operator returns true if the object is an instance of the specified class or is an instance of a class that derives from the specified class. For example:

    Dim x As Button
    x = New Button()
    If TypeOf x Is Control Then
       ' Insert code to continue program execution.
    

  Since the type of x is Button, and Button inherits from Control, the TypeOf x Is Control expression evaluates to True.

Reference Variables, Memory Allocation, and Variable Scope

• A reference variable stores the memory address of a variable It's similar to the C++ concept of a pointer. Unlike C++ pointers, reference variables do not need to be de-referenced.
• Dynamic Memory Allocation - making space for new variables in the middle of program execution. Dynamically allocated variables are allocated on the heap. Ordinary, or Automatic variables are allocated on the stack, as part of a function call.
• new - a keyword used to dynamically allocate memory for an object. Returns a reference to that object.
• Reference variables themselves (not the objects they refer to) are stored on the stack along with primitive variables.
• Variables on the stack go out of scope at the end of the function in which they were declared.
• Variables on the heap are globally available, and only the garbage collector can delete them. (When no more reference variables refer to them.) Garbage collection happens as needed, so unreferenced objects may not be destroyed immediately.
• Nothing - keyword indicating an empty reference. I.e. a reference variable whose value is Nothing is one that doesn't refer to an object. In other languages this is called "null".
• All reference variables are set to Nothing until made to refer to a new or pre-existing object.
• Trying to call a method on a Nothing reference will generate a run-time error (an exception).
• Example: add a button with the following code to the CarPayment Calculator form:

          Dim newForm As New FrmCarPayment()
          newForm.Show()
    

  Then try removing the word "New", moving the "New" declaration to the next line, changing the reference variable's data type to "System.Windows.Forms.Form", etc.
• To compare to reference values, use the operator "Is" instead of "=". E.g.:

          Dim newForm As FrmCarPayment
          If Not newForm Is Nothing Then ' avoid error if newForm doesn't refer to an object
              newForm.Show()
          End If
    

Return to the main CS 112D page