with sharing, without sharing, and inherited sharing

Module 20's closing lesson left an open question: whether a plain SOQL query enforces the running user's record-level access depends on the sharing mode of the class it runs in — this module explains exactly what that means. Sharing refers to Salesforce's record-level access model — role hierarchies, sharing rules, manual sharing — that determines which specific records a given user is allowed to see, on top of their object- and field-level permissions.

public with sharing class OpportunityService {
    public List<Opportunity> getMyTeamOpportunities() {
        return [SELECT Id, Name, Amount FROM Opportunity]; // only records this user can see
    }
}

1. public with sharing class OpportunityService { — with sharing means the class's queries and DML respect the running user's actual sharing access.
2. public List<Opportunity> getMyTeamOpportunities() { — the method.
3. return [SELECT Id, Name, Amount FROM Opportunity]; — a sales rep calling this only ever sees Opportunities they're actually allowed to see, exactly as if they'd run the query themselves through the UI.
4. } — closes the method.
5. } — closes the class.

public without sharing class OrgWideReportingService {
    public Integer getTotalOpportunityCount() {
        return [SELECT COUNT() FROM Opportunity]; // every Opportunity, regardless of who's asking
    }
}

1. public without sharing class OrgWideReportingService { — without sharing deliberately bypasses record-level sharing.
2. public Integer getTotalOpportunityCount() { — the method.
3. return [SELECT COUNT() FROM Opportunity]; — every query and DML statement in this class sees the entire object's data, not just what the running user could normally access.
4. } — closes the method.
5. } — closes the class.

This is a real, sometimes-necessary tool (an org-wide dashboard, a system integration), but one that needs a genuinely deliberate reason, not a default choice.

public inherited sharing class DateFormatterUtil {
    public String formatFriendly(Date d) {
        return d.format(); // doesn't touch sharing at all, but declares intent clearly
    }
}

1. public inherited sharing class DateFormatterUtil { — inherited sharing means: behave with sharing when called directly, but inherit whatever sharing mode the calling class was already running under when called from somewhere else.
2. public String formatFriendly(Date d) { — the method.
3. return d.format(); — doesn't touch sharing at all, but declares intent clearly.
4. } — closes the method.
5. } — closes the class.

For a reusable utility class that might get called from both with sharing and without sharing contexts, this is generally the safest, most predictable default.