Apllied Programming

Applied Object-Oriented

Issues in Object-Oriented Programming

• Classes vs. Objects

Classes are templates that we use to create new objects.

Classes are the blueprints used to manufacture objects in your code.

The New() procedure is known as the class constructor.


• Object vs Object Variables Object Variables - all variables that refer to objects

The following statement declares a variable of the Customer type, but doesn't create an object:

Dim Cust as Customer

If you omit this keyword from a declaration, only a variable of the Customer type will be created, but no instance of the Customer class will be created in memory, and the variable won’t point to an actual object.


The Cust variable can be set later in the code to reference an existing instance of the class:

Dim Cust As Customer

Dim Cust2 As New Customer

Cust = Cust2

To set the Company property, you can use either one of the following statements because they both point to the same object in memory:

Cust.CompanyName = "New Company Name"

or

Cust2.CompanyName = "New Company Name"


It’s also common to declare object variables without the New keyword when you know you’re going to use them later in your code, as shown in the following loop, which creates 20 items and adds them to a ListView control:

Dim LI As ListViewItem

For row = 0 To 20

LI = New ListViewItem

LI.Text = "..."

‘ more statements to set up the LI variable

ListView1.Items.Add(LI)

Next


• Uninitialized and Nullable Variables- an object variable may exist but not be initialized. Dim B As SolidBrush

The “B” variable’s value is Nothing because it hasn’t been initialized yet. After executing the following statement, the “B” variable will have a value and can be used to draw

something:

B = New SolidBrush(Color.Blue)


• To find out whether a variable has been initialized or not, we use the Is operator to com-pare the variable to Nothing:

If B Is Nothing Then

MsgBox("Uninitialized Brush variable")

End If


Let’s consider an Integer and a String variable declared as follows:

Dim Age As Integer

Dim Name As String

•The Age and Name variables have not been initialized explicitly, but they do have a value.

•Integers are initialized to zero and strings are initialized to empty strings.


• A variable that has no value is not necessarily a numeric zero or an empty string. To differentiate between the default values and the lack of value, the Framework supports the Nullable type, which indicates a variable of any of the basic types that will not be initialized implicitly.

• The Nullable keyword is followed by a pair of parentheses and the Of keyword, followed by the actual type. The following statement declares an Integer variable that is not initialized:

Dim Age As Nullable(Of Integer)


Dim Age As Nullable(Of Integer)

’ other statements

Dim Qualifies As Boolean

If Age.HasValue Then

If Age.Value < 16 Then

Qualifies = False

Else

Qualifies = True

End If


• There’s also a shorthand notation for declaring Nullable types; just append a question mark to the variable’s name as in the following statement:

Dim Age? As Integer


• Exploring Reference TypesTo better understand how reference types work, consider the

following statements that append a new row with two subitems to a ListView control (the control’s item is an object of the ListViewItem type):

ListView1.Items.Clear

Dim LI As New ListViewItem

LI.Text = "Item 1"

LI.SubItems.Add("Item 1 SubItem 1.a")

LI.SubItems.Add("Item 1 SubItem 1.b")



• To actually remove the control’s first item, you must call the Remove method of the LI variable:

LI.Remove• This statement will remove the ListViewItem

object from the control’s Items collection, but

the actual object still lives in the memory. If you execute the following statement, the item will be added again to the control:



• Properties versus Fields

The following statement invokes the Property Set segment of the Email public property of the class:

cust.EMail = "[email protected]"


• Properties versus Fields

Every time you call one of the class properties, the corresponding public procedure in the class is invoked. The following statement invokes both the Set and Get Property procedures of the Customer class Balance property:

cust.Balance = cust.Balance+429.25


• Shared versus Instance MembersA shared property is common to all instances of the class.

In other words, there’s no local variable for this property, and all instances of the class access the same variable.

Shared methods, on the other hand, are quite common. The Math class is a typical example. To calculate the logarithm of a number, you call the Log method of the Math class:

Math.Log(123)


Dim cust As New Customer

cust.GetCustomerByID("ALFKI")

Debug.WriteLine cust.CompanyName

Debug.WriteLine cust.ContactName & " " & cust.ContactTitle


• a class may expose a few shared properties if all instances of the class should access the same property value.

• It may also expose a few shared methods, which can be called through the class name if there’s no need to create an instance of the class in order to call a method.


• In extreme situations, you can create a shared class:

• All properties and methods of this class are shared by default.

• To make the most of objects, however, you should create classes that are instantiated with the New keyword and methods that manipulate the current instance of the class.


• Type Casting- The data type used most in earlier versions of the

language up to VB 6 was the Variant (which was replaced in subsequent versions by the Object type).

- A variable declared as Object can store anything, and any variable that hasn’t been declared explicitly is an Object variable.

- When you retrieve an item from a ListBox control, for example, you get back an object, not a specific data type.


• Type Casting

- To use this object in our code, we had to convert it to a more specific type, the Contact type, with the CType() or DirectCastfunction. The same is true for an ArrayList, which stores objects, and we usually cast its members to specific types.

- Variables declared without a specific type are called untyped variables.


• Early versus Late Binding

- Untyped variables can’t be resolved at compile time; these variables are said to be late-bound.

Inheritance

Inheritance

• The key word here is reuse: write once,

use many times.

• Inheritance is a powerful concept in object-oriented programming that allows you to build classes on top of existing ones.

• You inherit the functionality of an existing class and then add more functionality to it or overwrite some of its base functionality.

Inheritance

• Inheritance allows you to build hierarchies of classes that better represent physical entities, and it also enables you to reuse existing code (the holy grail of programming).

• Inheritance is a technique for reusing and improving code that doesn’t cause the applications that use it to break.

Inheritance

• It’s possible to add new functionality to the inherited code or even override some of the existing functionality.

• You can add new functionality to the code by adding new members to the inherited classes

How to Apply Inheritance

• A lot of functionality has been built into Windows itself, and we constantly reuse it in our applications. The various Windows Forms controls are a typical example.

• The functionality of the TextBox control, which we all take for granted, is packaged in a DLL (the System.Windows.Forms.TextBox class).

• Yet, many of us enhance the functionality of the TextBox control to address specific application requirements.

How to Apply InheritancePublic Class FocusedTextBox

Inherits System.Windows.Forms.TextBox

Private Sub FocusedTextBox_Enter(ByVal sender As Object,

ByVal e As System.EventArgs) Handles Me.Enter

Me.BackColor = _enterFocusColor

End Sub

Private Sub FocusedTextBox_Leave(ByVal sender As Object,

ByVal e As System.EventArgs) Handles Me.Leave

Me.BackColor = _leaveFocusColor

End Sub

End Class

_______________________________________________________

The_enterFocusColor and _leaveFocusColor variables are two local variables of the Color type, which must be also be declared.

How to Apply Inheritance• It took just a few lines of code and the keyword

Inherits. With the Inherits statement, you include all the functionality of the original TextBox control without touching the control code.

• Any project that uses the FocusedTextBox control can take advantage of the extra functionality, yet all existing projects will continue to work with the original version of the control.

How to Apply Inheritance• Inheritance is simply the ability to create a new

class based on an existing one.

• The existing class is the parent class, or base class.

• The replacement of existing members with other ones is called overriding.

Designing with Inheritance• Consider a structure for storing product

information; in most applications, this structure is optimized for a specific product type.

Apllied Programming

Documents

Transcript of Apllied Programming