The Singleton pattern attempts to solve the issue of repeatedly using an object instance, but only wishing to instantiate it once within a single transaction context.
Sample Code:
Apex Class:
public class Utility {
public static Utility objInstance = null;
public Integer acctCount;
public Utility() {
acctCount = [ SELECT COUNT() FROM Account ];
}
public static Utility getInstance() {
if ( objInstance == null )
objInstance = new Utility();
return objInstance;
}
}
If you execute the below code, the SOQL will be executed only once.
for ( Integer i = 0; i < 3; i++ ) {
Utility obj = Utility.getInstance();
system.debug(‘Count is ‘ + obj.acctCount);
}
Strategy:
Defining a family of algorithms, enscapsulating each one and making them interchangeable and selectable at runtime.
Sample Code:
1. Create an interface.
public interface Strategy {
Integer doOperation(Integer num1, Integer num2);
}
2. Create concrete classes implementing the same interface.
public class OperationAdd implements Strategy {
public Integer doOperation(Integer num1, Integer num2) {
return num1 + num2;
}
}
public class OperationSubstract implements Strategy {
public Integer doOperation(Integer num1, Integer num2) {
return num1 – num2;
}
}
3. Create Context Class.
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public Integer executeStrategy(Integer num1, Integer num2) {
return strategy.doOperation(num1, num2);
}
}
4. Use the Context to see change in behaviour when it changes its Strategy.
Context context = new Context(new OperationAdd());
System.debug(’10 + 5 = ‘ + context.executeStrategy(10, 5));
context = new Context(new OperationSubstract());
System.debug(’10 – 5 = ‘ + context.executeStrategy(10, 5));
Decorator:
Extending the functionality of an sObject in Apex.
Example is Wrapper Class – https://www.infallibletechie.com/2015/03/sample-wrapper-class-using-apex-in.html
Facade:
Simplifying the execution of classes with complex interfaces (e.g. web service callouts).
Sample Code:
/* Complex parts */
class CPU {
public void freeze() { … }
public void jump(long position) { … }
public void execute() { … }
}
class HardDrive {
public byte[] read(long lba, int size) { … }
}
class Memory {
public void load(long position, byte[] data) { … }
}
/* Facade */
class ComputerFacade {
private CPU processor;
private Memory ram;
private HardDrive hd;
public ComputerFacade() {
this.processor = new CPU();
this.ram = new Memory();
this.hd = new HardDrive();
}
public void start() {
processor.freeze();
ram.load(BOOT_ADDRESS, hd.read(BOOT_SECTOR, SECTOR_SIZE));
processor.jump(BOOT_ADDRESS);
processor.execute();
}
}
/* Client */
class You {
public static void main(String[] args) {
ComputerFacade computer = new ComputerFacade();
computer.start();
}
}
Composite:
Treating a group of objects in a similar manner to a single instance of that object. Composite pattern is used where we need to treat a group of objects in similar way as a single object. Composite pattern composes objects in term of a tree structure to represent part as well as whole hierarchy. This type of design pattern comes under structural pattern as this pattern creates a tree structure of group of objects.
Sample Code:
Apex Class:
public class Employee {
private String name;
private String dept;
private Integer salary;
private List<Employee> subordinates;
// constructor
public Employee(String name,String dept, Integer sal) {
this.name = name;
this.dept = dept;
this.salary = sal;
subordinates = new List < Employee >();
}
public void add(Employee e) {
subordinates.add(e);
}
public List<Employee> getSubordinates() {
return subordinates;
}
}
Execute the below code to set the hierarchy and view the debug log.
Employee CEO = new Employee(‘John’,’CEO’, 30000);
Employee headSales = new Employee(‘Robert’,’Head Sales’, 20000);
Employee headMarketing = new Employee(‘Michel’,’Head Marketing’, 20000);
Employee clerk1 = new Employee(‘Laura’,’Marketing’, 10000);
Employee clerk2 = new Employee(‘Bob’,’Marketing’, 10000);
Employee salesExecutive1 = new Employee(‘Richard’,’Sales’, 10000);
Employee salesExecutive2 = new Employee(‘Rob’,’Sales’, 10000);
CEO.add(headSales);
CEO.add(headMarketing);
headSales.add(salesExecutive1);
headSales.add(salesExecutive2);
headMarketing.add(clerk1);
headMarketing.add(clerk2);
//print all employees of the organization
System.debug(CEO);
for ( Employee headEmployee : CEO.getSubordinates() ) {
System.debug(headEmployee);
for ( Employee employee : headEmployee.getSubordinates() ) {
System.debug(employee);
}
}
Bulk State Transition:
Efficiently tracking the change of a field value in a trigger and executing functionality based on this change.
Example is bulking the trigger.