Tutorial APEX: lezioni di programmazione Apex ed esempi di codifica

Apex aiuta gli sviluppatori ad aggiungere logica aziendale agli eventi di sistema come clic sui pulsanti, aggiornamenti dei record correlati e pagine Visualforce. Apex ha una sintassi simile a Java. Registrati a Salesforce per scoprire come funziona il CRM

Caratteristiche del linguaggio di programmazione Apex

Ecco le caratteristiche importanti di Salesforce Apex:

• Apex è un linguaggio senza distinzione tra maiuscole e minuscole.
• Puoi eseguire operazioni DML come INSERT, UPDATE, UPSERT, DELETE sui record sObject utilizzando apex.
• È possibile eseguire query sui record sObject utilizzando SOQL (linguaggio di query degli oggetti di Salesforce) e SOSL (linguaggio di ricerca degli oggetti di Salesforce) in apex.
• Ti permette di creare un test unitario ed eseguirli per verificare il copertura del codice ed efficienza del codice in apice.
• Apex viene eseguito in un ambiente multi-tenant e Salesforce ha definito alcuni limiti del governatore che impediscono ad un utente di controllare le risorse condivise. Qualsiasi codice che supera il limite di Salesforce Governor non riesce e viene visualizzato un errore.
• L'oggetto Salesforce può essere utilizzato come tipo di dati in apex. Per esempio -

  Account acc = new Account();

  ,qui Account è un oggetto Salesforce standard.

• Apex si aggiorna automaticamente con ogni versione di Salesforce.

Quando lo sviluppatore dovrebbe scegliere Apex

Il codice Apex dovrebbe essere scritto solo se uno scenario aziendale è troppo complesso e non può essere implementato utilizzando le funzionalità predefinite fornite da Salesforce.

Di seguito sono riportati alcuni scenari in cui è necessario scrivere il codice Apex:

• Per creare servizi web che integrino Salesforce con altre applicazioni.
• Per implementare la convalida personalizzata sugli oggetti.
• Per eseguire la logica apex personalizzata quando viene eseguita un'operazione DML.
• Per implementare funzionalità che non possono essere implementate utilizzando flussi di flussi di lavoro esistenti e funzionalità di creazione di processi.
• Impostare servizi di posta elettronica, è necessario includere l'elaborazione del contenuto, delle intestazioni e degli allegati delle e-mail tramite codice Apex.

Struttura di lavoro dell'apice

Ora in questo tutorial di Apex impareremo la struttura di lavoro di Apex:

Di seguito è riportato il flusso di azioni per un codice Apex:

• Azione dello sviluppatore: tutto il codice apex scritto da uno sviluppatore viene compilato in una serie di istruzioni che possono essere comprese dall'interprete runtime apex quando lo sviluppatore salva il codice sulla piattaforma e queste istruzioni vengono quindi salvate come metadati sulla piattaforma.
• Azione dell'utente finale: quando l'evento utente esegue un codice apex, il server della piattaforma ottiene le istruzioni compilate dai metadati e le esegue tramite l'interprete apex prima di restituire il risultato.

Sintassi dell'apice

Dichiarazione di variabili

Poiché apex è un linguaggio fortemente tipizzato, è obbligatorio dichiarare una variabile con tipo di dati in apex.

Per esempio:

contact con = new contact(); 

qui la variabile con è dichiarata con contact come tipo di dati.

Domanda SOQL

SOQL sta per linguaggio di query degli oggetti Salesforce. SOQL viene utilizzato per recuperare i record sObject dal database Salesforce. Per esempio-

Account acc = [select id, name from Account Limit 1]; 

La query precedente recupera il record dell'account dal database Salesforce.

Dichiarazione del ciclo

L'istruzione loop viene utilizzata per scorrere i record in un elenco. Il numero di iterazioni è uguale al numero di record nell'elenco. Per esempio:

list<Account>listOfAccounts = [select id, name from account limit 100];
// iteration over the list of accounts
for(Account acc : listOfAccounts){
	//your logic
}

Nello snippet di codice sopra, listOfAccounts è una variabile di tipo dati list.

Dichiarazione di controllo del flusso

L'istruzione di controllo del flusso è utile quando si desidera eseguire alcune righe del codice in base ad alcune condizioni.

Per esempio:

list<Account>listOfAccounts = [select id, name from account limit 100];
// execute the logic if the size of the account list is greater than zero
if(listOfAccounts.size() >0){
	//your logic
}

