Anatomy of an Apex Class
An Apex class is a template that defines properties (fields) and behavior (methods). A class declaration consists of an access modifier, the class keyword, a name in PascalCase, and a body enclosed in curly braces. Once a class exists, you create individual objects, or instances, of it using the new keyword, each with its own independent state.
Cricket analogy: Like a coaching manual template defining every player's role and drills, from which each actual player, an instance, follows the same blueprint but ends up with their own individual stats.
Writing a Simple Class with Methods
A method has a return type (or void if it returns nothing), a name, a parameter list in parentheses, and a body. Instance methods operate on a specific object's data and are called through an instance, while static methods belong to the class itself and are called directly on the class name without ever creating an instance.
Cricket analogy: An instance method is like a specific player's individual technique, say Kohli's cover drive, callable only through him, while a static method is like a universal law of cricket such as the LBW rule that applies without needing any specific player.
Access Modifiers and Static vs Instance
Access modifiers such as public, private, protected, and global control visibility; private is the implicit default if none is specified for a class member. Static members belong to the class itself and are shared across every instance, while instance members belong separately to each individual object created from the class.
Cricket analogy: Private is like a team's internal training drills hidden from opponents, while public is like the published team sheet everyone can see; a static counter is like a tournament's shared total-runs tally across all matches, while an instance field is like each individual match's own scorecard.
Testing Your Class
Apex requires dedicated test classes, annotated with @isTest, and Salesforce enforces a minimum of 75% code coverage org-wide before Apex can be deployed to a production org. Test methods typically wrap the code under test in Test.startTest()/Test.stopTest(), which resets governor limits and forces asynchronous work to finish, then use System.assertEquals() to verify the actual outcome matches what was expected.
Cricket analogy: Like a player needing to pass a fitness test, the equivalent of asserting expected conditions, before being cleared to play in an official match, with a minimum fitness threshold required by the board just as 75% coverage is required by the platform.
public class GreetingService {
public static String getGreeting(String name) {
if (name == null) {
return 'Hello, Guest!';
}
return 'Hello, ' + name + '!';
}
}
@isTest
private class GreetingServiceTest {
@isTest
static void testGetGreetingWithName() {
Test.startTest();
String result = GreetingService.getGreeting('Trailblazer');
Test.stopTest();
System.assertEquals('Hello, Trailblazer!', result, 'Greeting should include the name');
}
}Salesforce requires at least 75% overall code coverage org-wide, with every trigger having some coverage, before Apex metadata can be deployed to a production org - though aiming for meaningful assertions, not just hitting the number, is the real goal.
Tests that only call a method without any System.assert statements provide code coverage but no real verification. A class can reach 100% coverage and still contain bugs if the tests never actually check the output values.
- An Apex class is declared with an access modifier, the class keyword, a PascalCase name, and a body in braces.
- Instances are created using the new keyword; instance methods operate on that specific instance's state.
- Static methods and variables belong to the class itself and are shared across all instances.
- Access modifiers (private, public, protected, global) control visibility; private is the default for class members.
- Test classes are annotated with @isTest and are required for deployment validation.
- Test.startTest()/Test.stopTest() reset governor limits and force async operations to complete within the test.
- A minimum of 75% code coverage (org-wide) is required before deploying Apex to production.
Practice what you learned
1. What keyword creates a new instance of an Apex class?
2. What is the default access modifier for a class member if none is specified?
3. What distinguishes a static method from an instance method?
4. What annotation marks a class as a test class in Apex?
5. What is the minimum code coverage percentage required to deploy Apex to production?
Was this page helpful?
You May Also Like
Apex Syntax and Variables
Covers the foundational rules of Apex syntax, how to declare and scope variables, naming conventions, and how comments structure readable code.
Apex Data Types
An overview of Apex's primitive types, collection types (List, Set, Map), sObjects and IDs, and the rules governing type conversion and null handling.
The Apex Development Environment
A tour of the tools used to write, test, and deploy Apex code, from VS Code and Salesforce CLI to Developer Console, sandboxes, and scratch orgs.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics