Josh Adams

Subscribe to Josh Adams: eMailAlertsEmail Alerts
Get Josh Adams: homepageHomepage mobileMobile rssRSS facebookFacebook twitterTwitter linkedinLinkedIn


Related Topics: Open BlueDragon Developer's Journal, ColdFusion on Ulitzer

BlueDragon: Article

Inheritance in ColdFusion: Code Reuse for CFCs

When it comes to code, less is more

When it comes to code, less is more. Or to be more precise, less is better. How do you write less code and still write enough code to make your applications function as required? One way is to reuse code: write code once, use that code many times. If the words "code reuse" evoke thoughts of copying bits of code and pasting it elsewhere, keep reading because this article will teach you a better way!

When it comes to object-oriented ColdFusion Markup Language (CFML) using ColdFusion components (CFCs), one approach to writing code once and using it many times is making use of inheritance. This article will explain what inheritance is and how you can take advantage of it in order to write less code. Along the way, this article will ensure that you understand the basics of CFCs and how they are used.

The best software not only functions as required by its users, but also allows for ease of maintenance. Maintenance is important because if an application is easily maintainable, it can continue to function as required by its users even as those requirements change over time. However, in order to produce functional software in a deadline-driven world, maintainability is often neglected. But is it possible that both the goals of immediate functionality and long-term maintainability can be served simultaneously in the initial development? Yes, and the key is to write as little code as possible to get the job done. As a general rule, less code equals both less bugs (or, put another way, better functionality) and less maintenance, not only with respect to bug fixes, but also in terms of code alteration in response to new or changed functional requirements.

CFML has long allowed for numerous types of code reuse such as including files, calling custom tags, and calling user-defined functions (if you are unfamiliar with these, you should make learning about them a priority). As is true of any CFML application, it is possible to leverage all these types of code reuse to improve the design of a CFML application that makes use of CFCs. However, CFCs can also leverage another type of code reuse: inheritance.

The Basics of CFCs
Since the use of CFCs is central to object-oriented CFML development and since inheritance in CFML is only applicable to CFCs, let's take a moment to look at the basics of CFCs before we dive into the specifics of inheritance. CFCs are special CFML files used in a particular way in CFML applications, yet the contents of a CFC are not so very different from the contents of other CFML files. Instead, the fundamental difference between CFCs and other CFML files lies in their use: CFCs are not used directly as part of a request; instead, CFCs are used as the basis for the creation of memory-resident objects. We will get to how that works in a moment, but before that we need to see what a CFC looks like. This simple example shows the contents of a file named simple.cfc:

<cfcomponent>
text output
<cfset this.myVar = "statement">

<cffunction name="myMethod">
<cfreturn "string">
</cffunction>
</cfcomponent>

This simple CFC is largely similar to other CFML files - note that it makes use of only one special CFML tag, the <cfcomponent> tag, which consists of an opening tag on the first line of the file and a closing tag on the last line of the file. This tag specifies that the file is a CFC. Although Adobe ColdFusion MX does not strictly require the use of the <cfomponent> tag, good coding practice dictates it be used in CFCs.

While the rest of the code in the CFC is familiar CFML, some new terminology is used. User-defined functions in a CFC are called "methods." Thus, the last three lines of simple.cfc before the closing </cfcomponent> tag implement the myMethod method of simple.cfc. Variables in a CFC are called properties. Thus, the third line of simple.cfc creates the myVar property of simple.cfc. Notice the use of the This scope in the creation of the myVar property. The This scope is a special scope for use only in CFCs; it is used to cause a property of a CFC to be accessible not only within the CFC but within code that uses the CFC. This is called making the property public. If instead in the Variables scope of the CFC is used, the property is made private, meaning that it is accessible only within the CFC and not from code that uses the CFC. Methods too can be made public or private via use of the access attribute of the <cffunction> tag; when this attribute is omitted, as it was in the method definition for myMethod in simple.cfc above, the method is public.

Now we can look at the way CFCs are used. This simple example provides the contents of a file named callsimple.cfm:

<cfset myObj = CreateObject("component", "simple")>
<cfoutput>
    <br>
    #myObj.myVar#<br>
    #myObj.myMethod()#<br>
</cfoutput>

Note that in this example, the myObj variable references in callsimple.cfm were left unscoped for the sake of simplicity. Good coding practice dictates that variable references be scoped.

As mentioned previously, CFCs are not used directly as part of a request. That means they are not called directly from a browser nor are they included with <cfinclude> nor are they even called with <cfmodule>. Instead, as demonstrated on line 1 of callsimple.cfm, CFCs are used with the CreateObject function (you may also use the <cfobject> tag; its functionality is the same as that of the CreateObject function and the choice of which to use is largely a personal preference). When "component" is the value of the first argument passed to the CreateObject function, an instance is created of the CFC specified by name in the second argument passed to the CreateObject function. An instance of a CFC is a memory-resident version of the CFC that contains all properties and methods defined in the CFC. An instance of a CFC is also called object. A theoretically unlimited number of objects can be created from any CFC.


More Stories By Josh Adams

Josh Adams is the developer evangelist for New Atlanta's BlueDragon family of CFML application server products. He presents on a regular basis at technical conferences and user groups throughout North America. Josh is also an active CFML developer both in his role at New Atlanta and in other endeavors.

Comments (0)

Share your thoughts on this story.

Add your comment
You must be signed in to add a comment. Sign-in | Register

In accordance with our Comment Policy, we encourage comments that are on topic, relevant and to-the-point. We will remove comments that include profanity, personal attacks, racial slurs, threats of violence, or other inappropriate material that violates our Terms and Conditions, and will block users who make repeated violations. We ask all readers to expect diversity of opinion and to treat one another with dignity and respect.