Object Oriented Programming in ColdFusion

Last updated on 16 May 2021 | Also applies to ColdFusion

To learn about ColdFusion components, see Build and use ColdFusion components.

Read on to know the new and enhanced OOP features in ColdFusion.

Abstract components and methods

An abstract component can have abstract method without body and can also have methods with implementation.

Use the abstract keyword to create an abstract component and method. In ColdFusion, you cannot instantiate an abstract component. An abstract component is mostly used to provide base for sub-components. The first concrete component should have the implementation of all the abstract methods in its inheritance hierarchy.

Note:

A concrete component cannot have abstract methods.

To declare an abstract component,

// myAbstractClass.cfc
abstract component {
 // abstract methods
 // concrete methods
}

That is all there is to when declaring an abstract component in ColdFusion.

You cannot create instances of myAbstractClass. Thus, the following code is NOT valid:

myClassInstance=new myAbstractComponent();

Here is an example of using abstract components in ColdFusion.

Shape.cfc

abstract component Shape{
 abstract function draw();
}

Square.cfc

component Square extends="Shape" {
 function draw() {
      writeoutput("Inside Square::draw() method. <br/>");
   }
}

ShapeFactory.cfc

component ShapeFactory extends="AbstractFactory" {
 
 Shape function getShape(String shapeType){
   
       if(shapeType EQ "RECTANGLE"){
         return new Rectangle();
         
      }else if(shapeType EQ "SQUARE"){
         return new Square();
         
      }else 
         return "not defined";
      }
}

Rectangle.cfc

component Rectangle extends="Shape" {
   function draw() {
      writeoutput("Inside Rectangle::draw() method. <br/>");
   }
}

AbstractFactory.cfc

abstract component AbstractFactory {
     abstract Shape function getShape(String shape) ;
}

FactoryProducer.cfc

component FactoryProducer {
 AbstractFactory function getFactory(String choice){
   if(choice eq "SHAPE"){
         return new ShapeFactory();
         
      }
      
   }
}

index.cfm

<cfscript>
   //get shape factory
   shapeFactory =  new FactoryProducer().getFactory("SHAPE");
   //get an object of Shape Rectangle
   shape2 = new shapeFactory().getShape("RECTANGLE");
   //call draw method of Shape Rectangle
   shape2.draw();
   //get an object of Shape Square 
   shape3 = new shapeFactory().getShape("SQUARE");
   //call draw method of Shape Square
   shape3.draw();
</cfscript>

Final component, method, and variable

In ColdFusion, inheritance is a highly useful feature. But at times, a component must not be extended by other classes to prevent data security breaches. For such situations, we have the final keyword.

ColdFusion supports the following:

Final component
Final method
Final variable

Final variable

Final variable are constants. Use the final keyword when declaring a variable. You cannot change the value of a final variable once you initialize it. For example,

component{
 final max=100;
  
 function mymethod(){
  //max=100;
  writeoutput("final variable is: " & max);
 }
}

Create an index.cfm, instantiate the component, and call the method defined in the component. If you change the value of max in the method, you see an exception. The following snippet also produces an exception.

component{
 final max;
 // constructor
 
 function mymethod(){
  max=50;
  writeoutput("final variable is: " & max);
 }
}

Final component

You cannot extend a final component and override a final method. A final component, however, can extend other components.

To define a final component, see the example below:

final component{
 // define methods
}

To define a final method, use the specifier before the final keyword and the return type. For example,

public final void function myMethod() {
 // method body
}

A final component helps secure your data. Hackers often create sub-components of a component and replace their components with the original component. The sub-component looks like the component and may perform a potentially malicious operation, which would compromise the entire application. To prevent such subversion, declare your component as final and prevent the creation of any sub-component. For example,

A.cfc

final component {
}

The code below produces an exception:

B.cfc

component extends=”A” {
}

Final method

A method with a final keyword cannot be overridden. This allows you to create functionality that cannot be changed by sub-components. For examples,

Test.cfc

component {
 // final method and cannot be overridden
 public final void function display(){
  writeOutput("From super class, final display() method");
 }
 // concrete method
 public void function show(){
  writeOutput("From super class, non-final show() method");
 }
}

Demo.cfc

component extends="Test"{
 //public void function display(){}
 public void function show()
   {
     writeOutput("From subclass show() method");
   }
}

In Demo. cfc , uncommenting the above line produces an exception, since you cannot override a Final method. You can, however, override a non-final method, as shown in the code above.

main.cfm

<cfscript>
 d1=new Demo();
 d1.display();
 d1.show();
</cfscript>

Output

From super class , final display() method

From subclass show() method

Default functions in interfaces

This feature enables you to declare a function in an interface, and not just the signature. While extending the interface, developers can choose to either override or reuse the default implementation.

Default Functions enables extending the interfaces without breaking old applications.

For example, create an interface, I.cfc, that defines a function returnsany, which returns an object of any type. Use the keyword "default", while defining such functions.

interface {
 public default any function returnsany(any obj)
 {
  return obj;
 }
}

Create a cfc, comp.cfc, that implements the interface, I.cfc.

component implements="I"
{

}

Now, create on object that returns a string.

<cfscript>
 myobj=new Comp();
 writeOutput(myobj.returnsany("hello world"));
</cfscript>

Covariance

Covariance is the relationship between types and subtypes. In ColdFusion (2021 release), Covariance is supported for return types in overriding a method.

In ColdFusion (2021 release), a return type is covariant in the component implementing the interface. The example below shows how you can leverage covariance.

The argument name is not compared during interface implementation, i.e, if the interface function takes argument name as x , the implementing function in the component can have any argument name.

Define an interface, IAnimal.cfc.

interface displayName="IAnimal" hint="Animal Interface."{
     
    any function eat(any prey="");
    any function makeNoise(string noise);
     
}

Define component, Animal.cfc, which implements the Interface.

While implementing the interface function eat() & makenoise (), it overrides the return type to a more specific type. This is known as Covariant Method Return Type.

component implements="IAnimal" displayname="Animal"{
 property animalSize;
 property animalType;
 function init(animalSize,animalType){
  variables.instance.animalSize = arguments.animalSize
  variables.instance.animalType = arguments.animalType
 }
 Animal function eat(any prey=""){
   return prey;
  }
 string function makeNoise(string noise){
   return noise;
  }
 function getanimalSize(){
  return variables.instance.animalSize
 }
 function getanimalType(){
  return variables.instance.animalType
 }
}

Create index.cfm and check how the animal eats and makes noise.

<cfscript>
 bunny=new Animal('small','rabbit');
 simba =new Animal('large','Tiger');
 writeoutput("Simba eats " & simba.eat(bunny).getAnimaltype() & "<br/>");
 writeoutput("Simba " & simba.makenoise('roarsss'));
</cfscript>

Adobe

Get help faster and easier

New user?