Salesforce Developer Tutorial

Salesforce Developer

Salesforce is one of the most popular CRM platforms, and it has a vast ecosystem of developers, administrators, and users. As a Salesforce developer, you can use Apex programming language to create custom functionality, automate business processes, and integrate with other systems.

In this Salesforce Developer tutorial, we will explore the basics of Apex programming and how to use it to develop on the Salesforce platform.

Getting Started with Apex Programming

Before we dive into Apex programming, we need to set up the Developer Console, which is an integrated development environment (IDE) for Salesforce developers. To access the Developer Console, go to Setup > Developer Console, or press Ctrl+Shift+I in Salesforce Classic.

Once you’re in the Developer Console, you can create a new Apex class by clicking File > New > Apex Class. In the new class window, you can give your class a name and define its access level (public, private, or global). Then, you can start writing your Apex code in the editor.

Apex code is similar to Java and C#, and it has its own syntax and keywords. Here’s an example of a basic Apex class:

public class HelloWorld {

public static void sayHello() {

System.debug(‘Hello, World!’);



This class defines a static method called sayHello that prints a message to the debug log. To execute this code, you can click on the “Execute Anonymous” button in the Developer Console and type HelloWorld.sayHello(); in the code editor. This will run the sayHello method and print the message in the debug log.

Salesforce Classes and Methods

In Apex programming, a class is a blueprint for creating objects, and a method is a block of code that performs a specific task. Salesforce provides many built-in classes and methods that you can use in your Apex code, such as the String class and the System.debug method.

To define your own class in Apex, you can use the class keyword followed by the class name and its access level. Here’s an example of a custom class in Apex:

public class ContactUtils {

public static void validateContact(Contact c) {

if (c.Email == null) {

throw new ContactException(‘Email is required.’);




This class defines a static method called validateContact that takes a Contact object as a parameter and checks if its email field is null. If the email is null, the method throws a custom exception called ContactException.

To use this class in your Apex code, you can create an instance of the class and call its methods. Here’s an example of using the ContactUtils class:

Contact c = new Contact();

c.FirstName = ‘John’;

c.LastName = ‘Doe’;

try {


} catch (ContactException ex) {



This code creates a new Contact object and sets its first name and last name fields. Then, it calls the validateContact method from the ContactUtils class and catches any exceptions that it throws.

Salesforce Objects

In Salesforce, an object is a database table that stores records of a specific type. Salesforce provides many standard objects, such as Account, Contact, and Opportunity, and you can create custom objects to store your own data.

To perform CRUD (create, read, update, delete) operations on Salesforce objects in Apex, you can use the Salesforce Object Query Language (SOQL) and the Salesforce Object Data Language (SODA). SOQL is similar to SQL, and it allows you to query and manipulate Salesforce data, while SODA provides a higher-level abstraction over SOQL and supports additional operations such as upsert.

Here’s an example of using SOQL to retrieve a list of contacts from Salesforce:

List<Contact> contacts = [SELECT Id, FirstName, LastName, Email FROM Contact WHERE LastName = ‘Doe’];

This code retrieves a list of contacts whose last name is “Doe” and returns their Id, first name, last name, and email fields.

Static Methods and Constructors in Apex Programming

In Apex programming, a static method is a method that belongs to the class rather than an instance of the class. You can use static methods to perform operations that don’t require an object instance, such as utility methods or factory methods.

Here’s an example of a static method in Apex:

public class MathUtils {

public static Integer add(Integer x, Integer y) {

return x + y;



This class defines a static method called add that takes two integer parameters and returns their sum. To use this method, you don’t need to create an instance of the MathUtils class. You can simply call the method using the class name and the dot notation, like this:

Integer result = MathUtils.add(3, 4);

This code calls the add method from the MathUtils class and assigns the result to the result variable.

In Apex programming, a constructor is a special method that gets called when you create a new instance of a class. Constructors allow you to initialize the state of the object and perform any necessary setup.

Here’s an example of a constructor in Apex:

public class Person {

public String firstName;

public String lastName;

public Person(String firstName, String lastName) {

this.firstName = firstName;

this.lastName = lastName;



This class defines a constructor that takes two string parameters and sets the firstName and lastName fields of the object.

To create a new instance of the Person class, you can use the new keyword and pass the constructor parameters, like this:

Person p = new Person(‘John’, ‘Doe’);

This code creates a new Person object with the first name “John” and the last name “Doe”.

Collections in Salesforce

In Apex programming, a collection is an object that stores a group of related elements. Salesforce provides three types of collections: lists, sets, and maps.

A list is an ordered collection of elements, and you can access its elements using an index. Here’s an example of a list in Apex:

List<String> fruits = new List<String>{‘Apple’, ‘Banana’, ‘Orange’};

String secondFruit = fruits[1];

This code creates a list of fruits and assigns the second fruit (Banana) to the secondFruit variable.

A set is an unordered collection of elements, and you can’t access its elements using an index. Here’s an example of a set in Apex:

Set<String> colors = new Set<String>{‘Red’, ‘Green’, ‘Blue’};

Boolean containsGreen = colors.contains(‘Green’);

This code creates a set of colors and checks if it contains the color green.

A map is a collection of key-value pairs, and you can access its values using the keys. Here’s an example of a map in Apex:

Map<String, Integer> prices = new Map<String, Integer>{‘Apple’ => 1, ‘Banana’ => 2, ‘Orange’ => 3};

Integer bananaPrice = prices.get(‘Banana’);

This code creates a map of fruit prices and retrieves the price of a banana using the get method.

Collections can be very useful in Salesforce development when working with large amounts of data. For example, you can use a list to store a set of records retrieved from a SOQL query, or you can use a set to remove duplicates from a list.


In this tutorial, we covered several important topics for Salesforce developers. We discussed Apex programming, the Developer Console, Salesforce classes and methods, and collections in Salesforce. We also looked at static methods and constructors in Apex programming.

By mastering these topics, you’ll be well on your way to becoming a successful Salesforce developer. Salesforce is a powerful platform with many features, and there’s always more to learn. Keep exploring, and you’ll discover new ways to build amazing applications that meet your business needs.

You May Also Like

About the Author: John Taylor

Leave a Reply

Your email address will not be published. Required fields are marked *