Vous êtes sur la page 1sur 6

Visual Basic/Object Oriented Programming - Wikibooks, open books fo... http://en.wikibooks.

org/wiki/Visual_Basic/Object_Oriented_Programming

1 of 6

We will now move into a more advanced aspect of VB - OOP. But don't worry, Object Oriented
Programming is quite simple, in fact it is probably simpler for those who have never programmed before than
for those with long experience of traditional Fortran/Basic/Pascal (pick your favourite imperative language).

You should be familiar with VB's event-driven programming style by now. However I'll explain it again.
When you're doing general VB programming, your thoughts should go in this pattern: "If the user does this,
what should happen? How would I make it happen?" Then you would write the program to fit the answers to
these questions. That is event-driven programming. You program according to what events the user would
trigger. Dragging a picture, clicking a button, and typing a word are all events.
You, being the brave coder that you are, would ask: "WHY do I HAVE to think like that??"
Well here's an alternative way for you to think: Object Oriented Programming(OOP). In the world of OOP,
you break a problem down into small parts and solve them individually. If you are to program in an object
oriented style, you would think of every variable or functions as a property of an object, and everything
would seem like an object to you. OOP is hard to explain so you'll have to experience it in the following
examples.
Imagine that you have a bottle of juice. What properties does it have? What events does it have?(What can it
do?) Here's a list I could think of:

Private Colour As String


Private Fruit As String
Private Volume As Single
Public Sub MakeJuice(c As
Colour = c
Fruit = f
Volume = v
End Sub
Public Sub Evaporate()
Volume = Volume - 10
End Sub

'What colour?
'What kind of fruit?
'How much?
String, f As String, v As Single)

'Make some

'Well, that's the only thing I could think of

Behold. That's our first class. Don't worry about anything right now. I will go over those later. Anyway, let's
assume that this class is named, "Juice". Think of it as a general description of a bottle of juice. Now we can
create an actual bottle of apple juice:

Private AppleJuice As Juice 'Define


Set AppleJuice = New Juice
'Create a new instance of Juice
AppleJuice.MakeJuice "brown", "apple", 30

Watch:

AppleJuice.Evaporate
AppleJuice.Evaporate
AppleJuice.Evaporate

'20 units left


'10 left
'Yes!!

6/3/2014 11:29 AM

Visual Basic/Object Oriented Programming - Wikibooks, open books fo... http://en.wikibooks.org/wiki/Visual_Basic/Object_Oriented_Programming

2 of 6

"Wait", you interrupted my rant once again, "but why do I have to use OOP? Just because you hate apple
juice?"
OOP is good for large-scale programming - As your code grows large, there are going to be more and more
procedures/functions to your program, and your code is going to be so cluttered that one more look at it,
you'd scream. That is why I'm teaching you OOP! (So instead of looking at hundreds of scattered
procedures/functions, you look at organized Objects.)

1 Types
2 Classes
3 Inheritance
3.1 Class cDog
3.2 Class cCat
3.3 module main
3.4 Class cPet
3.5 Class cPet rewritten
3.6 Class cDog
3.7 Class cCat
4 Collections
5 Iterators

You can think of a type as a simple form of class. Types can only hold variables, not procedures/functions.
An important distinction between user defined types ('UDT') and 'classes' in 'VB6' is that 'UDTs' are value
types while 'classes' are reference types. This means that when you store an object ('instance' of a 'class') in a
variable what actually happens is that a pointer to the existing object is stored but when you store a 'UDT'
instance in a variable a copy of the instance is stored. For instance imagine that you have defined a class,
'Class1', and a UDT, 'Type1':

Dim
Dim
Dim
Dim

ac
bc
at
bt

As
As
As
As

Class1
Class1
Type1
Type1

Now assign ac to bc:

Set bc = ac

and at to bt

6/3/2014 11:29 AM

Visual Basic/Object Oriented Programming - Wikibooks, open books fo... http://en.wikibooks.org/wiki/Visual_Basic/Object_Oriented_Programming

3 of 6

bt = at

Now make a change to one of the properties of bc and look at the corresponding property in ac. You should
see that when you change bc that ac also changes. This is because ac and bc are really pointers to the same
block of memory. If you do the same exercise with bt and at you should see that changing properties of bt
does not affect at. This is because at and bt are values not references and occupy distinct locations in
memory.
This is important when storing objects in 'Collections'. If you add an object to a collection you can later
change the values of its properties and the object in the collection will also seem to change. in fact it is the
same object because what is stored in the collection is the reference ('pointer') to the object. However if you
store a 'UDT' in a collection what is stored is a copy of the values not a reference so changing the original
UDT will not affect the content of the Collection.