Lo snippet di codice riportato sopra interroga i record dell'account dal database e controlla la dimensione dell'elenco.

Dichiarazione DML

DML sta per linguaggio di manipolazione dei dati. Le istruzioni DML vengono utilizzate per manipolare i dati nel database Salesforce. Per esempio -

Account acc = new Account(Name = ‘ Test Account’);
Insert acc; //DML statement to create account record.

Ambiente di sviluppo Apex

Ora in questo tutorial di programmazione Apex impareremo l'ambiente di sviluppo Apex:

Il codice Apex può essere sviluppato sia nella sandbox che nella developer edition di Salesforce.

È buona norma sviluppare il codice nell'ambiente sandbox e poi distribuirlo nell'ambiente di produzione.

Strumenti di sviluppo del codice Apex: di seguito sono riportati i tre strumenti disponibili per sviluppare il codice Apex in tutte le edizioni di Salesforce.

• Console per sviluppatori Force.com
• IDE Force.com
• Editor di codice nell'interfaccia utente di SalesforceYou

Tipo di dati in Apex

Di seguito sono riportati i tipi di dati supportati da Apex:

Primitivo

Numero intero, Double, Long, Date, Date Time, String, ID e Boolean sono considerati tipi di dati primitivi. Tutti i tipi di dati primitivi vengono passati per valore, non per riferimento.

Collezioni

In Apex sono disponibili tre tipi di raccolta

• Elenco: è una raccolta ordinata di primitive, sObject, raccolte o oggetti Apex basati su indici.
• Set: una raccolta non ordinata di primitive uniche.
• Mappa: è una raccolta di chiavi primitive univoche che si associano a singoli valori che possono essere primitivi, sObject, raccolte o oggetti Apex.

sOggetto

Questo è un tipo di dati speciale in Salesforce. È simile a un tavolo in SQL e contiene campi simili alle colonne in SQL.

Enums

Enum è un tipo di dati astratto che memorizza un valore di un insieme finito di identificatori specificati

Classi

Oggetti

Si riferisce a qualsiasi tipo di dati supportato in Apex.

interfacce

Identificatore di accesso Apex

Di seguito sono riportati gli specificatori di accesso supportati da Apex:

Pubblico

Questo specificatore di accesso fornisce l'accesso a una classe, un metodo, una variabile che deve essere utilizzata da un apice all'interno di uno spazio dei nomi.

Privata

Questo identificatore di accesso fornisce l'accesso a una classe, metodo, variabile da utilizzare localmente o all'interno della sezione di codice definita. In tutte le variabili tecniche che non hanno alcun identificatore di accesso definito hanno lo specificatore di accesso predefinito private.

Protetta

Questo identificatore di accesso fornisce l'accesso a un metodo, variabile che deve essere utilizzata da qualsiasi classe interna all'interno della definizione della classe Apex.

Global

Questo identificatore di accesso fornisce l'accesso a una classe, un metodo, una variabile che deve essere utilizzata da un apice all'interno di uno spazio dei nomi e all'esterno dello spazio dei nomi. È consigliabile non utilizzare la parola chiave globale finché non è necessario.

Parole chiave in Apex

Con condivisione

Se una classe viene definita con questa parola chiave, vengono applicate tutte le regole di condivisione all'utente corrente e se questa parola chiave è assente, il codice viene eseguito nel contesto di sistema.

Per esempio:

public with sharing class MyApexClass{
// sharing rules enforced when code in this class execute
}

Senza condivisione

Se una classe viene definita con questa parola chiave, tutte le regole di condivisione applicabili all'utente corrente non vengono applicate.

Per esempio:

public without sharing class MyApexClass{
// sharing rules is not enforced when code in this class execute
}

statica

Una variabile, Method, definita con la parola chiave static, viene inizializzata una volta e associata alla classe. Variabili statiche, i metodi possono essere chiamati direttamente dal nome della classe senza creare l'istanza di una classe.

fine

Una costante, Method, è definita con la parola chiave final e non può essere sovrascritta. Per esempio:

public class myCls {
static final Integer INT_CONST = 10;
}

Se provi a sovrascrivere il valore di questa variabile INT_CONST, otterrai un'eccezione: System.FinalException: la variabile finale è già stata inizializzata.

LUOGO DI RICONSEGNA

Questa parola chiave restituisce un valore da un metodo. Per esempio:

public String getName() {
return  'Test' ;
}

Nullo

