Given a scenario, follow best practices to write Apex classes and triggers.

// class with multiple constructors
public class ClassName {
    // constructor with no arguments
    public ClassName() { /* code block 1 */ }
    
    // constructor with a single argument
    public ClassName(Integer i) { /* code block 2 */ }
    
    // constructor with multiple arguments
    public ClassName(Integer j, String str) { /* code block 3 */ }}

// Object instantiation using different constructors
ClassName object1 = newClassName();
ClassName object2 = newClassName(1);
ClassName object3 = newClassName(2, 'Martin');

public class AnOuterClass {
    // outer class code here
    class AnInnerClass {
        // inner class code here       
        /* class AnotherInnerClass {     // this code will cause an error  } */   
    }
}

global class Person {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
}

// ignores the sharing model of the running user and 
// will be able to access all data
public without sharing class IgnoreSharingSettings {}

// respects the sharing model and can only access 
// the data that the current user is allowed to access
public with sharing class RespectSharingSettings {}

// uses the sharing model of the caller class
public inherited sharing class CallerSharingSettings {}

public with sharing class myOuterClass {
    // myOuterClass code here   
    without sharing class myInnerClass {
        // my InnerClass code here
    }
}

public class WeatherClass {
    public static String weather = 'cloudy';
    public static void isSunny() {
        weather = 'sunny';
        System.debug('The weather today is ' + weather);
        }
    }
    System.debug(WeatherClass.weather); // prints 'cloudy'
    WeatherClass.isSunny(); // prints 'The weather today is sunny'

trigger ContactTrigger on Contact (before insert) {
    for (Contact con: Trigger.new) {
        System.debug('Inserting new contact: ' + con.Name);
        //...
    }
}

// using isBefore and isUpdate
if (trigger.isBefore && trigger.isUpdate) {
    // Before Update logic here
}
// using operationType
switch on trigger.operationType {
    when BEFORE_UPDATE {
        // Before Update logic here
    }
}

trigger AccountTrigger on Account (before update) {
    for (Account newAccount: Trigger.new){
        // The below will return the old version of the record.
        // This is usually done to compare new and old field values
        Account oldAccount = Trigger.oldMap.get(newAccount.Id);
    }
}

trigger ContactTrigger on Contact (before insert, before update) {
    ContactHandler handler = newContactHandler();
    if (Trigger.isBefore) {
        if (Trigger.isInsert) {
            handler.handleBeforeInsert(Trigger.new);
        } elseif (Trigger.isUpdate) {
            // perform before update logic here...
        }
    }
}

public class ContactHandler {
    public void handleBeforeInsert(List<Contact> contacts) {
        if (Trigger.isExecuting) {
            // The method is called from an Apex trigger invocation.
            // So, perform specific logic for this context...
        }
        
        if (System.isBatch()) {
            // The method is called in a Batch Apex transaction.
            // So, perform specific logic for this context...
        }
    }
    // ...
}

trigger InquiryTrigger on Inquiry__c (before insert) {
    Map<String, RecordType> invRecTypeMap = newMap<String, RecordType>();
    for (RecordType recType: [SELECT Id, DeveloperName 
                                FROM RecordType
                               WHERE SObjectType = 'Inquiry__c']) {
        invRecTypeMap.put(recType.Name, recType);
    }
    
    for (Inquiry__c inquiry: Trigger.new) {
        if (invRecTypeMap.containsKey(inquiry.Industry__c)) {
            inquiry.RecordTypeId = invRecTypeMap.get(inquiry.Industry__c).Id;
        }
    }
}

trigger RequestTrigger on Request__c (before update) {
    for (Request__c newRequest: Trigger.new) {
        Request__c oldRequest = Trigger.oldMap.get(newRequest.Id);
        if (newRequest.Status__c != oldRequest.Status__c) {
            // change Owner based on the Status__c field
            // newRequest.Owner = userId;
        }
    }
}

trigger OpportunityTrigger on Opportunity (after update) {
    for (Opportunity opp: Trigger.new) {
        opp.Description = 'automated description';
    }
    update opp;
}

