Introdução ao Apex
Objetivos de aprendizagem
Após concluir esta unidade, você estará apto a:
- Descrever os principais recursos da linguagem de programação do Apex.
- Salvar uma classe do Apex e métodos de chamada com Apex anônimo.
- Use o Web Console para inspecionar registros de depuração.
Antes de começar
Estamos empolgados em acompanhá-lo em sua aventura Apex. Embora este módulo cubra informações básicas sobre a linguagem de programação, ele também aprofunda a questão, rapidamente. Se este módulo for sua primeira exposição ao Apex, recomendamos que você consulte primeiro o projeto Início rápido: Apex. Mas depois volte. Estaremos esperando por você!
O que é o Apex?
Apex é uma linguagem de programação que usa sintaxe similar à do Java e funciona como procedimentos armazenados no banco de dados. O Apex permite que os desenvolvedores adicionem lógica de negócios a eventos do sistema, tais como cliques em botões, atualizações de registros relacionados e páginas do Visualforce.
Como linguagem, o Apex é:
-
Hospedado – o Apex é salvo, compilado e executado no servidor, que é a Salesforce Platform.
-
Orientado por objetos – o Apex é compatível com classes, interfaces e herança.
-
Altamente tipificado – o Apex valida as referências aos objetos no momento da compilação.
-
Consciente dos multilocatários – como o Apex é executado em uma plataforma multilocatário, ele protege rigorosamente contra códigos sem controle através da imposição de limites. Estes limites ajudam a impedir que o código de monopolize recursos compartilhados.
-
Integrado ao banco de dados – ele acessa e manipula registros diretamente. O Apex proporciona acesso direto aos registros e seus campos, e oferece instruções e linguagens de consulta para manipular tais registros.
-
Concentrado nos dados – o Apex oferece acesso transacional ao banco de dados, permitindo que você reverta operações.
-
Fácil de usar – o Apex se baseia em linguagens Java conhecidas.
-
Fácil de testar – o Apex oferece suporte integrado à criação, execução e cobertura de código de testes de unidade.
-
Compatível com versões – é possível salvar códigos personalizados do Apex referentes a diversas versões da API.

Destaques da linguagem Apex
Assim como outras linguagens de programação orientadas por objeto, o Apex é compatível com estas construções de linguagem, entre outras:
- Classes, interfaces, propriedades e coleções (listas, mapas e conjuntos).
- Notação de objeto e matriz.
- Expressões, variáveis e constantes.
- Instruções condicionais (if-then-else) e instruções de fluxo de controle (loops for e loops while).
Ao contrário das outras linguagens de programação orientadas por objeto, o Apex é compatível com:
- Desenvolvimento na nuvem, pois o Apex é armazenado, compilado e executado na nuvem.
- Acionadores, que são semelhantes aos acionadores dos sistemas de banco de dados.
- Instruções de banco de dados, que permitem fazer chamadas diretas para o banco de dados e consultar linguagens a fim de consultar e pesquisar dados.
- Transações e reversões.
- Modificador de acesso
global, que é mais permissivo do que o modificadorpublice permite o acesso entre namespaces e aplicativos.
- Versões do código personalizado.
Além disso, o Apex é uma linguagem que não diferencia maiúsculas de minúsculas.
Ferramentas de desenvolvimento
Você também pode programar e depurar o Apex no computador cliente utilizando Extensões do Salesforce para Visual Studio Code. Consulte Desenvolver com facilidade usando extensões do Salesforce.
Também é possível programar Apex e acessar informações de depuração diretamente no navegador por meio da interface de usuário do Salesforce. Web Console é um ambiente de desenvolvimento integrado (IDE) moderno, leve e baseado em navegador, projetado para preencher a lacuna entre ferramentas legadas desatualizadas e ambientes de desenvolvimento com alto consumo de recursos. Para saber mais, consulte a documentação para desenvolvedor do Web Console.
Você pode abrir o Web Console no menu de acesso rápido (
).