Definisce una costante nulla e può essere assegnata a una variabile. Per esempio

 Boolean b = null;

virtuale

Se una classe è definita con una parola chiave virtuale, può essere estesa e sovrascritta.

Astratto

Se una classe è definita con la parola chiave abstract, deve contenere almeno un metodo con la parola chiave abstract e quel metodo deve avere solo una firma.

Per esempio

public abstract class MyAbstrtactClass {
abstract Integer myAbstractMethod1();
}

Corda apicale

Una stringa è un insieme di caratteri senza limiti di caratteri. Per esempio:

String name = 'Test';

Ci sono diversi metodi incorporati forniti dalla classe String in Salesforce. Di seguito sono riportate alcune funzioni frequentemente e maggiormente utilizzate:

abbreviare(larghezzamax)

Questo metodo tronca una stringa alla lunghezza specificata e la restituisce se la lunghezza della stringa data è maggiore della lunghezza specificata; in caso contrario, restituisce la stringa originale. Se il valore per la variabile maxWidth è inferiore a 4, questo metodo restituisce un'eccezione di runtime: System.StringException: la larghezza minima dell'abbreviazione è 4

Per esempio:

String s = 'Hello World';
String s2 = s.abbreviate(8);
System.debug('s2'+s2); //Hello...

capitalizzare()

Questo metodo converte la prima lettera di una stringa nel titolo e la restituisce.

Per esempio:

String s = 'hello;
String s2 = s.capitalize();
System.assertEquals('Hello', s2);

contiene(sottostringa)

Questo metodo restituisce true se la stringa che chiama il metodo contiene la sottostringa specificata.

String name1 = 'test1';
String name2 = 'test2';
Boolean flag = name.contains(name2);
System.debug('flag::',+flag); //true

è uguale a(stringOrId)

Questo metodo restituisce true se il parametro passato non è null e indica la stessa sequenza binaria di caratteri della stringa che chiama il metodo.

Durante il confronto dei valori ID, la lunghezza degli ID potrebbe non essere uguale. Ad esempio: se una stringa che rappresenta un ID di 15 caratteri viene confrontata con un oggetto che rappresenta un ID di 18 caratteri, questo metodo restituisce true. Per esempio:

Id idValue15 = '001D000000Ju1zH';
Id idValue18 = '001D000000Ju1zHIAR';
Boolean result4 = stringValue15.equals(IdValue18);
System.debug('result4', +result4); //true

Nell'esempio precedente il metodo equals confronta l'ID oggetto di 15 caratteri con l'ID oggetto di 18 caratteri e se entrambi questi ID rappresentano la stessa sequenza binaria restituirà true.

Utilizzare questo metodo per effettuare confronti con distinzione tra maiuscole e minuscole.

escapeSingleQuotes(stringToEscape)

Questo metodo aggiunge un carattere di escape (\) prima di ogni virgoletta singola in una stringa e lo restituisce. Questo metodo impedisce l'inserimento di SOQL durante la creazione di una query SOQL dinamica. Questo metodo garantisce che tutte le virgolette singole vengano considerate come stringhe che racchiudono, anziché comandi di database.

Per esempio:

String s = 'Hello Tom';
system.debug(s); // Outputs 'Hello Tom'
String escapedStr = String.escapeSingleQuotes(s);
// Outputs \'Hello Tom\'

rimuovi(sottostringa)

Questo metodo rimuove tutte le occorrenze della sottostringa menzionata dalla String che chiama il metodo e restituisce la stringa risultante.

Per esempio

String s1 = 'Salesforce and force.com';
String s2 = s1.remove('force');
System.debug( 's2'+ s2);// 'Sales and .com'

sottostringa(indiceiniziale)

Questo metodo restituisce una sottostringa che inizia dal carattere in startIndex e si estende fino all'ultimo della stringa.

Per esempio:

String s1 = 'hamburger';
String s2 = s1.substring(3);
System.debug('s2'+s2); //burger

inversione()

Questo metodo inverte tutti i caratteri di una stringa e la restituisce. Per esempio:

String s = 'Hello';
String s2 = s.reverse();
System.debug('s2::::'+s2);// olleH  // Hello

trim(): questo metodo rimuove tutti gli spazi bianchi iniziali da una stringa e la restituisce.

valoreOf(toConvert)

Questo metodo restituisce la rappresentazione della stringa dell'oggetto passato.

Limiti del governatore Apex