trigger ContactTrigger on Contact (before delete) {
    for (Contact con: Trigger.old) {
        if (con.AccountId == null) {
            con.addError('Unable to delete a Contact with no Account!');
        }
    }
}

trigger ContactTrigger on Contact (before update, after update, before delete, after delete) {
    List<Id> accountIds = newList<Id>();
    if (Trigger.isAfter && Trigger.isDelete) {
        // get all acount Ids to be updated
        for (Contact c : Trigger.Old) {
            if (c.Is_Primary_Contact__c == true) {
                accountIds.add(c.AccountId);
            }
        }
        // query and updated all accounts
        if (accountIds.isEmpty() == false) {
            List<Account> accounts = newList<Account>();
            for (Account a : [SELECT Id, Has_Primary_Contact__c 
                                FROM Account 
                               WHERE Id IN :accountIds]) {
                a.Has_Primary_Contact__c = false;
                accounts.add(a);
            }
            update accounts;
        }
    }
}

trigger AccountTrigger on Account (before insert, after insert, 
                                   before update, after update, 
                                   before delete, after delete, 
                                   after undelete) {
    if (trigger.isBefore) {
        if (trigger.isInsert) AccountTriggerHandler.onBeforeInsert(trigger.new);
        if (trigger.isUpdate) AccountTriggerHandler.onBeforeUpdate(trigger.old,
                                                                   trigger.oldMap, 
                                                                   trigger.new, 
                                                                   trigger.newMap);
        if (trigger.isDelete) AccountTriggerHandler.onBeforeDelete(trigger.old, 
                                                                   trigger.oldMap);
    }
    
    if (trigger.isAfter) {
        if (trigger.isInsert) AccountTriggereandler.onAfterInsert(trigger.new, 
                                                                  trigger.newMap);
        if (trigger.isUpdate) AccountTriggerHandler.onAfterUpdate(trigger.old, 
                                                                  trigger.oldMap, 
                                                                  trigger.new, 
                                                                  trigger.newMap);
        if (trigger.isDelete) AccountTriggerHandler.onAfterDelete(trigger.old, 
                                                                  trigger.oldMap);
        if (trigger.isUndelete) AccountTriggerHandler.onAfterDelete(trigger.new, 
                                                                    trigger.newMap);
    }
}

trigger Opportunitytrigger on Opportunity (before insert, after insert, 
                                           before update, after update, 
                                           before delete, after delete) {
    OpportunityTriggerHandler oppHandler = newOpportunityTriggerHandler();
    
    if (trigger.isBefore){
        if (trigger.isInsert){
            oppHandler.beforeInsert(trigger.New);
        } else if (trigger.isUpdate){
            oppHandler.beforeUpdate(trigger.New, trigger.Old);
        } else if (trigger.isDelete){
            oppHandler.beforeDelete(trigger.Old);
        }
    } elseif (trigger.isAfter){
        if(trigger.isInsert){
            oppHandler.afterInsert(trigger.New);
        } elseif (trigger.isUpdate){
            oppHandler.afterUpdate(trigger.New, trigger.Old);
        } elseif (trigger.isDelete){
            oppHandler.afterDelete(trigger.Old);
        }
    }
}

public class OpportunityTriggerHandler {
    public void beforeInsert(List<SObject> so) { // before insert logic here
        List<Opportunity> opp = (List<Opportunity>) so;
    }
    public void beforeUpdate(List<SObject> so, List<SObject> oldSo){ // before update logic here
        List<Opportunity> opp = (List<Opportunity>) so;
        List<opportunity> oppOld = (List<Opportunity>) oldSo;
    }
    public void beforeDelete(List<SObject> oldSo){ // before delete logic here
        List<Opportunity> oppOld = (List<Opportunity>) oldSo;
    } 
    public void afterInsert(List<SObject> so){ // after insert logic here
        List<Opportunity> opp = (List<Opportunity>) so;
    }
    public void afterUpdate(List<SObject> so, List<SObject> oldSo){ // after update logic here
        List<Opportunity> opp = (List<Opportunity>) so;
        List<opportunity> oppOld = (List<Opportunity>) oldSo;
    }
    public void afterDelete(List<SObject> oldSo){ // after delete logic here
        List<Opportunity> oppOld = (List<Opportunity>) oldSo;
    }
}