Visão geral dos tipos de dados
O Apex dá suporte a vários tipos de dados, inclusive um tipo de dados específico do Salesforce, o sObject.
O Apex dá suporte aos seguintes tipos de dados.
-
Números primitivos, como números inteiros, duplos, longos, data, data/hora, string, ID, booleano e outros.
- Um sObject, seja um sObject genérico ou específico, como uma Conta, um Contato ou MyCustomObject__c (você aprenderá mais sobre sObjects em outra unidade).
- Uma coleção, incluindo:
-
Uma lista – uma coleção ordenada e indexada de elementos. Os elementos de uma lista podem ser de qualquer tipo de dados, incluindo tipos primitivos, coleções, sObjects, tipos definidos pelo usuário e tipos do Apex fornecidos pelo sistema (integrados).
- Um conjunto – uma coleção não ordenada de elementos. Os elementos de um conjunto também podem ser de qualquer tipo de dados e não podem conter valores duplicados.
- Um mapa – uma coleção de pares de chave-valor que podem ser de qualquer tipo de dados.
- Uma lista tipificada de valores, também conhecida como enum
- Classes do Apex definidas pelo usuário (personalizadas)
- Classes do Apex fornecidas pelo sistema (integradas)
Coleções do Apex: Lista
As listas contêm uma coleção ordenada de dados do mesmo tipo.
As duas declarações a seguir são equivalentes. A variável colors é declarada usando a sintaxe List.
List<String> colors = new List<String>();
Como alternativa, a variável colors (cores) pode ser declarada usando a notação de matriz.
String[] colors = new List<String>();
Cultive coleções conforme necessário usando o método List.add() para adicionar novos elementos. Você pode usar a notação da matriz de colchetes para referenciar elementos existentes na coleção por índice. No entanto, você não pode usar a notação de matriz de colchetes para adicionar mais elementos.
Este exemplo mostra como adicionar elementos a uma lista, quando você cria uma e, em seguida, usar o método add() para adicionar mais elementos.
// Create a list and add elements to it in one step
List<String> colors = new List<String> { 'red', 'green', 'blue' };
// Add elements to a list after it has been created
List<String> moreColors = new List<String>();
moreColors.add('orange');
moreColors.add('purple');Os elementos de lista podem ser lidos com a especificação de um índice entre colchetes, conhecido como notação de matriz. Além disso, você pode usar o método get() para ler um elemento de lista. Este exemplo é baseado nas listas criadas no exemplo anterior e mostra como ler elementos de lista usando um desses métodos. O exemplo também mostra como iterar sobre elementos da lista.
// Get elements from a list
String color1 = moreColors.get(0);
String color2 = moreColors[0];
System.assertEquals(color1, color2);
// Iterate over a list to read elements
System.debug('Print out the colors in moreColors:');
for(String color : moreColors) {
// Write value to the debug log
System.debug(color);
}Ir além das noções básicas
O Apex dá suporte a mais dois tipos de coleção: Set e Map. Saiba mais sobre eles na seção Coleções do Guia do desenvolvedor do Apex.
Classes do Apex
Uma das vantagens das classes do Apex é a reutilização do código. Os métodos de classe podem ser chamados por acionadores e outras classes. O tutorial a seguir orienta você no processo de salvar uma classe de exemplo em sua organização, usando esta classe para atualizar descrições de contas, e inspecionar registros de depuração.
Salvar uma classe do Apex
A classe AccountProcessor tem um método público updateAccountDescriptions(). Esse método pega uma lista de contas e atualiza as respectivas descrições de acordo com o formato especificado no método auxiliar privado applyStandardFormatting(). Não é possível chamar métodos auxiliares privados externamente; eles precisam ser chamados de dentro da classe. A classe AccountProcessor também contém o método auxiliar privado inspectResults(), que inspeciona os resultados da operação de atualização do banco de dados.
Salve a classe AccountProcessor na sua organização do Trailhead.
- Abra o Web Console no menu de acesso rápido (
).
- No Web Console, pressione Ctrl+Shift+P (Windows) ou ⌘+Shift+P (macOS) para abrir a paleta de comandos.
- Insira
SFDX: Create Apex Classe pressione Enter.
- Para o tipo de modelo, selecione DefaultApexClass e pressione Enter.
- Como nome do projeto, insira
AccountProcessore pressione Enter.
- Para o diretório de saída, selecione force-app/main/default/classes e pressione Enter.
- Substitua o corpo da classe padrão pelo exemplo da classe
AccountProcessor.
public with sharing class AccountProcessor {
/**
* Applies a standard formatting to the descriptions of accounts in the list,
* and updates each account.
*/
public void updateAccountDescriptions(List<Account> acctList) {
if (acctList == null || acctList.isEmpty()) {
System.debug('Account list is null or empty.');
return;
}
for (Account acc : acctList) {
applyStandardFormatting(acc);
}
Database.SaveResult[] srList = Database.update(acctList,
false,
AccessLevel.USER_MODE);
inspectResults(srList);
}
/**
* Private helper method to handle the description formatting logic.
*/
private static void applyStandardFormatting(Account acc) {
String timestamp = String.valueOf(Datetime.now());
if (String.isBlank(acc.Description)) {
acc.Description = 'Account updated on: ' + timestamp;
} else {
acc.Description += ' | Last processed: ' + timestamp;
}
}
/*
* Private helper method to inspect the returned results.
*/
private static void inspectResults(Database.SaveResult[] results) {
for (Database.SaveResult sr : results) {
if (sr.isSuccess()) {
System.debug('Successfully updated account. Account ID: ' + sr.getId());
} else {
for (Database.Error err : sr.getErrors()) {
System.debug('The following error has occurred.');
System.debug(err.getStatusCode() + ': ' + err.getMessage());
System.debug('Account fields that affected this error: ' +
err.getFields());
}
}
}
}
}- Para salvar sua classe, pressione Ctrl+S (Windows) ou ⌘+S (macOS).
O Salesforce compila e implanta sua classe quando você a salva.
Ir além das noções básicas
A classe que você acabou de salvar utiliza a programação orientada a objetos (OOP, object-oriented programming). A classe encapsula os métodos que estão relacionados ao gerenciamento de emails. Para ser um exemplo perfeito de OOP, a classe também deveria conter variáveis membro (atributos) e métodos de acessador para acessar esses atributos. No entanto, por questões de simplificação, nossa classe não inclui nada disso.
Chamar um método para atualizar a descrição de uma conta
Vamos invocar o método público. Vamos usar a execução do Apex anônimo para fazer isso. O Apex anônimo permite executar linhas de código instantaneamente e é uma maneira prática de invocar o Apex, especialmente para testar a funcionalidade. São gerados resultados de registro de depuração, como em qualquer outra execução do Apex.
- No Web Console (Console da Web), pressione Ctrl+Shift+P (Windows) ou Cmd+Shift+P (macOS) para abrir a paleta de comandos.
- Insira
SFDX: Create Anonymous Apex Scripte pressione Enter.
- Como nome da classe, insira
UpdateAccountse pressione Enter.
- Para o diretório de saída, selecione scripts/apex e pressione Enter.
- Insira este código.
// Create new accounts
List<Account> newAccts = new List<Account>();
newAccts.add(new Account(Name='My New Account', Description='Original Description'));
newAccts.add(new Account(Name='My Second New Account'));
// Insert them into the database
try {
insert as user newAccts;
System.debug('Successfully inserted ' + newAccts.size() + ' accounts.');
} catch (Exception e) {
System.debug('An error inserting the records occurred: ' + e.getMessage());
}
// Instantiate an AccountProcessor object
AccountProcessor myAcctProcessor = new AccountProcessor();
// Pass the original list to update the account descriptions
myAcctProcessor.updateAccountDescriptions(newAccts);- Para salvar o script, pressione Ctrl+S (Windows) ou ⌘+S (macOS).
- Para executar o script, clique com o botão direito do mouse no editor de texto e selecione SFDX: Execute Anonymous Apex with Currently Open Editor (SFDX: Executar Apex anônimo com o editor atualmente aberto).
- No Salesforce, abra as páginas de detalhes dos registros My New Account (Minha nova conta) e My Second New Account (Minha segunda nova conta).
O campo Description (Descrição) do registro My New Account (Minha nova conta) deve ser Original Description | Last processed: 2026-01-01 00:00:00 e o campo Description (Descrição) do registro My Second New Account (Minha segunda nova conta) deve ser Account updated on: 2026-01-01 00:00:00, exceto que ambos os carimbos de data/hora refletirão a hora e a data em que você executou a transação do Apex anônima.
Ver registros de depuração
Os registros de depuração são úteis para depurar seu código. Quando os métodos do Apex são executados, as chamadas são registradas no registro de depuração. Além disso, você pode gravar suas próprias mensagens de depuração no registro para ajudar na depuração do código no caso de existirem erros. O método auxiliar inspectResults(), chamado por updateAccountDescriptions(), grava mensagens no registro usando o método System.debug() para indicar se a operação de atualização do banco de dados foi bem-sucedida ou apresentou erros. Você pode procurar estas mensagens no registro de depuração que foi gerado ao executar o método.
- Após executar o script UpdateAccounts em Web Console (Console da Web), abra o painel Output (Saída).
- Selecione Depurar apenas para filtrar o registro, para que apenas as linhas de registro das instruções
System.debug()sejam exibidas.
- No campo filter (filtrar), na parte superior do painel Output (Saída), insira
USER_DEBUGpara filtrar o log de modo que apenas as linhas de log das instruçõesSystem.debug()sejam exibidas.
- Você também pode ver o registro de depuração no diretório .sfdx/tools/debug/logs.