I limiti del governatore Apex sono i limiti imposti dal motore di runtime Apex per garantire che qualsiasi codice e processo Apex Runway non controlli le risorse condivise e non violi l'elaborazione per altri utenti nell'ambiente multitenant. Questi limiti vengono verificati rispetto a ogni transazione Apex. Di seguito sono riportati i limiti del governatore definiti da Salesforce su ogni transazione Apex:

Descrizione	Limitare
Query SOQL che possono essere eseguite in una transazione sincrona	100
Query SOQL che possono essere eseguite in una transazione asincrona	200
Record che possono essere recuperati da una query SOQL	50000
Record che possono essere recuperati da Database.getQueryLocator	10000
Query SOSL che possono essere eseguite in una transazione apex	20
Record che possono essere recuperati da una query SOSL	2000
Istruzioni DML che possono essere eseguite in una transazione apex	150
Record che possono essere elaborati come risultato di un'istruzione DML, Approval.process o database.emptyRecycleBin	10000
Callout che possono essere eseguiti in una transazione apex.	100
Limite di timeout cumulativo su tutti i callout eseguiti in una transazione apex	120 secondi
Limite sui processi apex che possono essere aggiunti alla coda con System.enqueueJob	50
Limite temporale di esecuzione per ciascuna transazione Apex	10 minuti
Limite sui caratteri che possono essere utilizzati in una classe apex e in un trigger	1 milioni
Limite di tempo della CPU per transazione sincrona	Millisecondi 10,000
Limite di tempo della CPU per transazione asincrona	Millisecondi 60,000

Getter e Setter Apex

La proprietà Apex è simile alla variabile apex. Getter e setter sono necessari per una proprietà apicale. Getter e setter possono essere utilizzati per eseguire codice prima che si acceda o si modifichi il valore della proprietà. Il codice nella funzione di accesso get viene eseguito quando viene letto il valore di una proprietà. Il codice nella funzione di accesso set viene eseguito quando viene modificato il valore di una proprietà. Qualsiasi proprietà che ha la funzione di accesso get è considerata di sola lettura, qualsiasi proprietà che ha la funzione di accesso set è considerata di sola scrittura, qualsiasi proprietà che ha sia la funzione di accesso get che set è considerata di lettura-scrittura. Sintassi di una proprietà apex:

