Apex Variable Declaration & Data Types: Complete Guide | SalesforceTutorial

Apex variables form the foundation of Salesforce development. This guide covers variable declaration syntax, data type specifications, naming conventions, and practical implementation patterns used in production Salesforce orgs.

What is Apex Variable Declaration?

Apex is a strongly typed language, requiring all variables to be declared with explicit data types before use. Variable declaration follows the pattern: DataType variableName;

Example: Integer i; (Integer = Data Type, i = variable name)

Variable Declaration Syntax

// Basic variable declaration
String accountName;
Integer recordCount;
Boolean isActive;

// Declaration with initialization
String companyName = 'Salesforce';
Integer maxRecords = 50000;
Date todayDate = Date.today();

Apex Variable Naming Rules and Best Practices

Salesforce enforces specific naming conventions for Apex variables:

• Variable names cannot start with numeric values or symbols
• Avoid underscore (_) prefixes or suffixes
• Cannot use Apex reserved words (class, public, static, etc.)
• Case-insensitive but follow camelCase convention
• Use descriptive names that indicate purpose

Valid and Invalid Variable Names

// Valid variable names
String firstName;
Integer accountCount;
List<Contact> activeContacts;
Map<Id, Account> accountMap;

// Invalid variable names
// String 1stName;        // starts with number
// Integer _count;        // starts with underscore
// Boolean class;         // reserved word
// String account-name;   // contains hyphen

Complete Apex Data Types Reference

Apex supports primitive data types, collections, and sObject types. Each data type has specific memory allocation and governor limit implications.

Primitive Data Types with Examples

String Data Type

// String declaration and manipulation
String accountName = 'Acme Corporation';
String description = null; // Strings can be null
String multiLine = 'Line 1\n' + 'Line 2';

// String methods
Integer nameLength = accountName.length();
String upperName = accountName.toUpperCase();
Boolean containsAcme = accountName.contains('Acme');

Numeric Data Types

// Integer for whole numbers
Integer recordCount = 1000;
Integer negativeValue = -500;

// Long for larger whole numbers
Long bigNumber = 9223372036854775807L;

// Decimal for precise calculations
Decimal price = 99.99;
Decimal taxRate = 0.0875;
Decimal totalPrice = price * (1 + taxRate);

// Double for floating point
Double percentage = 85.5;
Double scientificNotation = 1.23e-4;

Date and Time Data Types

// Date operations
Date today = Date.today();
Date futureDate = today.addDays(30);
Date specificDate = Date.newInstance(2024, 12, 25);

// DateTime with timezone handling
DateTime now = DateTime.now();
DateTime utcTime = DateTime.newInstanceGmt(2024, 1, 1, 12, 0, 0);
String formattedDateTime = now.format('yyyy-MM-dd HH:mm:ss');

// Time for time-only values
Time businessHours = Time.newInstance(9, 0, 0, 0); // 9:00 AM

Collection Data Types

Lists (Arrays)

// List declaration and initialization
List<String> cityNames = new List<String>();
List<Integer> numbers = new List<Integer>{1, 2, 3, 4, 5};
List<Account> accounts = [SELECT Id, Name FROM Account LIMIT 10];

// List operations
cityNames.add('San Francisco');
cityNames.add('New York');
Integer listSize = cityNames.size();
String firstCity = cityNames.get(0);

Sets for Unique Values

// Set declaration
Set<String> uniqueIndustries = new Set<String>();
Set<Id> accountIds = new Set<Id>();

// Adding values (duplicates ignored)
uniqueIndustries.add('Technology');
uniqueIndustries.add('Healthcare');
uniqueIndustries.add('Technology'); // Duplicate ignored

Boolean containsTech = uniqueIndustries.contains('Technology');

Maps for Key-Value Pairs

// Map declaration
Map<String, String> stateAbbreviations = new Map<String, String>();
Map<Id, Account> accountMap = new Map<Id, Account>();

// Map operations
stateAbbreviations.put('California', 'CA');
stateAbbreviations.put('New York', 'NY');
String caAbbrev = stateAbbreviations.get('California');
Set<String> allStates = stateAbbreviations.keySet();

SObject Data Types

// sObject variable declaration
Account acc = new Account();
Contact con = new Contact();
Opportunity opp = [SELECT Id, Name FROM Opportunity LIMIT 1];

// Generic sObject
sObject genericRecord = new Account();
Account specificAccount = (Account)genericRecord; // Type casting

// Working with sObject fields
acc.Name = 'New Account';
acc.Industry = 'Technology';
acc.AnnualRevenue = 1000000;

Type Casting and Conversion

// Implicit casting (safe)
Integer intValue = 100;
Long longValue = intValue; // Integer to Long
Double doubleValue = intValue; // Integer to Double

// Explicit casting (potential data loss)
Double preciseValue = 99.99;
Integer roundedValue = (Integer)preciseValue; // Results in 99

// String conversions
String numberAsString = String.valueOf(intValue);
Integer stringAsNumber = Integer.valueOf('123');

// sObject casting
sObject genericObj = new Account();
Account specificAcc = (Account)genericObj;

Variable Scope and Lifetime

Local Variables

public void processAccounts() {
    // Local variables - scope limited to method
    Integer processedCount = 0;
    List<Account> accountsToUpdate = new List<Account>();
    
    for (Account acc : [SELECT Id, Name FROM Account]) {
        // Loop variable scope
        String accountName = acc.Name;
        if (accountName != null) {
            processedCount++;
        }
    }
    // accountName not accessible here
}

Instance Variables

public class AccountProcessor {
    // Instance variables - accessible throughout class
    private Integer maxRecords = 10000;
    private String processingStatus;
    
    public void setMaxRecords(Integer max) {
        this.maxRecords = max; // 'this' refers to instance
    }
}

Governor Limits and Memory Considerations

Variable declaration impacts Salesforce governor limits:

• Heap Size Limit: 6MB synchronous, 12MB asynchronous
• Collection Limits: Lists and Maps consume memory based on size
• String Limits: Large strings impact heap usage
• sObject Limits: Each sObject instance uses memory

// Memory-efficient practices
// Use specific data types
Integer count = 100; // 4 bytes
// Instead of
// String count = '100'; // Variable bytes

// Clear large collections when done
List<Account> largeList = new List<Account>();
// ... process data
largeList.clear(); // Free memory

Common Variable Declaration Patterns

Null Safety Patterns

// Safe null checking
String accountName = acc.Name;
if (String.isNotBlank(accountName)) {
    // Process non-null, non-empty string
}

// Null coalescing pattern
String displayName = String.isBlank(acc.Name) ? 'Unknown' : acc.Name;

// Collection null safety
List<Contact> contacts = acc.Contacts;
if (contacts != null && !contacts.isEmpty()) {
    // Process contacts
}

Constants Declaration

// Class-level constants
public class Constants {
    public static final String DEFAULT_INDUSTRY = 'Technology';
    public static final Integer MAX_RECORDS = 50000;
    public static final Decimal TAX_RATE = 0.0875;
}

Best Practices for Variable Declaration

1. Use descriptive names: accountCount instead of count
2. Initialize when possible: Avoid null pointer exceptions
3. Choose appropriate data types: Use Integer for counts, Decimal for currency
4. Follow naming conventions: camelCase for variables, PascalCase for classes
5. Minimize scope: Declare variables in the smallest scope needed
6. Use final for constants: final String CONSTANT_VALUE = 'value';

Frequently Asked Questions