Você verá as seguintes mensagens na exibição filtrada do registro, desde que o script tenha sido executado sem erros.
DEBUG|Successfully inserted 2 accounts.
DEBUG|Successfully updated account. Account ID: {id}
DEBUG|Successfully updated account. Account ID: {id}Chamar um método estático
Como o método updateAccountDescriptions() em nossa classe não acessa variáveis membro da classe, não é necessário que ele seja um método de instância. Vamos alterá-lo para método estático adicionando a palavra-chave static a sua declaração. Os métodos estáticos são mais fáceis de chamar do que os métodos de instância porque eles não precisam ser chamados em uma instância da classe, mas são chamados diretamente no nome da classe.
- Em Web Console (Console da Web), abra o arquivo de classe
AccountProcessor.cls.
- Modifique a primeira linha da definição
updateAccountDescriptions(). A única alteração é a adição da palavra-chavestatic.
public static void updateAccountDescriptions(List<Account> acctList) {- Para salvar sua classe, pressione Ctrl+S (Windows) ou ⌘+S (macOS). A classe é reimplantada quando você salva.
- Abra o arquivo de script do Apex anônimo
UpdateAccounts.apex.
- Substitua o código atual pelo código a seguir, para que o script chame o método estático no nome da classe.
// Create new accounts
// For clarity, use different account names than the ones you used previously
List<Account> newAccts = new List<Account>();
newAccts.add(new Account(Name='My Third New Account', Description='Original Description'));
newAccts.add(new Account(Name='My Fourth New Account'));
// Insert them into the database
try {
insert as user newAccts;
System.debug('Successfully inserted ' + newAccts.size() + ' accounts.');
} catch (Exception e) {
System.debug('An error inserting the records occurred: ' + e.getMessage());
}
// Pass the original list to update the account descriptions
// The static method is called directly on the class
AccountProcessor.updateAccountDescriptions(newAccts);- Para salvar o script, pressione Ctrl+S (Windows) ou ⌘+S (macOS).
- Para executar o script, clique com o botão direito do mouse no editor de texto e selecione SFDX: Execute Anonymous Apex with Currently Open Editor (SFDX: Executar Apex anônimo com o editor atualmente aberto). Agora que esse método foi executado, você pode verificar as descrições de contas atualizadas no Salesforce e, opcionalmente, o registro de depuração como nas etapas anteriores.
Recursos
- Guia do desenvolvedor do Apex: Introdução ao Apex
- Guia do desenvolvedor do Apex: Loops
- Desenvolvedores do Salesforce: Usar Apex anônimo
- Web Console (Console da Web): Depurar código do Apex