Classes are a combination of subroutines and types. By that I mean that when you write a class it looks very
much like a type but is also contains subroutines and functions.
Each class in VB6 is a distinct file, there can only be one class in a file and the class cannot be spread out in
several files; this is a feature of VB6 not a requirement of object oriented programming.
A class looks very much like an ordinary module but has the file extension .cls instead of .bas

There are two types of inheritance: implementation and interface. However Visual Basic Classic provides
only Interface inheritance. Implementation inheritance can be simulated by a combination of interface
inheritance and delegation.
One of the common ways to introduce inheritance is to show a program that creates dog and cat objects or
car and train objects.
For example in Visual Basic we can declare two classes dog and cat like this:

Class cDog

Option Explicit
Public Sub Sound()
Debug.Print "Woof"
End Sub

Class cCat

Option Explicit
Public Sub Sound()

6/3/2014 11:29 AM

Visual Basic/Object Oriented Programming - Wikibooks, open books fo... http://en.wikibooks.org/wiki/Visual_Basic/Object_Oriented_Programming

4 of 6

Debug.Print "Meow"
End Sub

module main

Public Sub main()


Dim oDog as cDog
Dim oCat as cCat
Set oDog = New cDog
Set oCat = New cCat
oDog.Sound
oCat.Sound
End Sub

When you run this program it will print:


Woof
Meow

Now this is all very well until you decide that you would like an array of pets:

Dim aPets(1 to 10) as ????

Unless you declare the aPets array as variant you have to give it a type. One way is to create a class called
cPet and use it instead of cDog and cCat:

Class cPet

Option Explicit
Public IsDog as Boolean
Public Sub Sound()
If IsDog Then
Debug.Print "Woof"
Else
Debug.Print "Meow"
End If
End Sub

Now our main routine might look like this:

Option Explicit
Dim aPet(1 to 10) as cPet
Public Sub main()

6/3/2014 11:29 AM

Visual Basic/Object Oriented Programming - Wikibooks, open books fo... http://en.wikibooks.org/wiki/Visual_Basic/Object_Oriented_Programming

5 of 6

Dim lPet as Long


For lPet = 1 to 10
Set aPet(lPet) = New cPet
If lPet<=5 then
aPet(lPet).IsDog = True
Else
aPet(lPet).IsDog = False
End If
Next lPet
' Now find out what noise they make.
For lPet = 1 to 10
aPet(lPet).Sound
Next lPet
End Sub

This should print:


Woof
Woof
Woof
Woof
Woof
Meow
Meow
Meow
Meow
Meow

Look reasonable? For the requirements so far revealed this works fine. But what happens when you discover
that there are things that cats do that have no analogue in dogs? What about other kinds of pet? For example,
you want your cat to purr. You can have a method called purr but where will you put it? It surely doesn't
belong in cPet because dogs can't purr and neither can guinea pigs or fish.
The thing to do is to separate out those features that are common to all pets and create a class that deals only
with those, we can rewrite cPet for this purpose. Now we can go back to our original cDog and cCat classes
and modify them to inherit the 'interface from cPet.

Class cPet rewritten

Option Explicit
Public Sub Sound()
End Sub

Notice that the Sound method is empty. this is because it exists only to define the interface. The interface is
like the layout of the pins on a plug or socket; any plug that has the same layout, size and shape will plug in
to a socket implementing the same interface. What goes on inside the thing you plug in is a separate issue;
vacuum cleaners and television sets both use the same mains plug.
To make this work we must now modify cDog and cCat:

Class cDog

Option Explicit

6/3/2014 11:29 AM

Visual Basic/Object Oriented Programming - Wikibooks, open books fo... http://en.wikibooks.org/wiki/Visual_Basic/Object_Oriented_Programming

6 of 6

Implements cPet
Private Sub cPet_Sound()
Debug.Print "Woof"
End Sub

Class cCat

Option Explicit
Implements cPet
Private Sub cPet_Sound()
Debug.Print "Meow"
End Sub
Public Sub Purr()
Debug.Print "Purr"
End Sub

In the pet examples above an array of cPet objects is used to hold the pets. This works well if you know
exactly how many pets you have. But what happens if you adopt another stray puppy or your cat has
kittens?
One solution is to use a Collection object instead of an array. A collection object looks a little like an array
but lets you add and remove items without worrying about the declared size, it just expands and contracts
automatically.

Previous: External_Processes
Contents
Next: Effective Programming
Retrieved from "http://en.wikibooks.org/w/index.php?title=Visual_Basic/Object_Oriented_Programming&
oldid=2436138"
This page was last modified on 7 November 2012, at 22:44.
Text is available under the Creative Commons Attribution-ShareAlike License.; additional terms may
apply. By using this site, you agree to the Terms of Use and Privacy Policy.

6/3/2014 11:29 AM