trigger OwnerDesignation on Account (before insert, before update) {
    // A set is used here to create unique ownerIds.
    Set<Id> ownerIds = newSet<Id>();
    for (Account a : Trigger.new) {
        ownerIds.add(a.OwnerId);
    }
    // A map is used here to query for the designations of all the unique ownerIds 
    // on user records.
    Map<Id, User> owners = newMap<Id, User>([SELECT Designation__c 
                                               FROM User 
                                              WHERE Id IN :ownerIds]);
    
    // Trigger.new is used to iterate over a list of all new account records.
    // The Owner_Designation c field on account records is set 
    // to the designation on user records.
    for (Account a : Trigger.new) {
        a.Owner_Designation__c = owners.get(a.OwnerId).Designation__c;
    }
}

// Sample class is serializable in the same namespace, and deserializable in the same package
@JsonAccess(serializable='sameNamespace', deserializable='samePackage')
public class SomeSerializableClass {
    //.. 
}

// Sample class is always serializable, and deserializable only in the same namespace 
@JsonAccess(serializable='always')
public class AlwaysSerializable {
    //..
}

// Sample class is never deserializable, and serializable only in the same namespace
@JsonAccess(deserializable='never')
public class NeverDeserializable {
    //..
}

trigger OpportunityTrigger on Opportunity (before update) {
    List<Opportunity_Event__e> opp_events = newList<Opportunity_Event__e>();
    for(Opportunityo :Trigger.new){ 
        if(o.StageName == 'Closed Won') {
            Opportunity_Event__eoe = newOpportunity_Event__e();
            oe.Stage__c = o.StageName;
            opp_events.add(oe);
        }
    }
    List<Database.SaveResult> results = EventBus.publish(opp_events);
    for (Database.SaveResultsr : results) {
        if (sr.isSuccess()) {
            System.debug('Successfully published event.');
        } else {
            for(Database.Errorerr : sr.getErrors()) {
                System.debug('Error returned: ' + 
                             err.getStatusCode() + ' - ' + 
                             err.getMessage());
            }
        }
    }
}

// trigger for listening to order status events.
trigger OrderEventTrigger on Order_Event__e (after insert) {
    List<String> trackingIds = newList<String>();
    for (Order_Event__e event : Trigger.New) {
        trackingIds.add(event.Tracking_Id__c); // collect tracking ids
    }
    
    List<Order__c> orders = [SELECT Id FROM Order__c WHERE Tracking_Id__c IN :trackingIds];
    List<Order__c> ordersUpdate = newList<Order__c>();
    
    // Iterate through each published event.
    for (Order_Event__e event : Trigger.New) {
        for (Order__c order : orders) {
            if (event.Tracking_Id__c == order.Tracking_Id__c) {
                order.Status__c = event.Status__c;
                ordersUpdate.add(order);
            }
        }
    }
    update ordersUpdate; // save status updates of the orders
}

trigger OpportunityTrigger on Opportunity (before insert, after insert, 
                                           before update, after update, 
                                           before delete, after delete) {
    if (trigger.isAfter && trigger.isInsert){
        List<Contact> newConList = newList<Contact>();
        
        for (Opportunity opp: trigger.New){
            if (opp.AdditionalContactLastName__c != NULL) {
                Contact newCon = newContact();
                newCon.LastName = opp.AdditionalContactLastName__c;
                newCon.FirstName = opp.AdditionalContactFirstName__c;
                newCon.Email = opp.AdditionalContactEmail__c;
                newCon.Accountld = opp.Accountld;
                newConList.add(newCon);
            }
        }

        insert newConList;
    }
}

