Apex #1 Variables and Data Types

Understanding Variables

In programming, variables act as containers that hold data or values. They allow you to store and manipulate information, making your code dynamic and adaptable. In Apex, you declare variables using the following syntax:

// Syntax: data_type variable_name = value; 

Integer myNumber = 42; 
String myText = 'Hello, Salesforce!'; 
Date today = Date.today();

Let's dive into the key aspects of variables in Apex:

1. Data Type

Every variable in Apex has a specific data type, which defines the kind of data it can hold. Common data types include:

• Integer: Stores whole numbers (e.g., 42, -10).

  • Integer myNumber = 42;

• String: Holds text or characters (e.g., 'Salesforce' or 'Apex').

  • String myText = 'Hello, Salesforce!';

• Date: Represents a date without a time component (e.g., 2023-09-27).

  • Date today = Date.today();

• Boolean: Stores true or false values.

  • Boolean isTrue = true;

• Decimal: Holds numbers with decimal points (e.g., 3.14).

  • Decimal piValue = 3.14;

• List: Stores a collection of values of the same data type.

  • List<Integer> numbersList = new List<Integer>{1, 2, 3, 4, 5};

• Map: Stores key-value pairs, allowing you to associate values with unique keys.

  • Map<String, Integer> nameToAge = new Map<String, Integer>{

    'Alice' => 30,

    'Bob' => 28,

    'Carol' => 35

    };

2. Variable Name

Variable names in Apex should be meaningful and follow certain conventions. Avoid using reserved words, and keep names concise and descriptive for better code readability.

3. Value Assignment

Variables can be assigned values during declaration or later in your code. You can change the value of a variable as needed. For example:

Integer myVariable = 10; // Variable initialization 
myVariable = 20; // Variable value change

4. Scope

Variables have different scopes, determining where they can be accessed within your code. Apex offers three main scopes:

• Local: Variables declared within a method or block of code are local and can only be used within that method or block.

  public class ScopeExample {
      public void myMethod() {
          // This is a local variable within the method.
          Integer localVar = 42;
          System.debug('Local variable: ' + localVar);
      }
  }
  
  In this example, localVar is a local variable declared within the myMethod method. It can only be accessed within that method.

• Class: Class-level variables, also known as member variables, are declared within a class and can be accessed by any method within the class.

  public class ScopeExample {
      // This is a class-level variable.
      Integer classVar = 100;
  
      public void myMethod() {
          System.debug('Class-level variable: ' + classVar);
      }
  }
  
  In this example, classVar is a class-level variable, and it can be accessed both within the myMethod method and any other method within the ScopeExample class.

• Global (static): Static variables belong to a class rather than an instance of the class and can be accessed using the class name. They are shared among all instances of the class.

  public class ScopeExample {
      // This is a static variable.
      public static Integer staticVar = 500;
  
      public void myMethod() {
          System.debug('Static variable: ' + ScopeExample.staticVar);
      }
  }
  
  In this example, staticVar is a static variable, and it can be accessed using the class name ScopeExample. It is shared among all instances of the ScopeExample class.

Conclusion

Variables and data types are fundamental concepts in Apex programming. By understanding how to declare and use variables and selecting the appropriate data types, you can build robust and efficient Salesforce applications. As you continue your Salesforce development journey, keep exploring these concepts to harness the full power of Apex.

Stay tuned for more in-depth guides on Apex programming, where we'll delve into advanced topics such as classes, Objects etc. Happy coding, Salesforce developers!