public class myApexClass {
// Property declaration
	access_modifierreturn_typeproperty_name {
	get {
			//code  
		}
		set{
			//code
		}
	}

Qui access_modifier è il modificatore di accesso della proprietà. return_type è il dataType della proprietà. property_name è il nome della proprietà.

Di seguito è riportato un esempio di una proprietà apex con sia la funzione di accesso get che set.

public class myApex{
	public String name{
		get{ return name;}
		set{ name = 'Test';}
	}
}

Qui, il nome della proprietà è name, è una proprietà pubblica e restituisce una stringa dataType.

Non è obbligatorio avere del codice nel blocco get e set. Questi blocchi possono essere lasciati vuoti per definire una proprietà automatica. Per esempio:

public double MyReadWriteProp{ get; set; } 

Le funzioni di accesso get e set possono anche essere definite con il relativo modificatore di accesso. Se una funzione di accesso viene definita con un modificatore, sovrascrive il modificatore di accesso per la proprietà. Per esempio:

public String name{private get; set;}// name is private for read and public to write.

Classe Apex

Una classe apex è un progetto o un modello da cui vengono creati gli oggetti. Un oggetto è l'istanza di una classe.

Esistono tre modi per creare classi apex in Salesforce:

Console per gli sviluppatori

IDE Force.com

Pagina dei dettagli della classe Apex.

In apex è possibile definire una classe esterna denominata anche classe di livello superiore e inoltre è possibile definire classi all'interno di una classe esterna denominata classi interne.

È obbligatorio utilizzare il modificatore di accesso come global o public nella dichiarazione della classe esterna.

Non è necessario utilizzare il modificatore di accesso nella dichiarazione delle classi interne.

Una classe apex viene definita utilizzando la parola chiave class seguita dal nome della classe.

La parola chiave Extends viene utilizzata per estendere una classe esistente tramite una classe apex e la parola chiave Implements viene utilizzata per implementare un'interfaccia tramite una classe apex.

Salesforce Apex non supporta eredità multiple, una classe apex può estendere solo una classe apex esistente ma può implementare più interfacce.

Una classe apex può contenere un costruttore definito dall'utente e, se un costruttore definito dall'utente non è disponibile, viene utilizzato un costruttore predefinito. Il codice in un costruttore viene eseguito quando viene creata un'istanza di una classe.

Sintassi dell'esempio della classe Apex:

public class myApexClass{
// variable declaration
//constructor
	public myApexClass{
	}
//methods declaration
}

La nuova parola chiave viene utilizzata per creare un'istanza di una classe apex. Di seguito è riportata la sintassi per creare un'istanza di una classe apex.

myApexClass obj = new myApexClass();

Trigger dell'apice

I trigger Apex consentono di eseguire un apex personalizzato prima e dopo l'esecuzione di un'operazione DML.

Apex supporta i seguenti due tipi di trigger:

Prima dei trigger: questi trigger vengono utilizzati per convalidare e aggiornare il valore del campo prima del salvataggio del record nel database.

Dopo i trigger: questi trigger vengono utilizzati per accedere ai campi (ID record, campo LastModifiedDate) impostati dal sistema dopo il commit di un record nel database. Il valore di questi campi può essere utilizzato per modificare altri record. I record che vengono attivati ​​dopo i trigger sono di sola lettura.

È una procedura consigliata scrivere trigger voluminosi. Un trigger voluminoso può elaborare un singolo record così come più record alla volta.

Sintassi di un trigger apicale:

trigger TriggerName on ObjectName (trigger_events) {
	//Code_block
 }

Qui, TriggerName è il nome del trigger, ObjectName è il nome dell'oggetto su cui scrivere il trigger, trigger_events è l'elenco di eventi separati da virgole.

Di seguito sono riportati gli eventi supportati dai trigger Apex: prima dell'inserimento, prima dell'aggiornamento, prima dell'eliminazione, dopo l'inserimento, dopo un aggiornamento, dopo l'eliminazione, dopo l'annullamento dell'eliminazione.

Le parole chiave statiche non possono essere utilizzate in un trigger Apex. Tutte le parole chiave applicabili alle classi interne possono essere utilizzate in un trigger Apex.

Esistono variabili implicite definite da ogni trigger che restituisce il contesto di runtime. Queste variabili sono definite nel sistema. Classe di attivazione. Queste variabili sono chiamate variabili di contesto. Lo screenshot seguente mostra la variabile di contesto supportata dal trigger apex.

Di seguito sono riportate le considerazioni sulla variabile di contesto nel trigger Apex:

• Non utilizzare trigger.new e trigger.old nelle operazioni DML.
• Trigger.new non può essere eliminato.
• Trigger.new è di sola lettura.
• Trigger.new può essere utilizzato per modificare i valori dei campi sullo stesso oggetto solo prima del trigger.

Gli screenshot seguenti elencano le considerazioni su azioni specifiche in diversi eventi di attivazione.

Classe batch in Apex

La classe Batch in Salesforce viene utilizzata per elaborare un gran numero di record che supererebbero i limiti dell'apex governor se elaborati normalmente. La classe Batch esegue il codice in modo asincrono.

Di seguito sono riportati i vantaggi della classe batch:

• La classe batch elabora i dati in blocchi e se un blocco non viene elaborato correttamente, tutti i blocchi elaborati correttamente non vengono ripristinati.
• Ogni blocco di dati in una classe batch viene elaborato con un nuovo set di limiti del governatore che garantisce che il codice venga eseguito entro i limiti di esecuzione del governatore.
• Banca dati. L'interfaccia batch deve essere implementata da una classe apex da utilizzare come classe batch. Fornisce tre metodi che devono essere implementati dalla classe batch.

Di seguito sono riportati i tre metodi forniti dall'interfaccia Database. Batchable:

1.inizio()

Questo metodo genera l'ambito dei record o degli oggetti da elaborare tramite il metodo di interfaccia execute. Durante l'esecuzione del batch, viene chiamato una sola volta. Questo metodo restituisce un oggetto Database.QueryLocator o un Iterable. Il numero di record recuperati dalla query SQL tramite l'oggetto Database.QueryLocator è di 50 milioni di record, ma utilizzando un iterable, il numero totale di record che possono essere recuperati dalla query SQL è di soli 50000. Iterable viene utilizzato per generare un ambito complesso per la classe batch.

Sintassi del metodo start:

global (Database.QueryLocator | Iterable<sObject>) start(Database.BatchableContextbc) {}

2.esegui()

Questo metodo viene utilizzato per l'elaborazione di ciascun blocco di dati. Per ogni blocco di record viene chiamato il metodo di esecuzione. La dimensione batch predefinita per l'esecuzione è 200 record. Il metodo Execute accetta due argomenti:

Un riferimento all'oggetto Database.BatchableContext,

Un elenco di oggetti, ad esempio List o un elenco di tipi con parametri. Sintassi del metodo di esecuzione:

global void execute(Database.BatchableContext BC, list<P>){}

3.finitura()

Il metodo finish viene chiamato una volta durante l'esecuzione della classe batch. Le operazioni di post-elaborazione possono essere eseguite nel metodo finish. Ad esempio: inviare l'e-mail di conferma. Questo metodo viene chiamato quando tutto il batch viene elaborato. Sintassi del metodo Finish:

global void finish(Database.BatchableContext BC){}

Oggetto Database.BatchableContext

Ciascun metodo del database. L'interfaccia batchable ha un riferimento all'oggetto Database.BatchableContext.

Questo oggetto viene utilizzato per tenere traccia dell'avanzamento del lavoro batch.

Di seguito sono riportati i metodi di istanza forniti da BatchableContext:

• getChildJobId(): questo metodo restituisce l'ID di un lavoro batch attualmente elaborato.

• getJobId(): questo metodo restituisce l'ID del lavoro batch.

Di seguito è riportata la sintassi di una classe batch:

global class MyBatchClass implements Database.Batchable<sObject> {
	global (Database.QueryLocator | Iterable<sObject>) start(Database.BatchableContextbc) {
// collect the batches of records or objects to be passed to execute
}
global void execute(Database.BatchableContextbc, List<P> records){
// process each batch of records
}
global void finish(Database.BatchableContextbc){
// execute any post-processing operations
}
}

Metodo Database.executeBatch

Il metodo Database.executeBatch viene utilizzato per eseguire una classe batch.

Questo metodo accetta due parametri: istanza della classe batch da elaborare, parametro Opzioni per specificare la dimensione del batch, se non specificato accetta la dimensione predefinita di 200.

Sintassi di Database.executeBatch:

Database.executeBatch(myBatchObject,scope)

Esecuzione di un nome di classe batch MyBatchClass:

MyBatchClassmyBatchObject = new MyBatchClass(); 
Id batchId = Database.executeBatch(myBatchObject,100);

Database.stateful

La classe batch è senza stato per impostazione predefinita. Ogni volta che viene chiamato il metodo di esecuzione viene ricevuta una nuova copia di un oggetto, tutte le variabili della classe vengono inizializzate.

Database.stateful è implementato per rendere una classe batch con stato.

Se la tua classe batch ha implementato il file Banca Dati , interfaccia con stato, tutte le variabili di istanza mantengono i propri valori, ma le variabili statiche vengono reimpostate tra una transazione e l'altra.

Sintesi

• Apex è un programma fortemente tipizzato, orientato agli oggetti linguaggio di programmazione che viene compilato ed eseguito sulla piattaforma force.com
• Il linguaggio di programmazione Apex non fa distinzione tra maiuscole e minuscole
• Due tipi di flusso di azioni in Apex sono 1) Azione dello sviluppatore 2) Azione dell'utente finale
• Apex ti aiuta a creare servizi web che integrano Salesforce con altre applicazioni.
• I tipi di dati supportati da apex sono: 1).Primitive 2) Collezioni 3) sObject, Enum, 4) Classi, 5) Oggetti e interfacce
• Pubblico, Privato, Protetto e Globale sono i supporti specificati da Apex
• Le parole chiave utilizzate in Apex sono: 1) Con condivisione, 2) Senza condivisione, 3) Statico, 4) Finale 5) Ritorno, 6) Nullo, 7) Virtuale, 8) Astratto
• Una stringa è un insieme di caratteri senza limiti di caratteri
• I limiti del regolatore Apex sono i limiti applicati dal motore di runtime Apex per garantire che qualsiasi codice e processo Apex della pista
• Getter e setter possono essere utilizzati per eseguire codice prima che si acceda o si modifichi il valore della proprietà
• Esistono tre modi per creare classi apex in Salesforce: 1) Console per sviluppatori 2) IDE Force.com e 3) Pagina dei dettagli della classe Apex.
• I trigger Apex consentono di eseguire un apex personalizzato prima e dopo l'esecuzione di un'operazione DML.
• La classe batch in Salesforce viene utilizzata per elaborare un numero elevato di record che supererebbero i limiti dell'apex governatore se elaborati normalmente.