CONTENTS
Classes and Object in Apex
In this page, we will learn about Apex classes and objects. In object-oriented programming, we design a program using classes and objects.
What is a class in Apex
Class is a concept or prototype or template i.e. it is a logical entity. A class is having member method and member data.
Technically, a class is a group of objects which have common properties all together.
Syntax to declare a class:
class <class_name> { field; method; }
What is an object in Apex
Any real world entity that has state/data and behavior/method is known as an object. For example: marker, book, table, chair, mouse, car etc.
Technically, we can say object is an instance of a class or in other words you can say it is an implementation of a class.
For Example, Marker is an object. Its name is Luxor; color is white, known as its state/data. It is used to write, so writing is its behavior/method.
An object is an instance of a class, which means an object is a real time implementation of a class.
Syntax to define an object:
Class_name refVariable = new Class_name();
New keyword in Apex
The new keyword is used to allocate memory at runtime. All objects always get memory in heap memory area.
Class and Object Example:
In this example, we have created a Employee class which has two data members id and name. We are creating the object of the Employee class by new keyword and printing the object’s value.
//Apex Program to illustrate how to define a class, fields and methods //Defining a Employee class. public class Employee { //defining fields integer empId;//field or data member or instance variable String empName; //creating method inside the Employee class public void getEmpDetails(){ empId = 101; // setting the value of instance variable empName = 'Sanjay'; // setting the value of instance variable //Printing values System.debug('empId = ' + empId);//accessing member variable System.debug('empName = ' + empName); } }
How to create an Object of this class:
Employee emp = new Employee(); emp.getEmpDetails();
Output:
empId = 101 empName = varma
Memory Representation of Employee Program as below:
Above Program’s memory representation explanation:
Using new keyword, it will allocate a memory of type Employee where instance data members got initialized into memory that is referred by emp and then using emp we are referring the instance members.
Method in Apex:
A method is a way to perform some operation. Similarly, the method in Apex is a collection of instructions that performs some task. It provides the reusability of code. In this section, we will learn what is a method in Apex, types of methods, method declaration, and how to call a method in Apex.
What is a method in Apex?
A method is a block of statements or a set of code grouped together to perform a specific operation. It is used to achieve the reusability of code because we write a method at once and use it many times whenever required. We can easily modify the code just by adding or removing code as per requirement. The method is executed only when we call or invoke as per need.
Method Declaration
The method declaration provides information about method, such as what would be visibility, return-type, name, and its arguments as we are showing in the following figure.
Method Signature: Every method has its own method signature. It is a part of the method declaration. It includes the method name and argument/parameter list.
Access Specifier: Access specifier/modifier is the access type of the method. It specifies the visibility of the method which means from where we can call our method. Java provides four types of access specifier:
- global: The method is accessible by all classes within the Salesforce or outside the Salesforce when we use global specifier in our application.
- public: The method is accessible by all the classes within the Saleforce.
- Private: When we use a private access specifier, the method is only accessible within the class where we defined it.
- Protected: When we use protected access specifier in Apex class, the method is accessible to any inner classes in the defining Apex class, and to the classes that extend the defining Apex class as per need.
Return Type: Return type is a data type that the method is going to return. It may have a primitive data type, sObject, collection, void, etc. as per requirement, If the method does not return anything, we use void keyword. So void means that method is not going to return any value.
Method Name: It is a unique name that is used to define the name of a method. Please make sure the name which you are going to take for your method, must be corresponding to the functionality of the method. So that by reading the name of the method we can understand that what this method is going to perform.
Parameter/Argument List: It is the list of parameters/arguments separated by a comma. It’s having the data type and variable name. If the method has no parameter, left the parentheses as blank.
Method Body: In the method body we will define our business logic. It is enclosed within the pair of curly braces, that is nothing but defines method scope.
Constructor
Constructor in Apex is a special type of method that is used to initialize the object.
Apex constructor is invoked at the time of object creation. It constructs the values i.e. provides data for the object that is why it is known as constructor.
Note:
1. Each and every time an object is created using the new() keyword, at least one constructor of the class is get called.
2. It’s called a default constructor in the class if there is no constructor supplied by yourself, it is the responsibility of Apex compiler is to supply a default constructor into your class by default.
Rules for creating Apex constructor:
There are basically two rules defined for the constructor.
- Constructor name always must be same as its class name
- Constructor must have no explicit return type
There are two types of constructors:
- Default constructor (no-arg constructor)
- Parameterized constructor
Apex Default Constructor
A constructor that has no parameter is known as default constructor.
Syntax of default constructor.
public class ApexConstructor{ public ApexConstructor() { System.debug(‘This is Apex Default Constructor’); } }
Apex Parameterized Constructor
A constructor which is having number of arguments, known as Parameterized constructor.
A constructor which is having number of arguments, known as Parameterized constructor. public class ApexConstructor{ public ApexConstructor(Integer no){ System.debug(‘This is Apex parameterized Constructor ‘ +no); } }
Constructor Overloading in Apex
In Apex, a constructor is just like a method but without return type. It can also be overloaded like Apex methods.
Constructor overloading in Apex is a technique of having more than one constructor with same name with different parameter lists. They are basically arranged in a way that each constructor performs a different task as per need. They are differentiated by the compiler by the number of parameters/arguments in the list and their types.
Encapsulation In Apex
Wrapping (or Binding) method and data together into a single unit is known as encapsulation. For example: medical capsule, it is bind with different medicines.
An Apex class is the example of encapsulation. Apex bean is the fully encapsulated class because all the data members are private here.
For example, this is an apex class :
public class MyWrapper { private String name; public void addToName (String text) { name = name + text; } }
This apex class combines two properties, name with a method called addToName as well. This is how an apex class combines logic to embody encapsulation in apex.
Association In Apex Classes
What is the Association?
In object-oriented programming (OOPs), Association defines a relation or connection between two separate classes that are set up through their objects. Association indicates how objects know each other and how they are using each other’s functionality as per need.
In Apex programming we can achieve Association via two ways:
Note: As we have seen above, there are two ways to connect two classes either using IS-A-Relationship or HAS-A-Relationship what being a developer you need to understand in which scenario you have to use IS-A Relationship or HAS-A-Relationship.
Inheritance (IS-A-Relationship):
Inheritance in Apex is a mechanism by which one object acquires all the properties and behaviors of parent object.
The idea behind inheritance in Apex is that you can create new classes that are built upon existing classes. Whenever you inherit from an existing class, you can reuse methods and fields of parent / super class, as well as you can add new methods and fields also based on the requirements.
Why use inheritance in Apex?
- For Method Overriding (to achieved runtime polymorphism).
- For Code Reusability.
Terms used in Inheritance:
- Class: A class is a concept/prototype/template of common properties, from which objects are created.
- Child Class/Sub Class: Child class is a class which inherits the other class, known as child class. It is also called extended class, derived class, or sub class.
- Parent Class/Super Class: Parent class is the class from which a subclass inherits the features. It is also called a Super class or a base class.
- Virtual: The virtual modifier declares that this class allows for extension and overrides.
- Override: You cannot override a method with the override keyword in the child class unless the class and method have been defined as virtual.
Syntax Apex inheritance
public virtual class Parent{ public void display(){ System.debug(‘This is Parent’); } }
Syntax of Sub/Child class
public class Child extends Parent{ public void display show(){ System.debug(‘This is from Child’); } }
Create an object and call method
Child c = new Child(); c.show(); c.display();
Output :
This is from child
This is Parent
HAS-A-Relationship in Apex
What is HAS-A-Relationship: It is basically used for code reusability. It means that an instance of a class has a reference to another class or the other instance.
Why use HAS-A-Relationship?
- For Code Reusability.
Note: Using HAS-A-Relationship, we cannot achieve runtime polymorphism. Only via Inheritance we can achieve runtime polymorphism.
Aggregation: If a class has an entity reference, it is called as Aggregation. Aggregation is a type of HAS-A relationship.
Take an example, Room object contains many chairs. If we take away chairs away from room there is no impact on the existence of Room, as given below.
public class Room { String roomName; Chair ch; //Chair is a class. }
Composition: If a class has an entity reference, it is known as Composition. Composition is also a type of HAS-A relationship.
Take an example, Room object contains many walls. If we take away walls away from room there will be no existence of Room, as given below.
public class Room { String roomName; Wall wal; //Wall is a class. }
Polymorphism In Apex
One name many forms is known as polymorphism or in other words you can say many forms are known as polymorphism.
Real life example of polymorphism: lets take an example, in a college a Director wants to call all HODs for annual meeting so he will just simply publish into notice board that all ALLHOD’S are invited which means one name i.e. ALLHOD’S pointing to all HOD of the college of different departments so by which we can say one name many forms known as polymorphism.
Polymorphism can achieve by two ways:
- Method Overloading in Apex
- Method Overriding in Apex
Method Overloading in Apex:
If a class have multiple methods with same name but different parameters (either different length of the arguments or different data types of the arguments), it is known as Method Overloading.
If we have to perform only one operation, with the same name of the methods increases the readability of the program as well as its very logical too.
Let’s suppose if we want to perform addition of the given numbers but there can be any number in arguments as below:
Example of method overloading with different data types of the arguments with same method name like sum.
public class MethodOverloadDemo{ public void sum(Integer no1, Integer no2){ System.debug(‘Sum of 2 Integer is : ‘+ (no1+no2)); } public void sum(Decimal no1, Decimal no2){ System.debug(‘Sum of 2 Integer is : ‘+(no1+no2)); } }
To run : Create an object and call methods
MethodOverloadDemo mo = new MethodOverloadDemo(); mo.sum(10,20); mo.sum(10.5, 2.5);
Method Overriding In Apex
If a subclass (child class) has the same method as declared in the parent class, it is known as method overriding in Apex.
In other words, we can say If a subclass provides the specific implementation of the method that has been provided by one of its parent class, it is known as method overriding.
Note: Always make sure to achieve method overriding the scope must be of parent and child class relationship and you must have same name method needs to declare into child class with same signature of the method from Parent class to achieve method overriding in Apex.
Usage of Apex Method Overriding
Method overriding is used to provide specific implementation of a method that is already provided by its Parent/Super class. Method overriding is used to achieve runtime polymorphism.
Rules for Apex Method Overriding
- Method name must be same as in the parent class.
- Method name must have same parameter as in the parent class’s method.
- Must be inheritance (IS-A relationship).
Syntax for Method Override
public virtual class Parent { public virtual void display() { System.debug(‘This is Parent’); } }
public class Child extends Parent{ public override void display(){ System.debug(‘This is form Child’); } }
Child ch = new Child(); //OR Parent ch = new Child(); ch.display();
Output :
Abstraction In Apex
Hiding the complexity and given the functionality known as Abstraction.
Real time example of Abstraction: human beings are speaking because GOD given the functionality to them for speaking but how they are speaking and what all their internal body organs they are using for speaking is completely hidden from them so finally we can say they have a functionality of speaking but complexity is completely hidden from them.
Note: Always make sure, abstraction is always for end users not for developers.
In Apex, abstraction can be achieved via 2 ways:
- Abstract Class
- Interface
Abstract Class: There are some points which you always remember while working on abstract class as below:
- If you are making a class as abstract then there is no rule that you guys need to have abstract method inside the abstract class but vice-versa is not true i.e. if you guys having an abstract method inside a class in this case you guys need to declare that class as abstract.
- An abstract class can have abstract methods (a method without body is known as abstract method) as well as concrete methods (a method with body is known as concrete method) too.
- We can have a constructor in abstract class but we cannot instantiate the abstract class which means we cannot create object of abstract class.
- An abstract class always works with the conjunction of child class which means it is a responsibility of child class to override the abstract method of abstract parent class.
Note: If you want that immediate child class will not override the abstract method of parent class in this case you need declare a child class a abstract class.
Syntax of an Abstract Class
public abstract class ApexAbstruct { public ApexAbstruct() { } // default constructor public abstract void show(); // abstract method, having no body public void dispaly(){ // concrete method, having body. System.debug(‘This is normal method ‘); } }
Implemented/Child Class
public class ApexClass extends ApexAbstruct{ //Override the abstract method of parent class public override void show(){ System.debug(‘This is an Astruction example’); } }
Cretae an object and call the methos=d.
ApexClass ap = new ApexClass(); ap.show();
Interfaces: There are some points which you always remember while working on interface as below:
- All the methods of interfaces are by default abstract Which means you do not need to explicitly write abstract keyword in front of method.
- No need to define access specifier in front of method because all the methods of interfaces are by default is global.
- An interface always extends another interface.
- A class always implements an interface.
- It is a responsibility of child class to override all the methods of implemented interface as all the methods of interface are by default is abstract.
Note: Interfaces are used to achieve 100% abstraction.
Syntax of an Interface
public interface ApexInterface{ void show(); }
Implemented class
public class Apex implements ApexInterface{ public void show(){ System.debug(‘This is Apex interface example’); } }
Create an object and call the method
Apex ap = new Apex(); ap.show();
Output:
Exception Handling in Apex
Exception Handling is a mechanism in salesforce to handle unwanted exceptions or errors in our code without the exception breaking the flow of the code.
This is a practice which allows the developers to handle any exceptions in their code, which allows them to account for any errors in the system. This is a best practice that should be followed while developing apex classes.
Exception handling is done in apex by using the try and catch mechanism, basically any code which can throw an exception is enclosed in a try block and each try block is followed by a catch block which is entered if the try block throws an exception.
try{ // Exception prone Code } catch(Exception e){ // Handle the exception }
Exceptional Handling – try, catch, finally, throw keywords
Exception occurs during the run time / execution of a program. We have to handle the excretion in code. Like java, apex has exception handling mechanism. Below are the Keywords(try, catch, finally, throw ) related to an Exceptional Handling.
try: This keyword is used to identifies a block of code in which an exception can occur.
Example:
try { // Your code here } catch (ListException e) { // List Exception handling code here }
catch: This keyword is used to identifies a block of code that can handle a particular type of exception.
Example:
try { // Your code here } catch (ListException e) { // List Exception handling code here }
finally: This keyword is used to identifies a block of code that is guaranteed to execute.
Example:
try { // Your code here } catch (ListException e) { // List Exception handling code } finally { // will execute with or without exception }
throw: This keyword is used to throws an exception, signaling that an error has occurred.
Example:
public class MyException extends Exception { try { Integer i; if (i < 5) throw new MyException(); } catch (MyException e) { // Your MyException handling // code here } }
Commonly used exceptions in Apex
1. DmlException
Any problem with DML statement, such as an insert statement missing a required field a record.
Example
try { Merchandise__c m = new Merchandise__c(); insert m; } catch(DmlException e) { System.debug(‘The following exception has occurred: ‘ + e.getMessage()); }
2. Limit exception
Governor limits are runtime limits which are enforced by the Apex runtime engine. Because Apex runs in a shared and multi-tenant environment, the Apex runtime engine strictly enforces a number of limits to ensure that code does not take over shared resources. Types of limits that Apex enforces are resources like database, memory, number of script statements to avoid infinite loops, and the number of records being processed in a transaction. If the code exceeds a defined limit, the associated governor fires a runtime exception.
Example
Create an object with label Test Object with only one field Name which is of text type. Write an class that is used to inserts 300 records in Test Object.
public class TestDataController { public static Test_Object__c test; public static void massInsert(){ for(Integer count = 0; count < 300; count++){ test = new Test_Object__c(); test.Name = ‘data field ‘ + count; insert test; } }
now it's time to call the static method from your developer Console as shown below
From that Open Developer Console
TestDataController.massInsert();
Debug -> Open Execute Anonymous Window OR (CTRL + E).
Call TestDataController.massInsert(); as shown above.
Click Execute.
You can see that no rows are updated. The exception is
System.LimitException.
3. List Exception
Any problem with a list, for example attempting to access an index that is out of bound.
Example
try{ List li = new List(); li.add(10); Integer i1 = li[0]; Integer i1 = li[1]; // List exception }catch(listException le){ System.debug(‘The Exception is : ‘+le.getMessage()); }
4. Math Exception
Any problem with mathematical operation, such as divide by zero.
Example
Integer i= 1/0; // System.MathException
5. NullPointer Exception
This type of exception occur when you are trying to call a method with null i.e. if a variable is pointing to null and you are trying to call a method cause a NullPointerException.The exception is caught in our defined catch block and this is what is written to the debug log: The below exception has occurred: Attempt to de-reference a null object.
Example
String s; s.toLowerCase(); // Since s is pointing to null, this call causes // a NullPointerException or try { String s; Boolean b = s.contains(‘abc’); // Causes a NullPointerException } catch(NullPointerException npe) { System.debug(‘The following exception has occurred: ‘ + npe.getMessage()); }
6. QueryException:
Any problem with SOQL queries, like assigning a query that returns no records or you can say more than one record to a singleton sObject variable.
Example
try { // This statement doesn’t cause an exception, even though // we don’t have a merchandise with name=’XYZ’. // The list will just be empty. List lm = [SELECT Name FROM Merchandise__c WHERE Name=’XYZ’]; // lm.size() is 0 System.debug(lm.size()); // However, this statement causes a QueryException because // we’re assigning the return value to a Merchandise__c object // but no Merchandise is returned. Merchandise__c m = [SELECT Name FROM Merchandise__c WHERE Name=’XYZ’ LIMIT 1]; } catch(QueryException qe) { System.debug(‘The following exception has occurred: ‘ + qe.getMessage()); }
7. Creating Custom Exceptions
Since you cannot throw salesforce built-in Apex exceptions but can only catch them, you can create custom exceptions to throw in your methods as per your requirement. That way, you can also specify detailed error messages and have much more custom exception handling in your defined catch blocks. To create your custom exception class, extends with the keyword Exception(Which is the super class of all the exception class either built-in or custom). Append extends Exception after your class declaration as given below:
Syntax
public class MyException extends Exception {}
Example
Public class ContactException extends Exception{} public class ContactUtility { public static void mainProcessing() { try { insertContact(); }catch(ContactException me) { System.debug(‘Message: ‘ + me.getMessage()); System.debug(‘Cause: ‘ + me.getCause()); System.debug(‘Line number: ‘ + me.getLineNumber()); System.debug(‘Stack trace: ‘ + me.getStackTraceString()); } } public static void insertContact() { try { // Insert Contact without required fields Contact m = new Contact(); insert m; } catch(DmlException e) { // Something happened that prevents the insertion // of Contact objects, so throw a more // specific exception. throw new ContactException(‘Contact could not be inserted.’, e); } } }
- By default all the variables and methods are non-static.
- Scope of the non-static variables or metods is within the scope of the same object.
- We can declare variables and methods as static by using static keyword.
- Scope of the static variables and methods is through out the transaction.
- Static variables and methods, we can directly call with class name (we cannot access static variables and methods with object name).