Trigger InefficientAccountTrigger on Account (before update) {
    
    Account a = Trigger.new[0]; // The trigger is used to process a single record only
    // This SOQL query is not optimized to retrieve all the necessary records
    List<Contact> contacts = [
        SELECT Id
          FROM Contact
         WHERE AccountId = :a.Id
    ];
    for (Contact c : contacts) {
        // SOQL queries should not be performed inside loops
        List<Contact> results = [
            SELECT Trade_Show_Candidate__c, MailingCity
              FROM Contact
             WHERE Id = :c.Id 
               AND MailingCity = 'San Francisco' 
             LIMIT 1
        ];
        if (!results.IsEmpty()) {
            Contact con = results.get(0);
            con.Trade_Show_Candidate__c = true;
            update con; // A DML statement should not be performed inside loops.
        }
    }
}

trigger EfficientAccountTrigger on Account (before update) {
    // An Apex trigger should be designed to handle multiple records 
    // instead of a single record only.
    // SOQL queries should be executed outside loops and optimized 
    // to retrieve all necessary records.
    List<Account> accounts = [
        SELECT Id,
               (SELECT Id, MailingCity FROM Contacts WHERE MailingCity = 'San Francisco')
          FROM Account
         WHERE Id IN :Trigger.newMap.keySet()
    ];
     // Use a list to process records in bulk and reduce DML statements to issue
    List<Contact> contacts = newList<Contact>();
    
    // 'for' loops can be used to process the entire record collection.
    for (Account a : accounts) { 
        for (Contact con : a.contacts) {
            con.Trade_Show_Candidate__c = true;
            // The record is added to the collection instead of performing a 
            // DML statement inside the loop.
            contacts.add(con); 
        }
    }
    // DML statements should be executed outside 
    // loops and perform database operations in bulk.
    update contacts; 
}

// This example shows an inefficient Apex trigger and is 
// created for a single type of DML event only, i.e., 'before update'.
trigger InefficientQueryLoopAccountTrigger on Account (before update) {
    // These two statements show inefficient use of SOQL 
    // queries to retrieve records of a single object.
    // Also, both these queries are expected to return more than 50,000 records.
    List<Opportunity> won = [SELECT Id 
                               FROM Opportunity 
                              WHERE StageName = 'Closed Won' 
                                AND AccountId IN: Trigger.newmap.keySet()];
    List<Opportunity> lost = [SELECT Id 
                                FROM Opportunity 
                               WHERE StageName = 'Closed Lost' 
                                 AND AccountId IN: Trigger.newmap.keySet()];
    List<Opportunity> opportunitiesForUpdate = newList<Opportunity>();
    
    // Two for loops are used here to iterate through two types of 
    // records, of the same object, which is not an efficient approach.
    for(Opportunity o : won) {
        // Instead of using a helper class, the logic has been 
        // defined in the trigger.
        o.NextStep = 'Create Order';
        opportunitiesForUpdate.add(o);
    }
    for(Opportunity o : lost) {
        o.NextStep = 'Send Feedback Form';
        opportunitiesForUpdate.add(o);
    }
    update opportunitiesForUpdate;
}

// This example shows an efficient Apex trigger.
// This trigger uses the 'one trigger per object' design 
// approach and considers multiple possible DML events.
trigger EfficientQueryLoopAccountTrigger on Account (before insert, after insert, 
                                                     before update, after update, 
                                                     before delete) {
    if (Trigger.isUpdate) {
        // This code statement uses a single query to retrieve 
        // two types of records of the same object.
        List<Opportunity> wonAndLostOpportunities = [SELECT Id, StageName 
                                                       FROM Opportunity 
                                                      WHERE AccountId IN: Trigger.newmap.keySet()
                                                        AND (StageName = 'Closed Won' 
                                                         OR StageName = 'Closed Lost')
        ];
        // A single for loop is used here to loop through the retrieved records.
        for (Opportunity o : wonAndLostOpportunities) {
            // Two if statements are used here to process the two types of records differently.
            // A helper class with two static methods has been created for the processing logic.
            // The methods of the helper class are being invoked in the trigger here.
            if (o.StageName == 'Closed Won') {
                HelperClass.helperMethodForWonOpportunities(o);
            } else if (o.StageName == 'Closed Lost') {
                HelperClass.helperMethodForLostOpportunities(o);
            }
        }
    }
s}

