Example: How to use objects in Apex

Preface – This post is part of the Object Oriented Thinking series.

Finally, a real-life example of how and why to use objects in a business scenario!

Let’s say your company runs a subscription business and uses a custom “Member” object. Instead of converting leads to the standard Contact/Account/Opportunity model, your company converts leads to members using the following Apex class:

public class SpecialLeadConvert {
  // Variables
  List<Lead>      leads;
  List<Member__c> members;
  // Constructor  
  public SpecialLeadConvert(List<Lead> leadList) {
    leads   = leadList;
    members = new List<Member__c>();
  }

  // Method: convert leads to Members, not Contacts
  public void convertToMembers() {
    for (Lead l : leads) {
      Member__c member = new Member__c();
      member.Name      = l.FirstName + ' ' + l.LastName;
      member.Email__c  = l.Email;
      members.add(member);
    }
    insert members;

    // Delete the leads 
    // Apex doesn't let us delete records in Trigger.new
    // This is a workaround that tricks Apex!
    List<Lead> workaround = leads.deepClone(true);
    delete workaround;
  }
    
  // Method: get our Member list  
  public List<Member__c> getMembers() {
    return members;
  }
}

Now here’s how we’d use this class’s logic in a trigger:

trigger ConvertToMember on Lead (before update) {
  // Make a list of leads to convert
  List<Lead> leadsToConvert = new List<Lead>();
  for (Lead l : Trigger.new) {
    if (l.Status == 'Member') {
      leadsToConvert.add(l);
    }
  }
  
  // Create the special conversion object
  SpecialLeadConvert slc = new SpecialLeadConvert(leadsToConvert);
  
  // Use the object's method to convert its leads
  slc.convertToMembers();
  
  // Don't forget to use System.debug!
  System.debug('Members created: ' + slc.getMembers());
}

A good question to ask at this point is… did we really need to use a class? Why separate the code in a class, when we could’ve had similar code inside the trigger all along?

It’s better to use a class because we’re likely to re-use the class’s logic in other places. For example, we might have a Visualforce page that also converts leads. If all of our conversion code was in our trigger (instead of a class), we’d need a separate copy of the code in our Visualforce page logic.

Using a class will also organize our codebase. Let’s say our business expands and leads can now also become “Partners”, an exclusive type of membership with extravagant benefits. We’d simply create a new convertToPartners method in our class, and whenever or wherever we’d need to do any type of conversion, we’d know our SpecialLeadConvert class would be able to handle it.

Hope this example gets those juices flowing inside your head!

Next post: The “One Trigger to Rule them All” design pattern!