Apex basics

Apex is Salesforce's programming language. It runs on Salesforce's servers, looks like Java, and is built to work with your org's data: querying records, inserting and updating them, and reacting to changes. If you know Java, C# or even Python, you will pick it up quickly.

In this tutorial you will run Apex in the Developer Console, learn types, collections, loops and classes, change data with DML, handle errors, and write a small reusable service class.

Prerequisites: a Developer Edition org, and having read *SOQL and SOSL* (you will use queries inside Apex).

String shop = 'Brew & Bean';
Integer cups = 3;
Decimal price = 180.50;
Boolean open = true;
System.debug(shop + ' sold ' + cups + ' cups, total ' + (cups * price));
System.debug('Open now? ' + open);

The log shows: Brew & Bean sold 3 cups, total 541.50 and Open now? true.

Apex is strongly typed: every variable has a declared type, and each statement ends with a semicolon. Names are not case sensitive (Shop and shop are the same), but keep one style anyway.

Apex has three collection types, all generic:

List is an ordered list that allows duplicates, read by position. Set has no duplicates and no order. Map stores key and value pairs. Sets and maps of Ids are everywhere in Apex, because they let you look things up without extra queries.

List<String> drinks = new List<String>{'Espresso', 'Cold Brew'};
drinks.add('Filter Coffee');
System.debug(drinks[0] + ', size ' + drinks.size());

Set<String> cities = new Set<String>{'Bengaluru', 'Pune', 'Bengaluru'};
System.debug(cities.size()); // 2, the duplicate is dropped

Map<String, Decimal> menu = new Map<String, Decimal>{
    'Espresso' => 120, 'Masala Chai' => 90
};
menu.put('Cappuccino', 180);
System.debug(menu.get('Espresso')); // 120
System.debug(menu.containsKey('Latte')); // false

Prints Espresso, size 3, then 2, then 120, then false.

Integer total = 0;
for (Integer i = 1; i <= 5; i++) {
    total += i;
}
System.debug('Sum: ' + total); // 15

List<Integer> orders = new List<Integer>{120, 540, 90};
for (Integer amount : orders) {
    if (amount >= 500) {
        System.debug(amount + ' is a big order');
    } else if (amount >= 100) {
        System.debug(amount + ' is a normal order');
    } else {
        System.debug(amount + ' is a small order');
    }
}

Prints Sum: 15, then 120 normal, 540 big, 90 small. The second loop style, for (type item : collection), is the one you will use most.

Records are objects too. Set fields with the constructor or with dot notation, then save with a DML statement. DML (Data Manipulation Language) statements are insert, update, delete, upsert and undelete. After an insert, Salesforce fills in the record's Id.

Account acc = new Account(Name = 'Brew & Bean Cafe', Industry = 'Technology');
insert acc;
System.debug('New Id: ' + acc.Id);

Contact c = new Contact(FirstName = 'Asha', LastName = 'Rao', AccountId = acc.Id);
insert c;

acc.Phone = '080-5550100';
update acc;

Account saved = [SELECT Id, Name, Phone FROM Account WHERE Id = :acc.Id];
System.debug(saved.Name + ' / ' + saved.Phone);

delete c;

Creates an Account and a Contact, updates the Account's phone, reads it back with SOQL, then deletes the Contact. Check Accounts in the org afterwards: the Account is still there.

List<Contact> newContacts = new List<Contact>();
for (Integer i = 1; i <= 5; i++) {
    newContacts.add(new Contact(LastName = 'Tester ' + i));
}
insert newContacts; // one DML statement, five records

Five Contacts are created with a single insert. Delete them later with a SOQL query on LastName LIKE 'Tester%' followed by delete.

A normal DML statement is all or nothing: if any record fails (for example a required field is missing), it throws a DmlException and the whole statement is undone. Catch it to show a helpful message. If you want the good records saved and the bad ones reported, use the Database methods with allOrNone set to false.

List<Account> accts = new List<Account>{
    new Account(Name = 'Good Cafe'),
    new Account() // Name is required, so this one fails
};

try {
    insert accts;
} catch (DmlException e) {
    System.debug('Insert failed: ' + e.getMessage());
}

Database.SaveResult[] results = Database.insert(accts, false);
for (Database.SaveResult sr : results) {
    if (sr.isSuccess()) {
        System.debug('Saved ' + sr.getId());
    } else {
        System.debug('Error: ' + sr.getErrors()[0].getMessage());
    }
}

The first insert fails as a whole and prints the error. The Database.insert call saves Good Cafe and reports a required-field error for the second record.

Real Apex lives in classes, saved in your org and called from triggers, components or other classes. A class has fields, methods and access modifiers: public (visible across the org) or private (only inside the class). static methods belong to the class and are called without creating an object, which suits helper code.

To create one: in the Developer Console choose File > New > Apex Class, name it AccountService, paste the code and press Ctrl+S to save.

public with sharing class AccountService {

    // Create an account and a first contact in one go
    public static Account createWithContact(String accountName, String lastName) {
        Account acc = new Account(Name = accountName);
        insert acc;
        insert new Contact(LastName = lastName, AccountId = acc.Id);
        return acc;
    }

    // Return the accounts in an industry, biggest revenue first
    public static List<Account> findByIndustry(String industry) {
        return [
            SELECT Id, Name, AnnualRevenue
            FROM Account
            WHERE Industry = :industry
            ORDER BY AnnualRevenue DESC NULLS LAST
            LIMIT 50
        ];
    }

    // Number of contacts for each account Id
    public static Map<Id, Integer> countContacts(Set<Id> accountIds) {
        Map<Id, Integer> counts = new Map<Id, Integer>();
        for (Id accId : accountIds) {
            counts.put(accId, 0);
        }
        for (AggregateResult ar : [
            SELECT AccountId acc, COUNT(Id) total
            FROM Contact
            WHERE AccountId IN :accountIds
            GROUP BY AccountId
        ]) {
            counts.put((Id) ar.get('acc'), (Integer) ar.get('total'));
        }
        return counts;
    }
}

A service class with three static methods: one DML example, one query, one aggregate. The keyword 'with sharing' makes the class respect the user's record sharing.

Account a = AccountService.createWithContact('Lakeview Foods', 'Menon');
System.debug('Created ' + a.Id);

Map<Id, Integer> counts = AccountService.countContacts(new Set<Id>{a.Id});
System.debug(counts.get(a.Id) + ' contact(s)');

Prints the new Account Id, then 1 contact(s).

with sharing makes the class obey record sharing rules for the running user. without sharing ignores them. inherited sharing uses the caller's mode. Beginners should default to with sharing. Note that field-level security is a separate matter: use WITH USER_MODE in queries or Security.stripInaccessible when it matters.

Debugging tip. Use System.debug() and read the log, or set up a trace flag from Debug > Change Log Levels. Most Apex errors say what and where. Read the message, then the line number.

You are a senior Salesforce developer teaching a fresher. Explain this Apex code line by line in plain English, point out anything that could hit a governor limit or fail on 200 records, and suggest improvements.

[paste Apex]

What to expect: A good answer explains each statement, flags SOQL or DML inside loops, and suggests collections and bulk-safe patterns. Always run the improved code yourself.

How this comes up in interviews. Expect: the difference between List, Set and Map; what DML is and how many statements are allowed; with sharing versus without sharing; how to handle partial success with Database.insert(list, false); what an sObject is; and why static methods are used for helpers.