// This example shows how methods of the Limits class can be 
// used to obtain information about governor limits.
trigger LimitsAccountTrigger on Account (before insert, after insert, 
                                         before update, after update, 
                                         before delete, after delete) {
    if (Trigger.isBefore && Trigger.isUpdate) {
        System.debug('Before SOQL - Total Number of SOQL Queries allowed: ' + 
                     Limits.getLimitQueries());
        System.debug('Before SOQL - Total Number of SOQL Queries used: ' + 
                     Limits.getQueries());
        List<Opportunity> wonAndLostOpportunities = [
            SELECT Id 
              FROM Opportunity 
             WHERE AccountId IN: Trigger.newmap.keySet()
               AND (StageName = 'Closed Won' 
                OR StageName = 'Closed Lost')];
        System.debug('After SOQL - Total Number of SOQL Queries allowed: ' + 
                     Limits.getLimitQueries());
        System.debug('After SOQL - Total Number of SOQL Queries used: ' + 
                     Limits.getQueries());
        for (Opportunity o : wonAndLostOpportunities) {
            if (o.StageName == 'Closed Won') {
                HelperClass.helperMethodForWonOpportunities(o);
            } else if (o.StageName == 'Closed Lost') {
                HelperClass.helperMethodForLostOpportunities(o);
            }
        }
    }
}

// Example shows how an @future method should be invoked in an Apex trigger
trigger AsyncAccountTrigger on Account (before update) {
    // The @future method is invoked only once,
    // and a set of all the newly updated records is passed to the method
    AsyncApexClass.accountMethod(Trigger.newMap.keySet());
}

// The test class of an Apex trigger should be designed to verify handling of large datasets
@isTest
public class ApexTriggerTest {
    @isTest
    static void testAccountTrigger() {
        // The code below inserts 200 account records to test a 'before insert' trigger
        List<Account> accounts = newList<Account>();
        for (Integer x = 0; x < 200; x++) {
            Account a = newAccount(Name = 'Test' + x + 1);
            accounts.add(a);
        }
        
        Test.startTest();
        insert accounts;
        Test.stopTest();
    }
}

List<Account> accounts = [
    SELECT Id, Name, 
           (SELECT Id, Name, Amount, StageName 
              FROM Opportunities)
      FROM Account
     WHERE Id IN :accountIds];
// Loop through the Account records
for (Account a: accounts) {
// The below won't be necessary. Also, SOQL queries should NOT be performed in a loop!
// List<Opportunity> opportunities = [SELECT Id, Name, Amount, Stage 
//                                      FROM Opportunities WHERE AccountId = :a.Id];

// Child relationship dot syntax is used to access related opportunities
for (Opportunity o: a.Opportunities){
    System.debug('Name: ' + o.Name + ' | Stage: ' + o.StageName + ' | Amount: ' + o.Amount );
    }
}

// Example 1: Chaining a method
String url = null;

// a) Using a traditional method
if (user.getProfileUrl() != null) {
    url = user.getProfileUrl().toExternalForm();
}
// b) Using the safe navigation operator
url = user.getProfileUrl()?toExternalForm();

// Example 2: Chaining an object property/field

// a) Using a traditional method
List<Account> results = new List<Account>();
results = [SELECT Name FROM Account WHERE Id = :accountId];
return results.size() == 0 ? null : results[0].Name;

// b) Using the safe navigation operator
return [SELECT Name FROM Account WHERE Id = :accId]?Name;

public static Id getRecordTypeId(String developerName) {
    return (Schema
            .SObjectType
            .Account
            .getRecordTypeInfosByDeveloperName()?
            .get(developerName)?
            .getRecordTypeId());
}