At this point all we've done is create an object, but we haven't called a constructor. Or have we? Although CFCs don't have formal constructors, they do have what's usually referred to as a "pseudo-constructor." When you create a CFC, any code that's placed after the opening cfcomponent tag but outside any cffunction tags will get executed. We'll look at the code for our Person CFC in a moment, but here's a short example:

<cfcomponent>
    <!--- this is the pseudo-constructor --->
    <cfset variables.firstName = "Matt" />
    <cfset variables.lastName = "Woodward" />
    <!--- end of pseudo-constructor --->

    <!--- object methods begin here --->
    <cffunction name="doSomething">
        etc. ...
    </cffunction>
</cfcomponent>

Now obviously you aren't going to want to set all of your Person objects' names to "Matt Woodward" as they're created, but I hope you understand the concept. The CFML code in the area after the opening component tag but before the first cffunction tag will get executed when you create an instance of this CFC by using cfobject or CreateObject().

What has become considered a bit of a best practice in OO development with CFCs is not to rely on this pseudo-constructor, but rather to provide a method in the object called init() that is used as a constructor for the CFC. This allows for an explicit call to a constructor that is more along the lines of what happens in other OO languages. So while you could still create the object without calling the init method, in many cases you would do something like this:

matt = CreateObject("component", "Person").init("Matt", "Woodward");

This would create the object and immediately call the object's init method. By passing the init method a first and last name, in this case the object subsequently calls the setters for the firstName and lastName attributes in the object (we'll see specifically how this works in a moment). Bear in mind you could also call the init method and pass it no arguments and the object would be created; it just won't know its name or anything else about itself until we set those values. This will all be coming together shortly!

The Person CFC
If you're with me so far, you're well on your way to understanding objects and being able to start using them in your ColdFusion applications. Armed with all your newfound OO knowledge, let's take a look at the specific implementation of the Person CFC. What I won't cover in this article is how to use this CFC in the context of a larger application; I don't want to muddy the waters with how you will throw objects around in your applications just yet.

Let's briefly review the important object concepts before taking a look at the specific CFC code:

• Objects have attributes (e.g., first name and last name)
• Objects have methods (e.g., getFirstName(), setFirstName())
• Objects are self-contained, meaning the object's data and the methods that work with the data are all contained within the object itself
• Objects use encapsulation, meaning you will only interact with the object via the methods that it exposes to you
• Objects contain a constructor method that is called to construct the object (set default attribute values, etc.)
• Objects are your friend and you will use them whenever possible in your ColdFusion applications (sorry, had to throw that in here!)

And now, without further delay, let's take a look at the Person.cfc code (see Listing 1)! We're going to limit our CFC's attributes to just first name and last name, and there's going to be some "stuff" in here that we won't concern ourselves with at this stage, but we'll look over the CFC's anatomy after you peruse the code for yourself. See if you can pick out all of the concepts we've discussed and how they're implemented in this CFC.

If we want to create an instance of this object with the first name "Matt" and the last name "Woodward," we'd just use the code we outlined earlier, but now that you've see the CFC code you'll have a better understanding of what's happening:

matt = CreateObject("component", "Person").init("Matt", "Woodward");

This creates the object, and since we're calling the init method and passing it a first and last name, the init method in turn calls the setters for these attributes within the object.

Finally, since the init method returns the object itself, the "matt" variable becomes an instance of the Person object with the first and last name attributes set. How many items from our object concept list did you pick out? Let's walk through a few of them.

1.  Our object has attributes, specifically firstName and lastName. While a real-world object would typically have a lot more attributes than this, these suffice to illustrate the concept.

2.  Our object has methods, five to be exact. We have an init method that serves as a constructor, and a pair of get and set methods for each of our two attributes. The get methods simply return a string for their respective attribute, and the set methods take a string as an argument and set the attribute's value to the value of the argument passed to the method.

3.  Our object is self-contained. The object's attributes (data) and the methods that interact with this data are all contained within the object itself.

4.  Because we have getters and setters and no publicly accessible data (we'll discuss public, private, and surrounding issues in a future article), we're using encapsulation. You can only get and set the attribute values via the methods that the object provides to you for this purpose.

5.  Our object contains a constructor, which in this case is our init method. The two arguments firstName and lastName are marked as optional so we can either call init() and not pass it any arguments, in which case we'd get an object back with no value for firstName and lastName, or we can pass it arguments and the firstName and lastName attributes are set accordingly. Last, objects clearly are your best friend and you will be using them whenever possible in your ColdFusion applications! Even if you're not convinced quite yet, I hope you can at least see the tremendous potential for the use of objects in your applications. Once you really understand objects and get the hang of how to use them, it will make your development work much easier, your applications far easier to maintain, and you'll be writing your ColdFusion applications using the same methodologies as the rest of the software development world.

Looking Ahead...
I hope this relatively high-level overview of what an object is and how you apply object concepts in the ColdFusion world has piqued your interest in the wonderful world of object-oriented programming. While I can't promise that it will bring you vast wealth and make you more attractive to others, I can promise that it's a better way to develop ColdFusion applications. Even if it might seem a bit complex at first, after you've been working with objects for a bit you'll start to see the complexity fall away and you won't be able to imagine how you ever developed without them.

Please feel free to e-mail me if there are specific things you'd like to see addressed in future articles, but I think a logical next step will be to address some of the specific gotchas you'll need to be aware of as you start using CFCs as objects, and to show you how to use this Person CFC in a real-world application. Stay tuned for another installment in the near future!

Resources

• Sierra, Kathy and Bert Bates. Head First Java. O'Reilly, 2004.
• Taylor, David A. Object Technology: A Manager's Guide. 2nd ed. Addison-Wesley, 1998.
• Weisfeld, Matt. The Object-Oriented Thought Process. 2nd ed. Sam's Publishing, 2004.