通常，所有类型信息在运行时都可用。这意味着 Apex 启用强制转换，即将一个类的数据类型分配给一个数据 另一个类的类型，但仅当一个类是另一个类的子类时。使用铸造 当您要将对象从一种数据类型转换为另一种数据类型时。

在以下示例中，扩展 类 .因此，它是一个子类 那个班级。这意味着您可以使用强制转换将对象与父对象一起分配 数据类型 （） 添加到对象的 子类数据类型 （）。CustomReportReportReportCustomReport

public virtual class Report {
}

public class CustomReport extends Report {
}

在下面的代码段中，首先将自定义报表对象添加到报表列表中 对象。然后，自定义报表对象将作为报表对象返回，然后 强制转换回自定义报表对象。

...
  // Create a list of report objects
  Report[] Reports = new Report[5];

  // Create a custom report object
  CustomReport a = new CustomReport();

  // Because the custom report is a sub class of the Report class,
  // you can add the custom report object a to the list of report objects
  Reports.add(a);

  // The following is not legal:
  // CustomReport c = Reports.get(0);
  // because the compiler does not know that what you are
  // returning is a custom report. 

  // You must use cast to tell it that you know what
  // type you are returning. Instead, get the first item in the list
  // by casting it back to a custom report object
  CustomReport c = (CustomReport) Reports.get(0);
...

此外，接口类型可以强制转换为子接口或类类型，该类类型 实现该接口。

提示

若要验证类是否为特定类型的类，请使用关键字。有关更多信息，请参阅使用 instanceof 关键字。instanceOf

类和集合

列表和映射可以与类和接口一起使用，其方式与列表和映射相同 与 sObject 一起使用。这意味着，例如，您可以将用户定义的数据类型用于 value 或映射的键。同样，您可以创建一组用户定义的对象。

如果创建映射或接口列表，则 接口可以放入该集合中。例如，如果 List 包含一个接口，并实现 ，然后可以 被放置在列表中。

Collection Casting

由于 Apex 中的集合在运行时具有声明的类型，因此 Apex 允许集合转换。

集合可以采用与数组类似的方式进行强制转换 在 Java 中投射。例如，CustomerPurchaseOrder 对象的列表 如果 class 是子对象，则可以分配给 PurchaseOrder 对象列表 的类。CustomerPurchaseOrderPurchaseOrder

public virtual class PurchaseOrder {

    Public class CustomerPurchaseOrder extends PurchaseOrder {

    }
    {
        List<PurchaseOrder> POs = new PurchaseOrder[] {};
        List<CustomerPurchaseOrder> CPOs = new CustomerPurchaseOrder[]{};
        POs = CPOs;
    }
}

将列表分配给列表变量后，就可以将其强制转换 返回到 CustomerPurchaseOrder 对象的列表，但只是因为该实例是 最初实例化为 CustomerPurchaseOrder 对象的列表。列表 实例化的 PurchaseOrder 对象不能强制转换为 CustomerPurchaseOrder 对象，即使 PurchaseOrder 对象列表仅包含 CustomerPurchaseOrder 对象。CustomerPurchaseOrderPurchaseOrder

如果仅包含 CustomerPurchaseOrders 的 PurchaseOrder 列表的用户 objects 尝试插入 的非 CustomerPurchaseOrder 子类（例如 ），运行时 异常结果。这是因为 Apex 集合在运行时具有声明的类型。PurchaseOrderInternalPurchaseOrder

注意

地图的行为方式与列表在地图的值方面相同。如果值 映射 A 的一侧可以强制转换为映射 B 的值侧，并且它们具有相同的键类型， 然后可以将映射 A 投射到映射 B。如果强制转换无效，则会导致运行时错误 在运行时使用特定映射。

附注

Apex 注解修改了方法或类的使用方式，类似于 Java 中的注解。注释使用初始符号定义，后跟相应的关键字。

@

若要向方法添加批注，请在方法或类之前指定它 定义。例如：

global class MyClass {
     @Future
     Public static void myMethod(String a)
     {
          //long-running Apex code
     }
}

Apex 支持以下注解。

• @AuraEnabled
• @Deprecated
• @Future
• @InvocableMethod
• @InvocableVariable
• @IsTest
• @JsonAccess
• @NamespaceAccessible
• @ReadOnly
• @RemoteAction
• @SuppressWarnings
• @TestSetup
• @TestVisible
• Apex REST注解：
  • @ReadOnly
  • @RestResource(urlMapping=’/yourUrl‘)
  • @HttpDelete
  • @HttpGet
  • @HttpPatch
  • @HttpPost
  • @HttpPut

1. AuraEnabled 注解
2. 已弃用的批注
3. 未来注解
4. InvocableMethod 注解 使用注解
   来标识可作为可调用操作运行的方法。InvocableMethod
5. InvocableVariable 批注
   使用批注来标识自定义类中可调用方法使用的变量。InvocableVariable
6. IsTest 注解
7. JsonAccess 注解
8. NamespaceAccessible 批注
9. ReadOnly 注释
10. RemoteAction 批注
11. SuppressWarnings 注释
    此注释在 Apex 中不执行任何操作，但可用于向第三方工具提供信息。
12. TestSetup 批注 使用批注
    定义的方法用于创建可用于类中所有测试方法的通用测试记录。@TestSetup
13. TestVisible 注解

AuraEnabled（Lightning启用）注解

该注释支持客户端和服务器端访问 Apex 控制器方法。 提供此注释后，您的方法可用于 Lightning 组件 （Lightning Web 组件和 Aura 组件）。只有这个方法 注解是公开的。@AuraEnabled

在 API 版本 44.0 及更高版本中，您可以通过缓存方法提高运行时性能 使用注释在客户端上生成结果。您只能缓存以下方法的结果 检索数据但不修改数据的方法。使用此注解可消除 需要调用 JavaScript 代码 在调用 Apex 方法的每个操作上。@AuraEnabled(cacheable=true)setStorable()

在 API 版本 55.0 及更高版本中，您可以使用注释使 Apex 方法成为 缓存在全局缓存中。@AuraEnabled(cacheable=true scope=’global’)

版本化行为更改

在 API 版本 55.0 及更高版本中，不允许对带有 注释的方法进行重载。@AuraEnabled

废弃的注解

使用注释来标识方法、类、异常、枚举、 接口或变量，这些接口或变量在后续版本的 被管理 它们所在的包。此注释在以下情况下很有用 随着需求的发展重构托管包中的代码。新订阅者 看不到已弃用的元素，而这些元素继续运行 现有订阅者和 API 集成。Deprecated

以下代码片段显示了已弃用的方法。一样 语法可用于弃用类、异常、枚举、接口、 或变量。

@Deprecated
  // This method is deprecated. Use myOptimizedMethod(String a, String b) instead.
  global void myMethod(String a) {
   
}

弃用 Apex 标识符时，请注意以下规则：

• 非托管包不能包含使用关键字的代码。deprecated
• 当 Apex 项被弃用时，引用已弃用的 Apex 项的所有全局访问修饰符 标识符也必须弃用。任何在其中使用弃用类型的全局方法 还必须弃用输入参数或方法返回类型中的签名。已弃用的项（如方法或类）可以 仍由包开发人员在内部引用。
• webservice方法和变量不能是 荒废的。
• 您可以弃用 ，但不能弃用 个人价值。enumenum
• 可以弃用接口，但不能弃用接口中的单个方法。
• 您可以弃用抽象类，但不能弃用 抽象类。
• 您无法删除批注 在发布软件包版本后，取消弃用 Apex 中的某些内容，其中 Apex 中的项已弃用。Deprecated

有关包版本的详细信息，请参阅什么是包？。

未来的注解

使用注释进行标识 异步执行的方法。当您指定 时，该方法将在 Salesforce 具有 可用资源。FutureFuture

例如，您可以在以下情况下使用注释 对外部服务进行异步 Web 服务标注。没有 注解时，Web 服务标注是由执行 Apex 代码，在标注完成之前，不能进行其他处理 （同步处理）。Future

带有注解的方法必须是静态方法，并且只能返回 void 类型。指定的 参数必须是基元数据类型、基元数据类型的数组或集合 的原始数据类型。带有注解的方法不能将 sObjects 或对象作为参数。FutureFuture

若要使类中的方法异步执行，请使用注释定义方法。例如：Future

global class MyFutureClass {

  @Future 
  static void myMethod(String a, Integer i) {
    System.debug('Method called with: ' + a + ' and ' + i);
    // Perform long-running code
  }
}

若要允许在方法中使用标注，请指定 。默认值为 ，这会阻止方法 进行标注。Future(callout=true)(callout=false)

以下代码片段演示如何指定方法执行 标注：

@Future (callout=true)
  public static void doCalloutFromFuture() {
   //Add code to perform callout
}

未来方法注意事项

• 请记住，任何使用注解的方法都需要特别考虑，因为该方法不一定 按调用的相同顺序执行。Future
• 带有注释的方法不能在 Visualforce 控制器中使用 要么是方法，要么在构造函数中。FuturegetMethodNamesetMethodName
• 不能从同样具有批注的方法调用批注的方法。也不能从调用 另一个带注释的方法。FutureFuture

InvocableMethod注解

使用注释来标识可以作为可调用运行的方法 行动。InvocableMethod

注意

如果流调用 Apex，则正在运行的用户必须具有相应的 Apex 类安全性 在其用户配置文件或权限集中设置。

可调用方法从交互的 Rest、Apex、Flow 或 Einstein 机器人中本机调用 与外部 API 源一起使用。可调用方法具有动态输入和输出值，并且 支持描述调用。

此代码示例演示具有基元数据类型的可调用方法。

public class AccountQueryAction {
  @InvocableMethod(label='Get Account Names' description='Returns the list of account names corresponding to the specified account IDs.' category='Account')
  public static List<String> getAccountNames(List<ID> ids) {
    List<Account> accounts = [SELECT Name FROM Account WHERE Id in :ids];
    Map<ID, String> idToName = new Map<ID, String>();
    for (Account account : accounts) {
      idToName.put(account.Id, account.Name);
    }
    // put each name in the output at the same position as the id in the input
    List<String> accountNames = new List<String>();
    for (String id : ids) {
      accountNames.add(idToName.get(id));
    }
    return accountNames;
  }
}

此代码示例演示具有特定 sObject 数据类型的可调用方法。

public class AccountInsertAction {
  @InvocableMethod(label='Insert Accounts' description='Inserts the accounts specified and returns the IDs of the new accounts.' category= 'Account')
  public static List<ID> insertAccounts(List<Account> accounts) {
    Database.SaveResult[] results = Database.insert(accounts);
    List<ID> accountIds = new List<ID>();
      for (Database.SaveResult result : results) {
      accountIds.add(result.getId());
    }
    return accountIds;
  }
}

此代码示例演示具有泛型 sObject 数据类型的可调用方法。

public with sharing class GetFirstFromCollection {
  @InvocableMethod
  public static List<Results> execute (List<Requests> requestList) {
    List<Results> results = new List<Results>();
    for (Requests request : requestList) {
      List<SObject> inputCollection = request.inputCollection;
      SObject outputMember = inputCollection[0];
      
      //Create a Results object to hold the return values
      Results result = new Results();
      
      //Add the return values to the Results object
      result.outputMember = outputMember;
      
      //Add Result to the results List at the same position as the request is in the requests List
      results.add(result);
    }
    return results;
  }

  public class Requests {
    @InvocableVariable(label='Records for Input' description='yourDescription' required=true)
    public List<SObject> inputCollection;
  }

  public class Results {
    @InvocableVariable(label='Records for Output' description='yourDescription' required=true)
    public SObject outputMember;
  }
}

此代码示例演示了具有 SVG 文件中自定义图标的可调用方法。

global class CustomSvgIcon { 
  @InvocableMethod(label='myIcon' iconName='resource:myPackageNamespace__google:top')
  global static List<Integer> myMethod(List<Integer> request) {
    List<Integer> results = new List<Integer>();
    for(Integer reqInt : request) { 
       results.add(reqInt);
    }
    return results;
  }
}

此代码示例显示了一个带有 Salesforce Lightning 自定义图标的可调用方法 设计系统（SLDS）。

public class CustomSldsIcon { 
  
  @InvocableMethod(iconName='slds:standard:choice') 
  public static void run() {} 
  
  }

支持的修饰符

所有修饰符都是可选的。标签方法的标签，在流生成器中显示为操作名称。这 默认值是方法名称，但我们建议您提供标签。描述方法的说明，在流中显示为操作说明 建筑工人。缺省值为 。Null标注标注修饰符标识该方法是否调用外部系统。如果 该方法调用外部系统，添加 .缺省值为 。callout=truefalse类别方法的类别，在 Flow Builder 中显示为操作类别。 如果未提供类别（默认情况下），则操作将显示在“未分类”下。配置编辑器使用方法注册并显示在 Flow 中的自定义属性编辑器 管理员配置操作时的生成器。如果未指定此修饰符，则 Flow 生成器使用标准属性编辑器。图标名称要用作 Flow Builder 中操作的自定义图标的图标的名称 帆布。您可以将上传的 SVG 文件指定为静态资源，也可以将 Salesforce Lightning Design System 标准图标。

InvocableMethod 注意事项

实施说明

• 可调用方法必须是 and 或 ，并且其类必须是外部类。staticpublicglobal
• 一个类中只有一个方法可以具有注释。InvocableMethod
• 其他批注不能与批注一起使用。InvocableMethod

输入和输出最多可以有一个输入参数，其数据类型必须为以下参数之一：

• 基元数据类型的列表或基元数据类型的列表列表 – 泛型类型不是 支持。Object
• sObject 类型的列表或 sObject 类型的列表列表。
• 泛型 sObject 类型 （） 的列表或泛型 sObject 类型的列表 ().List<sObject>List<List<sObject>>
• 用户定义类型的列表，包含受支持类型的变量或 用户定义的 Apex 类型，带有注释。要实现您的数据类型，请创建一个 自定义全局或公共 Apex 类。该类必须包含至少一个成员 变量，带有可调用的变量注解。InvocableVariable

如果返回类型不是 ，则数据 方法返回的类型必须是下列类型之一：Null

• 基元数据类型的列表或基元数据类型的列表列表 – 泛型类型不是 支持。Object
• sObject 类型的列表或 sObject 类型的列表列表。
• 泛型 sObject 类型 （） 的列表或泛型 sObject 类型的列表 ().List<sObject>List<List<sObject>>
• 用户定义类型的列表，包含受支持类型的变量或 用户定义的 Apex 类型，带有注释。要实现您的数据类型，请创建一个 自定义全局或公共 Apex 类。该类必须包含至少一个成员 变量，带有可调用的变量注解。InvocableVariable注意为了正确的膨胀 实现时，输入和输出的大小和顺序必须匹配。 例如，第 i 个“输出”条目必须与第 i 个“输入”条目相对应。 当您的操作在 批量执行，例如在记录触发器中使用 Apex 操作时 流。

托管软件包

• 可以在包中使用可调用方法，但在添加可调用方法后 无法将其从更高版本的包中删除。
• 公共可调用方法可由 托管包。
• 全局可调用方法可以在订阅者组织中的任何位置引用。只 全局可调用方法显示在 Flow Builder 和 Process Builder 的 订阅者组织。

有关可调用操作的详细信息，请参阅操作开发人员指南。

Invocable变量注解

使用注释来标识 自定义类。InvocableVariable

注释标识类 变量，用作方法的可调用操作的输入或输出参数。如果创建自己的自定义类以 用作可调用方法的输入或输出，可以对单个类成员进行注释 变量，使它们可供方法使用。InvocableVariableInvocableMethod

下面的代码示例演示了具有 invocable 变量的 invocable 方法。

global class ConvertLeadAction {
  @InvocableMethod(label='Convert Leads')
  global static List<ConvertLeadActionResult> convertLeads(List<ConvertLeadActionRequest> requests) {
    List<ConvertLeadActionResult> results = new List<ConvertLeadActionResult>();
    for (ConvertLeadActionRequest request : requests) {
      results.add(convertLead(request));
    }
    return results;
  }

  public static ConvertLeadActionResult convertLead(ConvertLeadActionRequest request) {
    Database.LeadConvert lc = new Database.LeadConvert();
    lc.setLeadId(request.leadId);
    lc.setConvertedStatus(request.convertedStatus);

    if (request.accountId != null) {
        lc.setAccountId(request.accountId);
    }

    if (request.contactId != null) {
      lc.setContactId(request.contactId);
    }

    if (request.overWriteLeadSource != null && request.overWriteLeadSource) {
      lc.setOverwriteLeadSource(request.overWriteLeadSource);
    }

    if (request.createOpportunity != null && !request.createOpportunity) {
      lc.setDoNotCreateOpportunity(!request.createOpportunity);
    }

    if (request.opportunityName != null) {
      lc.setOpportunityName(request.opportunityName);
    }

    if (request.ownerId != null) {
      lc.setOwnerId(request.ownerId);
    }

    if (request.sendEmailToOwner != null && request.sendEmailToOwner) {
      lc.setSendNotificationEmail(request.sendEmailToOwner);
    }

    Database.LeadConvertResult lcr = Database.convertLead(lc, true);
    if (lcr.isSuccess()) {
      ConvertLeadActionResult result = new ConvertLeadActionResult();
      result.accountId = lcr.getAccountId();
      result.contactId = lcr.getContactId();
      result.opportunityId = lcr.getOpportunityId();
      return result;
    } else {
      throw new ConvertLeadActionException(lcr.getErrors()[0].getMessage());
    }
  }

  global class ConvertLeadActionRequest {
    @InvocableVariable(required=true)
    global ID leadId;

    @InvocableVariable(required=true)
    global String convertedStatus;

    @InvocableVariable
    global ID accountId;

    @InvocableVariable
    global ID contactId;

    @InvocableVariable
    global Boolean overWriteLeadSource;

    @InvocableVariable
    global Boolean createOpportunity;

    @InvocableVariable
    global String opportunityName;

    @InvocableVariable
    global ID ownerId;

    @InvocableVariable
    global Boolean sendEmailToOwner;
  }

  global class ConvertLeadActionResult {
    @InvocableVariable
    global ID accountId;

    @InvocableVariable
    global ID contactId;

    @InvocableVariable
    global ID opportunityId;
  }

  class ConvertLeadActionException extends Exception {}
}

以下代码示例演示了一个 invocable 方法，该方法具有 泛型 sObject 数据类型。

public with sharing class GetFirstFromCollection {
  @InvocableMethod
  public static List <Results> execute (List<Requests> requestList) {
    List<SObject> inputCollection = requestList[0].inputCollection;
    SObject outputMember = inputCollection[0];

    //Create a Results object to hold the return values
    Results response = new Results();

    //Add the return values to the Results object
    response.outputMember = outputMember;

    //Wrap the Results object in a List container 
    //(an extra step added to allow this interface to also support bulkification)
    List<Results> responseWrapper= new List<Results>();
    responseWrapper.add(response);
    return responseWrapper;    
  }
}

public class Requests {
  @InvocableVariable(label='Records for Input' description='yourDescription' required=true)
  public List<SObject> inputCollection;
  }

public class Results {
  @InvocableVariable(label='Records for Output' description='yourDescription' required=true)
  public SObject outputMember;
  }
}

支持的修饰符

可调用变量注释支持此示例中所示的修饰符。

@InvocableVariable(label=’yourLabel‘ description=’yourDescription‘ required=(true | false))所有修饰符都是可选的。标签变量的标签。默认值为变量名称。

提示

此标签显示在 Flow Builder 中 Action 元素的 Action 元素中 对应于可调用的方法。此标签可帮助管理员了解如何使用 流中的变量。描述变量的说明。缺省值为 。Null必填指定变量是否为必需变量。如果未指定，则默认值为 false。 对于输出变量，将忽略该值。

InvocableVariable 注意事项

• 其他批注不能与批注一起使用。InvocableVariable
• 只有全局变量和公共变量才能是可调用变量。
• 可调用变量不能是以下变量之一：
  • 非成员变量，如 a 或 变量。staticlocal
  • 属性。
  • 一个变量。final
  • Protected或。private
• 可调用变量的数据类型必须为下列类型之一：
  • Object 以外的基元
  • sObject，泛型 sObject 或特定 sObject
  • 从 Apex 创建的基元、sObjects、对象列表的列表或列表 类或集合
• Apex 中的可调用变量名称必须与流程中的名称匹配。名称区分大小写。
• 对于托管软件包：
  • 公共可调用变量可以在同一托管的流和流程中设置 包。
  • 全局可调用变量可以在订阅者组织中的任何位置设置。只有全球 可调用变量显示在订阅者的 Flow Builder 和 Process Builder 中 组织。

IsTest的注解

使用注释 定义仅包含用于测试应用程序的代码的类和方法。这 注释可以在括号内使用多个修饰符，并用空格分隔。@IsTest

注意

上的注释 methods 等同于关键字。如 最佳做法，Salesforce 建议您使用 而不是 .关键字可以在 未来版本。@IsTesttestMethod@IsTesttestMethodtestMethod

类和方法定义为 can be 或 。定义为的类必须是顶级类。@IsTestprivatepublic@IsTest

注意

使用注释定义的类不计入组织 6 MB 的限制 所有 Apex 代码。@IsTest

下面是一个包含两个测试的私有测试类的示例 方法。

@IsTest
private class MyTestClass {

   // Methods for testing
   @IsTest
   static void test1() {
      // Implement test code
   }

   @IsTest
   static void test2() {
      // Implement test code
   }

}

下面是包含实用程序的公共测试类的示例 测试数据的方法 创造：

@IsTest 
public class TestUtil {

   public static void createTestAccounts() { 
      // Create some test accounts
   }

   public static void createTestContacts() {
      // Create some test contacts
   }

}

定义为 不能是接口或 枚举。@IsTest

公共测试类的方法只能从 运行测试，即测试方法或测试方法调用的代码。非测试 请求不能调用公共方法。.要了解各种方法，请执行以下操作 运行测试方法，请参阅运行单元测试方法。

@IsTest（SeeAllData=true）注解

对于使用 Salesforce API 版本 24.0 保存的 Apex 代码 稍后，使用注解授予测试类和 单个测试方法访问组织中的所有数据。交通 包括测试未创建的预先存在的数据。从 Apex 代码开始 使用 Salesforce API 版本 24.0 保存，测试方法无权访问 组织中预先存在的数据。但是，保存的测试代码 Salesforce API 版本 23.0 及更早版本继续可以访问 组织。@IsTest(SeeAllData=true)请参见在单元测试中将测试数据与组织数据隔离。注释的注意事项@IsTest(SeeAllData=true)

• 如果测试类是用注解定义的，则 未显式设置关键字的测试方法。@IsTest(SeeAllData=true)SeeAllData=trueSeeAllData
• 注解用于打开 在类或方法级别应用时的数据访问。但是，如果 包含类已用 、 对于方法，将忽略对方法进行批注。 在这种情况下，该方法仍然可以访问 组织。使用重写对方法进行注释，对于该方法，对 类。@IsTest(SeeAllData=true)@IsTest(SeeAllData=true)@IsTest(SeeAllData=false)@IsTest(SeeAllData=true)@IsTest(SeeAllData=false)
• @IsTest(SeeAllData=true)并且不能使用注释 一起使用相同的 Apex 方法。@IsTest(IsParallel=true)

此示例演示如何使用注释定义测试类。所有 此类中的测试方法可以访问 组织。

@IsTest(SeeAllData=true)

// All test methods in this class can access all data.
@IsTest(SeeAllData=true)
public class TestDataAccessClass {

    // This test accesses an existing account. 
    // It also creates and accesses a new test account.
    @IsTest
    static void myTestMethod1() {
        // Query an existing account in the organization. 
        Account a = [SELECT Id, Name FROM Account WHERE Name='Acme' LIMIT 1];
        System.assert(a != null);
        
        // Create a test account based on the queried account.
        Account testAccount = a.clone();
        testAccount.Name = 'Acme Test';
        insert testAccount;
        
        // Query the test account that was inserted.
        Account testAccount2 = [SELECT Id, Name FROM Account 
                                WHERE Name='Acme Test' LIMIT 1];
        System.assert(testAccount2 != null);
    }
       
    
    // Like the previous method, this test method can also access all data
    // because the containing class is annotated with @IsTest(SeeAllData=true).
    @IsTest
    static void myTestMethod2() {
        // Can access all data in the organization.
   }
  
}

第二个示例演示如何在测试上应用注释 方法。由于测试方法的类没有注释，因此必须注释 方法，以便能够访问该方法的所有数据。第二种测试方法没有 具有此注释，因此它只能访问它创建的数据。此外，它还可以 访问用于管理组织的对象，例如 用户。

@IsTest(SeeAllData=true)

// This class contains test methods with different data access levels.
@IsTest
private class ClassWithDifferentDataAccess {

    // Test method that has access to all data.
    @IsTest(SeeAllData=true)
    static void testWithAllDataAccess() {
        // Can query all data in the organization.      
    }
    
    // Test method that has access to only the data it creates
    // and organization setup and metadata objects.
    @IsTest
    static void testWithOwnDataAccess() {
        // This method can still access the User object.
        // This query returns the first user object.
        User u = [SELECT UserName,Email FROM User LIMIT 1]; 
        System.debug('UserName: ' + u.UserName);
        System.debug('Email: ' + u.Email);
        
        // Can access the test account that is created here.
        Account a = new Account(Name='Test Account');
        insert a;      
        // Access the account that was just created.
        Account insertedAcct = [SELECT Id,Name FROM Account 
                                WHERE Name='Test Account'];
        System.assert(insertedAcct != null);
    }
}

@IsTest（OnInstall=true）注解

使用注释指定哪些 Apex 测试是 在软件包安装期间执行。此注释用于托管中的测试 或非托管包。仅测试具有此注释的方法，或具有此注释的方法 具有此注释的测试类的一部分在打包过程中执行 安装。@IsTest(OnInstall=true)注释为在打包期间运行的测试 安装必须通过才能成功安装包。不是 在软件包安装期间绕过失败测试的可能性更长。没有此注释的测试方法或类， 或者，在安装过程中不会执行带有 或 注释的。@IsTest(OnInstall=false)@IsTest

在包安装和升级期间运行的带批注的测试不计入代码覆盖率。 但是，在包创建操作期间会跟踪和计算代码覆盖率。 因为从托管软件包安装的 Apex 代码被排除在组织级别之外 对代码覆盖率的要求，您不太可能受到影响。但是，如果你 跟踪托管包测试覆盖率，则必须在 要更新代码覆盖率统计信息的包安装或升级操作。 包安装不会被代码覆盖率要求阻止。IsTest(OnInstall=true)

此示例演示如何对测试方法进行批注，该方法为 在软件包安装期间执行。在此示例中，已执行，但未执行。test1test2test3

public class OnInstallClass {
   // Implement logic for the class.
   public void method1(){
      // Some code
   }
}

@IsTest
private class OnInstallClassTest {
   // This test method will be executed
   // during the installation of the package.
   @IsTest(OnInstall=true)
   static void test1() {
      // Some test code
   }

   // Tests excluded from running during the
   // the installation of a package.

   @IsTest
   static void test2() {
      // Some test code
   }

   @IsTest
   static void test3() {
      // Some test code
   }
}

@IsTest（IsParallel=true）注解

使用注释来指示测试类 可以并行运行。对并发测试数的默认限制没有 适用于这些测试课程。此注解使测试类的执行 效率更高，因为可以并行运行更多测试。@IsTest(IsParallel=true)注释的注意事项@IsTest(IsParallel=true)

• 此注释将覆盖禁用并行的设置 测试。
• @IsTest(SeeAllData=true)和注释不能在同一个 Apex 方法上一起使用。@IsTest(IsParallel=true)

JsonAccess注解

在 Apex 类中定义的注释 级别控制类的实例是否可以序列化或反序列化。如果 注解限制了 JSON 序列化和反序列化，抛出运行时异常。@JsonAccessJSONException注解的 和 参数强制执行 Apex 允许序列化和 反序列化。您可以指定一个或两个参数，但不能指定注释 没有参数。参数的有效值，用于指示序列化和 允许反序列化：

serializabledeserializable@JsonAccess

• never：从不允许
• sameNamespace：仅允许 Apex 代码 相同的命名空间
• samePackage：仅允许 Apex 代码 相同的包（仅影响第二代包）
• always：始终允许任何 Apex 代码

JsonAccess考虑

• 如果注释为 扩展时，扩展类不继承此属性。JsonAccess
• 如果将该方法应用于对象 这不能被序列化，私人数据可以被暴露。您必须在必须保护其数据的对象上重写该方法。 例如，序列化在 Map 中存储为键的对象会调用该方法。生成的映射包括键（字符串） 和值条目，从而公开对象的所有字段。toStringtoStringtoString

此示例代码显示了一个标有注释的 Apex 类。@JsonAccess

// SomeSerializableClass is serializable in the same package and deserializable in the wider namespace

@JsonAccess(serializable='samePackage' deserializable=’sameNamespace’)
public class SomeSerializableClass { }


// AlwaysDeserializable class is always deserializable and serializable only in the same namespace (default value from version 49.0 onwards)

@JsonAccess(deserializable=’always’)
public class AlwaysDeserializable { }

版本化行为更改

在版本 48.0 及更早版本中，反序列化的默认访问权限是，序列化的默认访问权限是保留现有行为。从 从版本 49.0 开始，序列化和反序列化的默认访问权限为 。alwayssameNamespacesameNamespace

命名空间可访问注解

在 包可用于使用相同命名空间的其他包。没有这个 注解、定义的 Apex 类、方法、接口、属性和抽象类 在 2GP 包中，无法被与它们共享的其他包访问 命名空间。声明为全局的 Apex 在所有命名空间中始终可用，并且 不需要注释。@NamespaceAccessible

有关 2GP 托管包的详细信息，请参阅第二代托管包 Salesforce DX 开发人员指南中的软件包。

跨 Apex 可访问性的注意事项 包

• 不能将注释用于 Apex 方法。@NamespaceAccessible@AuraEnabled
• 您可以随时添加或删除批注，即使在托管上也是如此 并发布了 Apex 代码。确保没有依赖包 在添加或删除之前依赖注释的功能 它。@NamespaceAccessible
• 在软件包中添加或删除 Apex 时，请考虑影响 对于安装了引用此包的其他包版本的客户 包的注解。在推送软件包升级之前，请确保没有 客户正在运行的包版本在以下情况下无法完全编译 已推送升级。@NamespaceAccessible
• 如果公共接口声明为 ，则所有接口成员都继承 注解。不能使用 对单个接口成员进行注释。@NamespaceAccessible@NamespaceAccessible
• 如果将公共变量或受保护的变量或方法声明为 ，则其定义类 必须是全局的或带有注释的公共的。@NamespaceAccessible@NamespaceAccessible
• 如果将公共或受保护的内部类声明为 ，则其封闭式 类必须是带有注释的全局类或公共类。@NamespaceAccessible@NamespaceAccessible

此示例显示一个标有批注的 Apex 类。这 类可供同一命名空间中的其他包访问。第一个 构造函数在命名空间中也可见，但第二个构造函数不可见。

@NamespaceAccessible

// A namespace-visible Apex class
@NamespaceAccessible
public class MyClass {
    private Boolean bypassFLS;

    // A namespace-visible constructor that only allows secure use
    @NamespaceAccessible
    public MyClass() {
        bypassFLS = false;
    }

    // A package private constructor that allows use in trusted contexts,
    // but only internal to the package
    public MyClass (Boolean bypassFLS) {
        this.bypassFLS = bypassFLS;
    }
    @NamespaceAccessible
    protected Boolean getBypassFLS() {
       return bypassFLS;
    }
}

版本化行为更改

在 API 版本 47.0 及更高版本中@NamespaceAccessible，不允许在标有 @AuraEnabled。因此，从软件包安装的 Aura 或 Lightning Web 组件不能 从另一个包调用 Apex 方法，即使两个包位于同一命名空间中。

在 API 版本 50.0 及更高版本中，范围和可访问性规则在 Apex 上强制执行 用 注释的变量、方法、内部类和接口。出于辅助功能考虑， 请参阅 Apex 的注意事项 跨软件包的可访问性。有关基于命名空间的可见性的详细信息， 请参阅 Apex 的基于命名空间的可见性 第二代包中的类。@NamespaceAccessible

只读注解

该注释允许您 通过增加限制，对 Lightning 平台数据库执行限制较少的查询 请求返回的行数为 1,000,000。所有其他限制仍然适用。这 注释会阻止请求中的以下操作：DML 操作、对 的调用和排队的异步 Apex 作业。@ReadOnlySystem.schedule

注释可用于 REST 和 SOAP Web 服务以及接口。若要使用注释，顶级请求必须位于计划中 执行或 Web 服务调用。例如，如果 Visualforce 页面调用 包含批注的 Web 服务，请求失败，因为 Visualforce 是顶级请求，而不是 Web 服务。@ReadOnlySchedulable@ReadOnly@ReadOnly

Visualforce 页面可以使用注释调用控制器方法，这些方法使用 同样放宽了限制。要增加其他特定于 Visualforce 的限制，例如 作为可供迭代组件使用的集合的大小，例如 ，您可以将标记上的属性设置为 。有关更多信息，请参见 Visualforce Developer 的 指南。@ReadOnly<apex:pageBlockTable>readonly<apex:page>true

版本化行为更改

在 API 版本 49.0 之前，在 Apex 上使用 还需要 REST 方法（@HttpDelete、@HttpGet、@HttpPatch、@HttpPost 或 @HttpPut） 用 注释方法。在 API 中 版本 49.0 及更高版本中，您可以仅使用 .@ReadOnly@RemoteAction@ReadOnly

远程操作注解

注释 支持通过 JavaScript 调用 Visualforce 中使用的 Apex 方法。这 进程通常称为 JavaScript 远程处理。RemoteAction

注意

带有注释的方法必须是 和 或 。RemoteActionstaticglobalpublic将 Apex 类作为自定义控制器或控制器扩展添加到 页。

<apex:page controller="MyController" extension="MyExtension">

警告

添加控制器或控制器扩展将授予对该 Apex 类中所有方法的访问权限，即使这些方法 页面中不使用方法。任何可以查看该页面的人都可以执行所有方法，并向 控制器。@RemoteAction@RemoteAction然后，将请求添加为 JavaScript 函数调用。一个简单的 JavaScript 远程调用采用以下方法 形式。

[namespace.]MyController.method(
    [parameters...,]
    callbackFunction,
    [configuration]
);

在控制器中，Apex 方法声明前面带有类似 这：

@RemoteAction

@RemoteAction
global static String getItemId(String objectName) { ... }

Apex 方法必须是 和 或 。

@RemoteActionstaticglobalpublic

您的方法可以采用 Apex 基元、集合、类型化和泛型 sObjects，以及 用户定义的 Apex 类和接口作为参数。通用 sObject 必须具有 ID 或 sobjectType 值来标识实际类型。接口参数必须具有 apexType 确定实际类型。您的方法可以返回 Apex 基元、sObjects、集合、 用户定义的 Apex 类和枚举、 、 、 或 。SaveResultUpsertResultDeleteResultSelectOptionPageReference

有关详细信息，请参阅《Visualforce 开发人员指南》中的“适用于 Apex 控制器的 JavaScript 远程处理”。

抑制警告注解

此注释在 Apex 中不执行任何操作，但可用于向 第三方工具。

注释在 Apex 中不执行任何操作，但可用于向 第三方工具。@SuppressWarnings

测试设置注解

使用注解定义的方法 用于创建可用于 类。

@TestSetup

语法

测试设置方法是在测试类中定义的，不带任何参数，也不返回任何值。这 以下是测试设置方法的语法。

@TestSetup static void methodName() {

}

如果测试类包含测试设置方法，则测试框架将执行测试设置 方法，在类中的任何测试方法之前。在测试设置中创建的记录 方法可用于测试类中的所有测试方法，并在 测试类执行。如果测试方法更改了这些记录，例如记录字段更新或 记录删除，这些更改将在每个测试方法完成执行后回滚。这 接下来，执行测试方法可以访问这些记录的原始未修改状态。

注意

每个测试类只能有一种测试设置方法。

只有测试类的默认数据隔离模式才支持测试设置方法。 如果测试类或测试方法可以使用批注访问组织数据， 此类不支持测试设置方法。因为测试的数据隔离 适用于 API 版本 24.0 及更高版本，也提供测试设置方法 仅适用于这些版本。@IsTest(SeeAllData=true)

测试可见注解

使用注释 允许测试方法访问另一个成员的私有或受保护成员 测试类之外的类。这些成员包括方法、成员 变量和内部类。此注释可实现更宽松的 仅用于运行测试的访问级别。此注解不 如果非测试类访问成员，则更改成员的可见性。TestVisible

使用此注释，您不必更改方法的访问修饰符，并且 如果要在测试方法中访问它们，则将变量添加到 public。例如，如果 私有成员变量不应该暴露给外部类，但它 必须可通过测试方法访问，才能将注释添加到变量定义中。TestVisible

此示例演示如何对私有类成员变量进行批注 和私有方法。TestVisible

public class TestVisibleExample {
    // Private member variable
    @TestVisible private static Integer recordNumber = 1;

    // Private method
    @TestVisible private static void updateRecord(String name) {
        // Do something
    }
}

此测试类使用上一个类，并包含访问带注释的 成员变量和方法。

@IsTest
private class TestVisibleExampleTest {
    @IsTest static void test1() {
        // Access private variable annotated with TestVisible
        Integer i = TestVisibleExample.recordNumber;
        System.assertEquals(1, i);

        // Access private method annotated with TestVisible
        TestVisibleExample.updateRecord('RecordName');
        // Perform some verification
    }
}

Apex REST 注解

使用这些注解将 Apex 类公开为 RESTful Web 服务。

• @ReadOnly
• @RestResource(urlMapping=’/yourUrl‘)
• @HttpDelete
• @HttpGet
• @HttpPatch
• @HttpPost
• @HttpPut

RestResource Annotation

注释用于 类级别，使您能够将 Apex 类公开为 REST 资源。@RestResource使用此注释时的一些注意事项：

• URL 映射是相对于 https:// instance.salesforce.com/services/apexrest/ 的。
• URL 映射可以包含通配符 （*）。
• URL 映射区分大小写。例如，的 URL 映射与包含 而不是 的 REST 资源匹配。my_urlmy_urlMy_Url
• 要使用此注释，必须将 Apex 类定义为全局类。

URL 准则

URL 路径映射如下所示：

• 路径必须以正斜杠 （/） 开头。
• 路径长度最多为 255 个字符。
• 路径中出现的通配符 （*） 前面必须有正斜杠 （/）。 此外，除非通配符是路径中的最后一个字符，否则必须遵循通配符 正斜杠 （/）。

映射 URL 的规则如下：

• 完全匹配总是获胜。
• 如果未找到完全匹配项，请查找具有匹配通配符的所有模式，然后选择 其中最长的（按字符串长度计算）。
• 如果未找到通配符匹配项，则返回 HTTP 响应状态代码 404。

命名空间类的 URL 包含命名空间。例如，如果您的类位于命名空间中，并且该类映射到 ，则 API URL 将修改如下：https:// instance.salesforce.com/services/apexrest/abc/your_url/。 在发生 URL 冲突的情况下，始终使用命名空间类。abcyour_url

Http删除注解

注释在方法级别使用 并使您能够将 Apex 方法公开为 REST 资源。此方法在发送 HTTP 请求时调用，并删除指定的 资源。@HttpDeleteDELETE

若要使用此批注，必须将 Apex 方法定义为 全局静态。

HttpGet的注解

注释用于方法级别和 使您能够将 Apex 方法公开为 REST 资源。此方法在发送 HTTP 请求时调用，并返回指定的 资源。@HttpGetGET以下是使用此注释时的一些注意事项：

• 若要使用此注释，必须将 Apex 方法定义为全局静态方法。
• 注释的方法也称为 if HTTP 请求使用 request 方法。@HttpGetHEAD

HttpPatch 的注解

注释在方法级别使用 并使您能够将 Apex 方法公开为 REST 资源。此方法在发送 HTTP 请求时调用，并更新指定的 资源。@HttpPatchPATCH

若要使用此注释，必须将 Apex 方法定义为全局静态方法。

HttpPost的注解

注释用于方法 级别，并使您能够将 Apex 方法公开为 REST 资源。此方法称为 发送 HTTP 请求时，并创建一个 新资源。@HttpPostPOST

若要使用此注释，必须将 Apex 方法定义为全局静态方法。

HttpPut 的注解

注释用于方法级别和 使您能够将 Apex 方法公开为 REST 资源。此方法在发送 HTTP 请求时调用，并创建或更新指定的 资源。@HttpPutPUT

若要使用此注释，必须将 Apex 方法定义为全局静态方法。

Apex 提供了 关键字 final, instanceof, super, this, transient, with sharing and without sharing

1. 使用 final 关键字
2. 使用 instanceof 关键字
3. 使用 super 关键字
4. 使用 this 关键字
5. 使用 transient 关键字
6. 使用 with sharing、without sharing 和 inherited sharing 关键字 在类上使用 or 关键字
   指定是否必须强制执行共享规则。在类上使用关键字，以在调用该类的类的共享模式下运行该类。with sharing without sharing inherited sharing

使用 final 关键字

您可以使用关键字 修改变量。

final

• 最终变量只能赋值一次，无论是在声明变量时还是在 构造函数。您必须在以下两个位置之一为其赋值。
• 静态最终变量可以在静态初始化中更改 代码或定义的位置。
• 成员最终变量可以在初始化代码块中更改， 构造函数，或使用其他变量声明。
• 要定义常量，请将变量标记为 和 。staticfinal
• 非最终静态变量用于在 类级别（例如触发器之间的状态）。然而，事实并非如此 在请求之间共享。
• 默认情况下，方法和类是最终的。不能在声明中使用关键字 的类或方法。这意味着它们不能被覆盖。如果需要覆盖，请使用关键字 方法或类。finalvirtua

使用 instanceof 关键字

如果需要在运行时验证对象是否实际上是 特定类，请使用关键字。 关键字只能用于 验证关键字右侧表达式中的目标类型是否可行 左侧表达式的声明类型的替代项。instanceofinstanceof您可以将以下检查添加到类中的类中，然后 将项目投射回对象之前的投射示例。

ReportCustomReport

If (Reports.get(0) instanceof CustomReport) {
    // Can safely cast it back to a custom report object
   CustomReport c = (CustomReport) Reports.get(0);
   } Else {
   // Do something with the non-custom-report.
}

注意

在使用 API 版本 32.0 及更高版本保存的 Apex 中，如果左操作数为 null 对象，则返回。为 示例，以下示例返回 。instanceoffalsefalse

Object o = null;
Boolean result = o instanceof Account;
System.assertEquals(false, result);

在 API 版本 31.0 及更早版本中，在本例中返回。instanceoftrue

使用 super 关键字

关键字可以 由从虚拟类或抽象类扩展而来的类使用。 通过使用 ，可以覆盖 父类中的构造函数和方法。supersuper例如，如果您有以下虚拟类：

public virtual class SuperClass {
    public String mySalutation;
    public String myFirstName;
    public String myLastName;

    public SuperClass() {

        mySalutation = 'Mr.';
        myFirstName = 'Carl';
        myLastName = 'Vonderburg';
    }

    public SuperClass(String salutation, String firstName, String lastName) {

        mySalutation = salutation;
        myFirstName = firstName;
        myLastName = lastName;
    }

    public virtual void printName() {

        System.debug('My name is ' + mySalutation + myLastName);
    }

   public virtual String getFirstName() {
       return myFirstName;
   }
}

您可以创建以下类来扩展和重写其方法：

SuperclassprintName

public class Subclass extends Superclass {
  public override void printName() {
        super.printName();
        System.debug('But you can call me ' + super.getFirstName());
    }
}

调用时的预期输出为Subclass.printNameMy name is Mr. Vonderburg. But you can call me Carl.还可以用于调用构造函数。将以下构造函数添加到：

superSubClass

public Subclass() {
    super('Madam', 'Brenda', 'Clapentrap');
}

现在，预期的输出是Subclass.printNameMy name is Madam Clapentrap. But you can call me Brenda.

使用 super 关键字的最佳做法

• 只有扩展自 或 类的类才能使用 .virtualabstractsuper
• 只能在用关键字指定的方法中使用。superoverride

使用 this 关键字

有两种不同的使用关键字的方法。this

您可以使用关键字 以点表示法，不带括号，表示当前实例 它出现在哪个类中。使用这种形式的关键字来访问实例变量 和方法。例如：thisthis

public class myTestThis {

string s;
  {
      this.s = 'TestString';
  }
}

在上面的示例中，该类声明了一个实例变量。初始化代码填充 使用 关键字的变量。myTestThissthis

或者你可以使用关键字来做构造函数链接，即在一个构造函数中， 调用另一个构造函数。在此格式中，使用带括号的关键字。为 例：thisthis

public class testThis {

// First constructor for the class. It requires a string parameter.
   public testThis(string s2) {
   }

// Second constructor for the class. It does not require a parameter.
// This constructor calls the first constructor using the this keyword.
   public testThis() {
       this('None');
   }
}

当您使用关键字时 在构造函数中，要执行构造函数链接，它必须是第一个 语句。this

使用 transient 关键字

使用关键字声明实例 无法保存且不应作为视图状态的一部分传输的变量 用于 Visualforce 页面。为 例：

transient

Transient Integer currentTotal;

您还可以在 Apex 中使用关键字 可序列化的类，即在控制器、控制器扩展或类中 实现 or 接口。此外，还可以在定义类型的类中使用 在可序列化类中声明的字段。transientBatchableSchedulabletransient

将变量声明为缩减视图 状态大小。关键字的一个常见用例是 Visualforce 页面上的字段，该字段仅在页面持续时间内需要 请求，但不应是页面视图状态的一部分，并且会使用过多的系统 在请求期间要多次重新计算的资源。transienttransient

某些 Apex 对象会自动被视为瞬态对象，也就是说，它们的值不会 保存为页面视图状态的一部分。这些对象包括：

• 页面引用
• XmlStream 类
• 集合自动标记为暂时性，仅当它们的对象类型 保留会自动标记为暂时性保留，例如保存点的集合
• 大多数对象由系统方法生成，例如 .Schema.getGlobalDescribe
• JSONParser类实例。

静态变量也不会得到 通过视图状态传输。

以下示例包含一个 Visualforce 页面和一个自定义控制器。点击 页面上的“刷新”按钮使瞬态日期为 已更新，因为每次刷新页面时都会重新创建它。非瞬态 date 继续具有其原始值，该值已从视图中反序列化 状态，所以它保持不变。

<apex:page controller="ExampleController">
  T1: {!t1} <br/>
  T2: {!t2} <br/>
  <apex:form>
    <apex:commandLink value="refresh"/>
  </apex:form>
</apex:page>

public class ExampleController {

    DateTime t1;
    transient DateTime t2;

    public String getT1() {
        if (t1 == null) t1 = System.now();
        return '' + t1;
    }

    public String getT2() {
        if (t2 == null) t2 = System.now();
        return '' + t2;
    }
}

使用有共享、无共享和继承共享关键字

在类上使用 or 关键字来指定是否 必须强制执行共享规则。在类上使用关键字以在类的共享模式下运行该类 称其为。

with sharingwithout sharinginherited sharing

与共享

在声明 类来强制执行当前用户的共享规则。显式设置此关键字可确保 Apex 代码在当前用户上下文中运行。通过调用执行的 Apex 代码和 Apex 中的 Connect 始终执行 使用当前用户的共享规则。有关 的详细信息，请参阅匿名块。with sharingexecuteAnonymousexecuteAnonymous

在声明 类来强制执行适用于当前用户的共享规则。例如：with sharing

public with sharing class sharingClass {

   // Code here

}

无共享

在声明 类来确保不强制执行当前用户的共享规则。例如 当一个类从另一个类调用时，您可以显式关闭共享规则强制执行 使用 声明的类。without sharingwith sharing

public without sharing class noSharing {

   // Code here

}

继承共享

在声明 类来强制执行调用它的类的共享规则。使用是一种先进的技术来确定 运行时的共享模式，并设计可以在任一模式下运行的 Apex 类。inherited sharinginherited sharingwith sharingwithout sharing

警告

由于共享模式是在运行时确定的，因此必须采取极端措施 注意确保您的 Apex 代码可以安全地在两种模式下运行。with sharingwithout sharing将 一起使用 和其他 适当的安全检查，有助于通过 AppExchange 安全审查并确保 您的特权 Apex 代码不会以意外或不安全的方式使用。一个 Apex 类，其运行方式为：

inherited sharinginherited sharingwith sharing

• Aura 组件控制器
• Visualforce 控制器
• Apex REST 服务
• Apex 事务的任何其他入口点

标有 Apex 类和省略共享的类之间有明显的区别 声明。如果该类用作 Apex 事务的入口点，则省略 共享声明以 . 但是，确保默认 是以 .声明为 的类仅在从 已经建立的上下文。inherited sharingwithout sharinginherited sharingwith sharinginherited sharingwithout sharingwithout sharing

例

此示例声明一个 Apex 类，其中包含该 Apex 代码的 Visualforce 调用。由于声明，只有联系人 显示正在运行的用户具有共享访问权限。如果省略声明，请联系 由于不安全的默认值，用户没有查看权限 行为。

inherited sharinginherited sharing

public inherited sharing class InheritedSharingClass {
    public List<Contact> getAllTheSecrets() {
        return [SELECT Name FROM Contact];
    }
}

<apex:page controller="InheritedSharingClass">
    <apex:repeat value="{!allTheSecrets}" var="record">
        {!record.Name}
    </apex:repeat>
</apex:page>

实施细节

• 应用定义方法的类的共享设置，而不是 从中调用方法的类。例如，如果在类中定义了方法 声明为由类调用 声明为 ，方法 在强制执行共享规则的情况下执行。with sharingwithout sharing
• 如果类未显式声明为 either 或 ， 当前共享规则仍然有效。因此，该类不强制执行共享 规则，除非它从另一个类获取共享规则。例如，如果 类由另一个强制执行共享的类调用，然后强制执行共享 被调用的类。with sharingwithout sharing
• 内部类和外部类都可以声明为 。内部类不继承 共享容器类中的设置。否则，共享设置将应用于 类中包含的所有代码，包括初始化代码、构造函数和 方法。with sharing
• 当一个类扩展或 实现另一个。
• Apex 触发器不能具有显式共享声明，不能以 .without sharing

最佳实践

默认情况下，没有显式共享声明的 Apex 是不安全的。我们强烈建议 您始终为类指定共享声明。

无论采用何种共享模式，对象级访问和字段级安全性都不是 由 Apex 强制执行。您必须在 您的 SOQL 查询或代码。例如，机制不强制用户访问查看报表和 仪表 板。您必须显式强制执行正在运行的用户的 CRUD（创建、读取、更新、 Delete） 和代码中的字段级安全性。请参阅强制执行对象和字段权限。with sharing

接口就像一个类，其中没有任何方法 已实现 – 方法签名存在，但每个方法的主体为空。自 使用接口，另一个类必须通过为所有方法提供主体来实现它 包含在接口中。

接口可以为代码提供抽象层。他们分离特定的 从该方法的声明中实现方法。这样你就可以拥有 基于特定应用程序的方法的不同实现。

定义接口类似于定义新类。例如，一家公司可以有 两种类型的采购订单，一种来自客户，另一种来自客户 他们的员工。两者都是一种采购订单。假设您需要一种方法来 提供折扣。折扣金额可能取决于采购订单的类型。

您可以将采购订单的一般概念建模为接口，并具有特定的 为客户和员工实施。在以下示例中，焦点仅为 在采购订单的折扣方面。

下面是接口的定义。PurchaseOrder

// An interface that defines what a purchase order looks like in general
public interface PurchaseOrder {
    // All other functionality excluded
    Double discount();
}

此类实现接口 用于客户采购订单。PurchaseOrder

// One implementation of the interface for customers
public class CustomerPurchaseOrder implements PurchaseOrder {
    public Double discount() {
        return .05;  // Flat 5% discount
    }
}

此类实现接口 用于员工采购订单。PurchaseOrder

// Another implementation of the interface for employees
public class EmployeePurchaseOrder implements PurchaseOrder {
      public Double discount() {
        return .10;  // It’s worth it being an employee! 10% discount
      } 
}

请注意有关该示例的以下信息：

• 接口已定义 作为通用原型。接口中定义的方法无权访问 修饰符，并且只包含它们的签名。PurchaseOrder
• 班级 实现此接口;因此，它必须为方法提供定义。任何类 实现接口必须定义接口中包含的所有方法。CustomerPurchaseOrderdiscount

定义新接口时，就是在定义新的数据类型。您可以使用 接口名称：在任何地方都可以使用其他数据类型名称。分配给 interface 类型的变量必须是实现该接口的类的实例， 或子接口数据类型。

另请参见类和强制转换。

注意

在类之后，无法将方法添加到全局接口 在托管 – 已发布的包版本中上传。

版本化行为更改

在 API 版本 50.0 及更高版本中，范围和可访问性规则在 Apex 上强制执行 用 注释的变量、方法、内部类和接口。对于可访问性 注意事项，请参阅 NamespaceAccessible 注释。有关基于命名空间的可见性的详细信息，请参阅基于命名空间的可见性 适用于第二代软件包中的 Apex 类。@namespaceAccessible

1. 自定义迭代器

自定义迭代器

迭代器遍历集合中的每个项。例如，在 Apex 的循环中，您定义了一个 退出循环的条件，并且您必须提供一些遍历 集合，即迭代器。while在此示例中，每次循环 执行。

count

while (count < 11) {
   System.debug(count);
      count++;
   }

使用该界面，您可以创建自定义集 的指令，用于通过循环遍历列表。迭代器对数据很有用 存在于 Salesforce 之外的源中，您通常会定义其范围 使用语句。迭代器也可以是 如果有多个语句，则使用。IteratorSELECTSELECT

使用自定义 迭代器

自 使用自定义迭代器时，必须创建一个实现接口的 Apex 类。Iterator该接口具有以下实例 方法：

Iterator

接口中的所有方法都必须声明为 或 。Iteratorglobalpublic您只能在循环中使用自定义迭代器。为 例：

while

IterableString x = new IterableString('This is a really cool test.');

while(x.hasNext()){
   system.debug(x.next());
}

循环中目前不支持迭代器。

for

将自定义迭代器与 Iterable 一起使用

如果 您不想将自定义迭代器与列表一起使用，而是希望创建 自己的数据结构，可以使用接口生成数据结构。Iterable该接口具有以下方法：

Iterable

该方法必须是 声明为 或 。它创建对迭代器的引用 然后，您可以使用它来遍历数据结构。iteratorglobalpublicIn the following example a custom iterator iterates through a collection:

public class CustomIterator
   implements Iterator<Account>{ 
 
   private List<Account> accounts;
   private Integer currentIndex;
 
   public CustomIterator(List<Account> accounts){
       this.accounts = accounts;
       this.currentIndex = 0;
   }
 
   public Boolean hasNext(){ 
       return currentIndex < accounts.size();
   }    
 
   public Account next(){
       if(hasNext()) {
           return accounts[currentIndex++];
       } else {
           throw new NoSuchElementException('Iterator has no more elements.');
       }
   } 
}

public class CustomIterable implements Iterable<Account> {
   public Iterator<Account> iterator(){
      List<Account> accounts =
      [SELECT Id, Name,
       NumberOfEmployees 
       FROM Account
       LIMIT 10];
      return new CustomIterator(accounts);
   }
}

下面是一个批处理作业，它使用 迭 代：

public class BatchClass implements Database.Batchable<Account>{
   public Iterable<Account> start(Database.BatchableContext info){
       return new CustomIterable();
   }
   public void execute(Database.BatchableContext info, List<Account> scope){
       List<Account> accsToUpdate = new List<Account>();
       for(Account acc : scope){
           acc.Name = 'changed';
           acc.NumberOfEmployees = 69;
           accsToUpdate.add(acc);
       }
       update accsToUpdate;
   }
   public void finish(Database.BatchableContext info){
   }
}

与 Java 一样，您可以在 Apex Class中创建类。类是用于创建对象的模板或蓝图。对象是类的实例。

例如，该类描述整个购买 订单，以及您可以使用采购订单执行的所有操作。类的实例是特定的采购订单 您发送或接收的内容。PurchaseOrderPurchaseOrder

所有对象都有状态和行为，即 对象知道自己，以及对象可以做的事情。状态 PurchaseOrder 对象（它所知道的对象）包括发送它的用户、日期 以及它的创建时间，以及它是否被标记为重要。行为 PurchaseOrder 对象（它可以做什么）包括检查库存、发货 产品，或通知客户。

类可以包含变量和方法。变量用于指定 对象，例如对象的 或 .由于这些变量与 类并且是它的成员，它们通常被称为成员 变量。方法用于控制行为，例如 或 。NameTypegetOtherQuotescopyLineItems

类可以包含其他类、异常类型和初始化代码。

接口就像一个类，其中没有一个 方法已实现 – 方法签名在那里，但 每个方法都是空的。要使用接口，另一个类必须通过提供 接口中包含的所有方法的主体。

有关类、对象和接口的更多常规信息，请参阅 http://java.sun.com/docs/books/tutorial/java/concepts/index.html

除了类之外，Apex 还提供触发器、 类似于数据库触发器。触发器是执行的 Apex 代码 在数据库操作之前或之后。请参阅触发器。

1. Apex 类定义
2. 类变量
3. 类方法
4. 使用构造函数
5. 访问修饰符
6. 静态和实例方法、变量和初始化代码
   在 Apex 中，您可以拥有静态方法、变量和初始化代码。但是，Apex 类不能是静态的。还可以具有实例方法、成员变量和初始化代码（没有修饰符）和局部变量。
7. Apex 属性
8. 扩展类
   可以扩展类以提供更专业的行为。
9. 扩展类示例

Apex 类定义

在 Apex 中，您可以定义顶级类（也称为外部类）以及内部类， 也就是说，在另一个类中定义的类。内部类只能有一个级别深。为 例：

public class myOuterClass {
   // Additional myOuterClass code here
   class myInnerClass {
     // myInnerClass code here
   }
}

若要定义类，请指定以下内容：

1. 访问修饰符：
   • 您必须在顶级的声明中使用访问修饰符之一（如 或 ） 类。publicglobal
   • 不必在内部类的声明中使用访问修饰符。
2. 可选的定义修饰符（如 、 等）virtualabstract
3. 必需：关键字后跟类名称class
4. 可选扩展或实现，或两者兼而有之

注意

避免对类名使用标准对象名。这样做 导致意外结果。有关标准对象的列表，请参阅 Salesforce 的对象参考。

使用以下语法定义类：

private | public | global 
[virtual | abstract | with sharing | without sharing] 
class ClassName [implements InterfaceNameList] [extends ClassName] 
{ 
// The body of the class
}

• access 修饰符声明此类是 仅在本地知道，即仅通过这部分代码知道。这是默认设置 内部类的访问权限 – 也就是说，如果未指定访问修饰符 对于内部类，它被认为是 .此关键字只能与内部类（或 标有注解的顶级测试类）。privateprivate@IsTest
• 访问修饰符 声明此类在应用程序或命名空间中可见。public
• access 修饰符声明此类是 所有 Apex 代码都广为人知。global所有班级 包含用关键字定义的方法必须声明为 。如果方法或内部类是 声明为 ，外部， 顶级类也必须定义为 。webserviceglobalglobalglobal
• 和关键字指定此类的共享模式。欲了解更多信息， 请参阅使用有共享、无共享和继承共享关键字。with sharingwithout sharing
• 定义修饰符声明此 类允许扩展和覆盖。不能使用关键字重写方法，除非类 已定义为 。virtualoverridevirtual
• 定义 modifier 声明此类包含抽象方法， 是，只声明其签名而不定义主体的方法。abstract

注意

• 在将抽象方法上传到全局类后，无法将抽象方法添加到全局类中 托管 – 已发布的包版本。
• 如果“托管 – 已发布”包中的类是虚拟的，则可以向其添加的方法 还必须是虚拟的，并且必须具有实现。
• 不能重写已安装的全局类的公共或受保护的虚拟方法 托管包。

有关托管包的详细信息，请参阅什么是包？。

一个类可以实现多个接口，但只能扩展一个现有类。此限制 表示 Apex 不支持多重继承。列表中的接口名称 用逗号分隔。有关接口的详细信息，请参阅接口。

有关方法和变量访问修饰符的更多信息，请参见访问修饰符。

类变量

若要声明变量，请指定以下内容：

• 可选：修饰符，例如 或 ，以及 。publicfinalstatic
• 必需：变量的数据类型，例如 String 或 Boolean。
• 必需：变量的名称。
• 可选：变量的值。

定义 变量：

[public | private | protected | global] [final] [static] data_type variable_name 
[= value]

例如：

private static final Integer MY_INT; 
      private final Integer i = 1;

版本化行为更改

在 API 版本 50.0 及更高版本中，范围和可访问性规则强制执行 带注释的 Apex 变量、方法、内部类和接口 跟。为 辅助功能注意事项，请参阅 NamespaceAccessible 注释。有关基于命名空间的可见性的详细信息， 请参阅基于命名空间 第二代软件包中 Apex 类的可见性。@namespaceAccessible

类方法

若要定义方法，请指定以下内容：

• 可选：修饰符，例如 或 .publicprotected
• 必需：方法返回的值的数据类型，例如 String 或 整数。如果方法不使用，请使用 返回一个值。void
• 必需：方法的输入参数列表，用逗号分隔，每个参数 前面是其数据类型，并括在括号中。如果没有参数，请使用 空括号。一个方法只能有 32 个输入参数。()
• 必需：方法的主体，用大括号括起来。该方法的所有代码，包括 此处包含任何局部变量声明。{}

定义 方法：

[public | private | protected | global] [override] [static] data_type method_name 
(input parameters) 
{
// The body of the method
}

注意

您可以使用 仅在已定义为 或 的类中覆盖方法。overridevirtualabstract例如：

public static Integer getInt() { 
     return MY_INT; 
  }

与 Java 一样，返回值的方法也可以作为语句运行，如果其结果 未分配给其他变量。用户定义的方法：

• 可以在使用系统方法的任何地方使用。
• 可以是递归的。
• 可能会产生副作用，例如初始化 sObject 记录 ID 的 DML 语句。请参阅 Apex DML 语句。insert
• 可以引用它们自己或稍后在同一类中定义的方法，或者 匿名块。Apex 分两个阶段解析方法，因此 forward 声明 不需要。
• 可以是多态性的。例如，可以通过两种方式实现名为的方法，一种是使用单个 Integer 参数，一个包含两个 Integer 参数。取决于方法是否 调用一个或两个整数，Apex 解析器选择适当的 要执行的实现。如果解析器找不到完全匹配，则 使用类型强制规则寻求近似匹配。欲了解更多信息 数据转换，详见 转换。example注意如果解析器找到多个近似匹配项，则 生成解析时异常。
• 具有 void 返回类型的方法通常作为独立语句调用 在 Apex 代码中。为 例：System.debug('Here is a note for the log.');
• 可以有返回值作为语句运行的语句，如果它们的 结果不会分配给其他变量。此规则在 Java 中相同。

按值传递方法参数

在 Apex 中，所有原始数据类型参数，例如 Integer 或 String，按值传递到方法中。这一事实意味着对 参数仅存在于方法的范围内。当方法 返回时，对参数的更改将丢失。

非基元数据类型参数（如 sObjects）是 通过引用传递到方法中。因此，当该方法返回时， 传入的参数仍引用与方法调用之前相同的对象。 在该方法中，不能更改引用以指向另一个对象，但 可以更改对象字段的值。

以下是传递基元和非基元数据类型参数的示例 into 方法。

示例：传递基元数据类型参数此示例演示如何将 String 类型的基元参数按值传递到 另一种方法。此示例中的方法创建一个 String 变量 ， 和 为其赋值。然后，它将此变量作为参数传递给另一个方法， 修改此 String 的值。但是，由于 String 是基元类型， 它是按值传递的，当方法返回时，原始的值 变量 ， 保持不变。assert 语句验证 的价值仍然是旧的 价值。

debugStatusMessagemsgmsgmsg

public class PassPrimitiveTypeExample {
    public static void debugStatusMessage() {
        String msg = 'Original value';
        processString(msg);
        // The value of the msg variable didn't
        // change; it is still the old value.
        System.assertEquals(msg, 'Original value');
    }
    
    public static void processString(String s) {
        s = 'Modified value';
    }
}

示例：传递非基元数据类型参数

此示例演示如何通过引用将 List 参数传递到方法中并对其进行修改。然后 在方法中，显示 不能将 List 参数更改为指向另一个 List 对象。reference()referenceNew()一、方法 创建一个变量 ，该变量是整数列表并传递 它变成了一种方法。调用的方法使用表示的整数值填充此列表 四舍五入的温度值。当该方法返回时，assert 语句将验证 原始 List 变量的内容已更改，现在包含五个 值。接下来，该示例创建第二个 List 变量 ，并将其传递给另一个方法。调用的方法 将传入的参数分配给新创建的包含新 Integer 的 List 值。当方法返回时，原始变量 不指向新列表，但仍指向原始列表，该列表为空。 assert 语句验证不包含 值。

createTemperatureHistoryfillMecreateMecreateMecreateMe

public class PassNonPrimitiveTypeExample {
    
    public static void createTemperatureHistory() {
        List<Integer> fillMe = new List<Integer>();        
        reference(fillMe);
        // The list is modified and contains five items
        // as expected.
        System.assertEquals(fillMe.size(),5);        
        
        List<Integer> createMe = new List<Integer>();
        referenceNew(createMe);
        // The list is not modified because it still points
        // to the original list, not the new list 
        // that the method created.
        System.assertEquals(createMe.size(),0);     
    }
            
    public static void reference(List<Integer> m) {
        // Add rounded temperatures for the last five days.
        m.add(70);
        m.add(68);
        m.add(75);
        m.add(80);
        m.add(82);
    }    
        
    public static void referenceNew(List<Integer> m) {
        // Assign argument to a new List of
        // five temperature values.
        m = new List<Integer>{55, 59, 62, 60, 63};
    }    
}

版本化行为更改

在 API 版本 50.0 及更高版本中，范围和可访问性规则在 Apex 上强制执行 用 注释的变量、方法、内部类和接口。对于可访问性 注意事项，请参阅 NamespaceAccessible 注释。有关基于命名空间的可见性的详细信息，请参阅基于命名空间的可见性 适用于第二代软件包中的 Apex 类。@namespaceAccessible

使用构造函数

构造函数是从类创建对象时调用的代码 蓝图。您不需要为每个类编写构造函数。如果一个类没有 用户定义的构造函数，使用默认的、无参数的公共构造函数。

构造函数的语法类似于方法，但有所不同 从方法定义，因为它从来就没有显式返回类型 并且它不会被从它创建的对象继承。编写类的构造函数后，必须使用关键字才能实例化 该类中的对象，使用该构造函数。例如，使用 以下类：

new

public class TestObject {

   // The no argument constructor 
   public TestObject() {
      // more code here
  }
}

可以使用以下命令实例化此类型的新对象 法典：

TestObject myTest = new TestObject();

如果编写一个接受参数的构造函数，则可以使用该构造函数创建一个 对象。

如果创建接受参数的构造函数，并且仍希望使用无参数 构造函数，则必须在代码中创建自己的无参数构造函数。创建 构造函数，则您不再有权访问默认的无参数公共 构造 函数。在 Apex 中，构造函数可以重载，也就是说，可以 一个类的多个构造函数，每个构造函数都有不同的参数。 下面的示例演示一个具有两个构造函数的类：一个 没有参数，并且采用简单的 Integer 参数。它 还阐释了一个构造函数如何使用 语法，也 称为构造函数链接。

this(…)

public class TestObject2 {

private static final Integer DEFAULT_SIZE = 10;

Integer size;

   //Constructor with no arguments
   public TestObject2() {
       this(DEFAULT_SIZE); // Using this(...) calls the one argument constructor    
   }

   // Constructor with one argument 
   public TestObject2(Integer ObjectSize) {
     size = ObjectSize;  
   }
}

可以使用以下命令实例化此类型的新对象 法典：

TestObject2 myObject1 = new TestObject2(42);
  TestObject2 myObject2 = new TestObject2();

为类创建的每个构造函数都必须具有不同 参数列表。在下面的示例中，所有构造函数都是 可能：

public class Leads {

  // First a no-argument constructor 
  public Leads () {}

  // A constructor with one argument
  public Leads (Boolean call) {}

  // A constructor with two arguments
  public Leads (String email, Boolean call) {}

  // Though this constructor has the same arguments as the 
  // one above, they are in a different order, so this is legal
  public Leads (Boolean call, String email) {}
}

定义新类时，就是在定义新的数据类型。 您可以在任何可以使用其他数据类型名称的地方使用类名， 例如 String、Boolean 或 Account。如果定义一个变量，其 type 是一个类，分配给它的任何对象都必须是 该类或子类。

访问修饰符

Apex 允许您使用 、 、 和 access 修饰符 定义方法和变量时。privateprotectedpublicglobal

虽然触发器和匿名块也可以使用这些访问修饰符，但它们在 Apex 的较小部分。例如，将方法声明为匿名块中的方法并不能调用 它来自该代码的外部。global

有关类访问修饰符的更多信息，请参见 Apex 类定义。

注意

接口方法没有访问修饰符。它们始终是全球性的。有关详细信息，请参阅接口。

默认情况下，方法或变量仅对定义中的 Apex 代码可见 类。显式指定方法或变量为公共方法或变量，以便将其指定为 public 可用于同一应用程序命名空间中的其他类（请参阅命名空间前缀）。您可以更改 使用以下访问修饰符的可见性级别：private此访问修饰符是默认值，表示 方法或变量只能在定义它的 Apex 类中访问。 如果未指定访问修饰符，则方法或变量为 .privateprotected这意味着该方法或变量对 定义 Apex 类，以及扩展定义 Apex 类的类。您可以 仅将此访问修饰符用于实例方法和成员变量。此设置 严格来说，它比默认（私有）设置更宽松，就像 Java 一样。public这表示方法或变量可供所有人访问 特定包中的 Apex。适用于所有第二代 （2GP） 共享命名空间的托管包与注释一起使用。在 no-namespace 包将 Apex 代码隐式呈现为 @NamespaceAccessible。public@NamespaceAccessible

注意

在 Apex 中，访问 modifier 与 Java 中的修饰符不同。这样做是为了阻止加入 应用程序，以将每个应用程序的代码分开。在 Apex 中，如果您愿意 要像在 Java 中那样公开某些内容，必须使用 access 修饰符。publicglobal有关基于命名空间的可见性的详细信息，请参阅基于命名空间的可见性 适用于第二代软件包中的 Apex 类。global这表示该方法或变量可以由任何 Apex 代码使用 可以访问该类，而不仅仅是同一应用程序中的 Apex 代码。这 访问修饰符必须用于必须在 应用程序，无论是在 SOAP API 中还是通过其他 Apex 代码。如果声明方法或 变量为 ，您还必须声明 以 .globalglobal

注意

我们建议很少使用访问修饰符（如果有的话）。跨应用程序 依赖关系难以维护。global

要使用 、 、 或 access 修饰符，请使用 语法如下：privateprotectedpublicglobal

[(none)|private|protected|public|global] declaration

例如：

// private variable s1
private string s1 = '1';

// public method getsz()
public string getsz() { 
   ... 
}

静态和实例方法、变量和初始化 法典

在 Apex 中，您可以拥有静态方法、变量和初始化 法典。但是，Apex 类不能是静态的。还可以具有实例方法、成员变量和初始化代码（没有修饰符）和局部变量。

特性

静态方法、变量和初始化代码具有这些特征。

• 它们与类相关联。
• 它们只允许在外部类中使用。
• 它们仅在加载类时初始化。
• 它们不会作为 Visualforce 页面视图状态的一部分进行传输。

实例方法、成员变量和初始化代码具有这些 特性。

• 它们与特定对象相关联。
• 它们没有定义修饰符。
• 它们是使用从它们所在的类实例化的每个对象创建的 宣布。

局部变量具有这些特征。

• 它们与声明它们的代码块相关联。
• 在使用它们之前，必须对其进行初始化。

下面的示例演示一个局部变量，其作用域是代码块的持续时间。if

Boolean myCondition = true;
if (myCondition) {
    integer localVariable = 10;
}

使用静态方法和变量

只能将静态方法和变量用于外部类。内部类有 没有静态方法或变量。静态方法或变量不需要 类的实例。

在创建类的对象之前，类中的所有静态成员变量都是 初始化，并执行所有静态初始化代码块。这些项目是 按照它们在类中出现的顺序进行处理。

静态方法用作实用程序方法，它从不依赖于 实例成员变量。因为静态方法只与类相关联， 它无法访问其类的实例成员变量值。

静态变量仅在 Apex 事务范围内是静态的。 它不是整个服务器或整个组织的静态。a 的值 静态变量在单个事务的上下文中保留并重置 跨越事务边界。例如，如果 Apex DML 请求导致触发器 若要多次触发，静态变量会在这些触发器中保留 调用。

若要存储跨类实例共享的信息，请使用静态 变量。同一类的所有实例共享静态的单个副本 变量。例如，单个事务生成的所有触发器都可以通信 通过查看和更新相关类中的静态变量来相互关联。一个 递归触发器可以使用类变量的值来确定何时退出 递归。

假设您有以下类。

public class P { 
   public static boolean firstRun = true; 
}

然后，使用此类的触发器可能会选择性地使 触发。

trigger T1 on Account (before delete, after delete, after undelete) { 
       if(Trigger.isBefore){
          if(Trigger.isDelete){
             if(p.firstRun){
                 Trigger.old[0].addError('Before Account Delete Error');
                  p.firstRun=false;
              } 
           }
        }
}

触发器中定义的静态变量不会在不同 同一事务中的触发上下文，例如在插入之前和 插入调用后。相反，在类中定义静态变量，以便 触发器可以访问这些类成员变量并检查其静态变量 值。

无法通过类的实例访问类静态变量。如果类有一个静态变量，并且是 的实例，则不是合法的表达式。MyClassmyStaticVariablemyClassInstanceMyClassmyClassInstance.myStaticVariable

实例方法也是如此。如果是静态方法，则不合法。相反，请参考那些 使用类的静态标识符： 和 .myStaticMethod()myClassInstance.myStaticMethod()MyClass.myStaticVariableMyClass.myStaticMethod()局部变量名在类名之前计算。如果局部变量具有 与类同名，局部变量隐藏了 同名。例如，如果注释掉该行，则此方法有效。但是，如果包含该行，则该方法不会 compile，因为 Salesforce 报告该方法不存在或具有 不對 签名。

StringString

public static void method() {
String Database = '';
Database.insert(new Account());
}

内部类的行为类似于静态 Java 内部类， 但不需要关键字。 内部类可以像外部类一样具有实例成员变量，但 没有指向外部类实例的隐式指针（使用 关键字）。staticthis

注意

在 API 版本 20.0 及更早版本中，如果批量 API 请求导致触发器触发， 触发器要处理的 200 条记录的每个块被拆分为 100 条记录的块 记录。在 Salesforce API 版本 21.0 及更高版本中，不再拆分 API 区块 发生。如果批量 API 请求导致触发器多次触发 200 条记录，调控器限制在这些触发器调用之间重置 相同的 HTTP 请求。

使用实例方法和变量

实例方法和成员变量由类的实例使用，即 一个对象。实例成员变量在类中声明，但不在类中声明 方法。实例方法通常使用实例成员变量来影响 方法的行为。

假设您希望有一个收集二维点和绘图的类 它们在图表上。下面的框架类使用成员变量来保存列表 的点和一个内部类来管理二维点列表。

public class Plotter {

    // This inner class manages the points
    class Point {
        Double x;
        Double y;

        Point(Double x, Double y) {
             this.x = x;
             this.y = y;
        }
        Double getXCoordinate() {
             return x;
        }

        Double getYCoordinate() {
             return y;
        }
    }

    List<Point> points = new List<Point>();

    public void plot(Double x, Double y) {
        points.add(new Point(x, y));
    }
    
    // The following method takes the list of points and does something with them
    public void render() {
    }
}

使用初始化代码

实例初始化代码是定义以下形式的代码块 在课堂上。

{ 

   //code body

}

每次对象执行时，都会执行类中的实例初始化代码 从该类实例化。这些代码块在构造函数之前运行。

如果不想为类编写自己的构造函数，可以使用实例 初始化代码块，用于初始化实例变量。在简单的情况下， 使用普通的初始值设定项。为复杂情况保留初始化代码， 例如初始化静态映射。静态初始化块只运行一次， 不管您访问包含它的类多少次。

静态初始化代码是以关键字 开头的代码块。static

static {

   //code body

}

与其他静态代码类似，静态初始化代码块仅初始化 第一次使用类时一次。

一个类可以具有任意数量的静态或实例初始化代码块。 它们可以出现在代码正文中的任何位置。代码块按以下顺序执行 它们出现在文件中，就像它们在 Java 中一样。

您可以使用静态初始化代码来初始化静态最终变量，并 声明静态信息，例如值映射。例如：

public class MyClass {
 
    class RGB {

        Integer red;
        Integer green;
        Integer blue;

        RGB(Integer red, Integer green, Integer blue) {
            this.red = red;
            this.green = green;
            this.blue = blue;
        }
     }

   static Map<String, RGB> colorMap = new Map<String, RGB>();

    static {
        colorMap.put('red', new RGB(255, 0, 0));
        colorMap.put('cyan', new RGB(0, 255, 255));
        colorMap.put('magenta', new RGB(255, 0, 255));
    }
}

版本化行为更改

在 API 版本 50.0 及更高版本中，范围和可访问性规则在 Apex 上强制执行 用 注释的变量、方法、内部类和接口。对于可访问性 注意事项，请参阅 NamespaceAccessible 注释。有关基于命名空间的可见性的详细信息，请参阅基于命名空间的可见性 适用于第二代软件包中的 Apex 类。@namespaceAccessible

Apex 属性

Apex 属性类似于变量; 但是，您可以在代码中对属性值执行其他操作，然后再将其 访问或返回。属性可用于在更改之前验证数据 made，用于在数据发生更改时提示操作（例如更改其他值 成员变量），或公开从其他源检索到的数据（例如 作为另一个类）。属性定义包括一个或两个代码块，表示 get 访问器和 SET 访问器：

• get 访问器中的代码在读取属性时执行。
• 当为属性分配新值时，将执行 set 访问器中的代码。

如果属性只有 get 访问器，则将其视为只读。如果属性只有 set 访问器，则将其视为只写。考虑具有两个访问器的属性 读写。

若要声明属性，请在类的主体中使用以下语法：

Public class BasicClass {

   // Property declaration
   access_modifier return_type property_name {
      get {
         //Get accessor code block
      }
      set {
         //Set accessor code block
      }
   } 
}

哪里：

• access_modifier是属性的访问修饰符。这 可应用于属性的访问修饰符包括：、、 和 。此外，这些定义 可以应用修饰符：和 。有关访问的更多信息 修饰符，请参阅 Access 修饰符。publicprivateglobalprotectedstatictransient
• return_type是属性的类型，例如 Integer、Double、 sObject 等。有关详细信息，请参阅数据类型。
• property_name是属性的名称

例如，下面的类定义了一个名为 的属性。该物业是公共的。该属性返回整数数据类型。prop

public class BasicProperty {
   public integer prop {
      get { return prop; }
      set { prop = value; }
   }
}

下面的代码段调用 BasicProperty 类，执行 get 和 set 访问：

BasicProperty bp = new BasicProperty();
bp.prop = 5;                   // Calls set accessor
System.assertEquals(5, bp.prop);   // Calls get accessor

请注意以下事项：

• get 访问器的主体类似于方法的主体。它必须返回值 属性类型。执行 get 访问器与读取 变量。
• get 访问器必须以 return 语句结尾。
• 建议 get 访问器不要更改其对象的状态 定义上。
• set 访问器类似于返回类型为 void 的方法。
• 为属性赋值时，将使用参数调用 set 访问器 这提供了新的价值。
• 在 API 版本 42.0 及更高版本中，除非在 set 访问器中设置了变量值，否则 无法在 GET 访问器中更新其值。
• 调用 set 访问器时，系统会将隐式参数传递给 setter 调用的数据类型与 财产。value
• 不能在接口上定义属性。
• Apex 属性基于 C# 中的对应属性，但存在以下差异：
  • 属性直接为值提供存储。您无需创建 支持用于存储值的成员。
  • 可以在 Apex 中创建自动属性。有关详细信息，请参阅使用自动属性。

使用自动属性

属性不需要在其 get 或 set 访问器代码块中使用其他代码。 相反，您可以将 get 和 set 访问器代码块留空以定义自动属性。自动属性允许您编写更多内容 紧凑的代码，更易于调试和维护。它们可以声明为 只读、读写或只写。以下示例创建三个自动 性能：

public class AutomaticProperty {
   public integer MyReadOnlyProp { get; }
   public double MyReadWriteProp { get; set; }
   public string MyWriteOnlyProp { set; }
}

以下代码段练习这些属性：

AutomaticProperty ap = new AutomaticProperty();
ap.MyReadOnlyProp = 5;                 // This produces a compile error: not writable
ap.MyReadWriteProp = 5;                // No error
System.assertEquals(5, ap.MyWriteOnlyProp);   // This produces a compile error: not readable

使用静态属性

当属性声明为 时， 属性的访问器方法在静态上下文中执行。因此，访问器不会 有权访问类中定义的非静态成员变量。以下 示例创建一个同时具有静态属性和实例属性的类：static

public class StaticProperty {
   private static integer StaticMember;
   private integer NonStaticMember;

   // The following produces a system error
   // public static integer MyBadStaticProp { return NonStaticMember; }

   public static integer MyGoodStaticProp { 
     get {return StaticMember;} 
     set { StaticMember = value; } 
   }  
   public integer MyGoodNonStaticProp { 
     get {return NonStaticMember;} 
     set { NonStaticMember = value; } 
   } 
}

以下代码段调用静态属性和实例属性：

StaticProperty sp = new StaticProperty();
// The following produces a system error: a static variable cannot be
// accessed through an object instance
// sp.MyGoodStaticProp = 5;

// The following does not produce an error
StaticProperty.MyGoodStaticProp = 5;

在属性上使用访问修饰符 访问

可以使用自己的访问修饰符定义属性访问器。如果访问器 包含它自己的访问修饰符，这个修饰符覆盖了 财产。单个访问器的访问修饰符必须更具限制性 而不是属性本身的访问修饰符。例如，如果属性具有 被定义为 ，个人 访问器不能定义为 。这 以下类定义显示了其他示例：publicglobal

global virtual class PropertyVisibility {
   // X is private for read and public for write
   public integer X { private get; set; }
   // Y can be globally read but only written within a class
   global integer Y { get; public set; }
   // Z can be read within the class but only subclasses can set it
   public integer Z { get; protected set; }
}

扩展类

您可以扩展类以提供更专业的行为。

扩展另一个类的类继承了 扩展类。此外，扩展类可以覆盖现有的虚拟类 方法，方法是在方法定义中使用 override 关键字。覆盖虚拟 方法允许您为现有方法提供不同的实现。这 表示特定方法的行为因对象而异 你正在召唤它。这称为多态性。

一个类使用类定义中的关键字扩展另一个类。一个类只能扩展另一个类，但它可以 实现多个接口。extends

此示例演示类如何 扩展类。运行继承 示例 在本节中，首先创建类。YellowMarkerMarkerMarker

public virtual class Marker {
    public virtual void write() {
        System.debug('Writing some text.');
    }

    public virtual Double discount() {
        return .05;
    }
}

然后创建类，该类扩展 类。YellowMarkerMarker

// Extension for the Marker class
public class YellowMarker extends Marker {
    public override void write() {
        System.debug('Writing some text using the yellow marker.');
    } 
}

此代码段显示多态性。该示例声明两个相同类型的对象 ().即使两个对象都是 标记，则将第二个对象分配给类的实例。因此，在其上调用该方法会产生与 在第一个对象上调用此方法，因为此方法已被重写。 但是，您可以在 第二个对象，即使此方法不是类定义的一部分。但它是扩展类的一部分，并且 因此，可用于扩展类 .在 Execute Anonymous 窗口中运行此代码段 开发 人员 安慰。

MarkerYellowMarkerwritediscountYellowMarkerYellowMarker

Marker obj1, obj2;
obj1 = new Marker();
// This outputs 'Writing some text.'
obj1.write();

obj2 = new YellowMarker();
// This outputs 'Writing some text using the yellow marker.'
obj2.write();
// We get the discount method for free
// and can call it from the YellowMarker instance.
Double d = obj2.discount();

扩展类可以具有更多与原始类不常见的方法定义 扩展类。在此示例中，该类扩展了该类，并具有一个额外的类 方法，不适用于 类。要调用额外的方法，请 对象类型必须是扩展类。RedMarkerMarkercomputePriceMarker

在运行下一个代码段之前，请创建该类，这需要组织中的类。RedMarkerMarker

// Extension for the Marker class
public class RedMarker extends Marker {
    public override void write() {
        System.debug('Writing some text in red.');
    } 

    // Method only in this class
    public Double computePrice() {
        return 1.5;
    }
}

此代码片段演示如何对类调用其他方法。在“执行”中运行此代码片段 开发者控制台的匿名窗口。RedMarker

RedMarker obj = new RedMarker();
// Call method specific to RedMarker only
Double price = obj.computePrice();

扩展也适用于接口 – 一个接口可以扩展另一个接口。如 使用类，当一个接口扩展另一个接口时，所有方法和 扩展接口的属性可用于扩展接口。

版本化行为更改

在 API 版本 50.0 及更高版本中，范围和可访问性规则在 Apex 上强制执行 用 注释的变量、方法、内部类和接口。对于可访问性 注意事项，请参阅 NamespaceAccessible 注释。有关基于命名空间的可见性的详细信息，请参阅基于命名空间的可见性 适用于第二代软件包中的 Apex 类。@namespaceAccessible

扩展类示例

下面是一个类的扩展示例，显示了所有 Apex 类的功能。示例中介绍的关键字和概念是 在本章中进行了更详细的解释。

// Top-level (outer) class must be public or global (usually public unless they contain
// a Web Service, then they must be global)
public class OuterClass {

  // Static final variable (constant) – outer class level only
  private static final Integer MY_INT;

  // Non-final static variable - use this to communicate state across triggers
  // within a single request)
  public static String sharedState;
  
  // Static method - outer class level only
  public static Integer getInt() { return MY_INT; }

  // Static initialization (can be included where the variable is defined)
  static {
    MY_INT = 2; 
  }

  // Member variable for outer class
  private final String m;

  // Instance initialization block - can be done where the variable is declared, 
  // or in a constructor
  {
    m = 'a';  
  }
  
  // Because no constructor is explicitly defined in this outer class, an implicit, 
  // no-argument, public constructor exists

  // Inner interface
  public virtual interface MyInterface { 

    // No access modifier is necessary for interface methods - these are always 
    // public or global depending on the interface visibility
    void myMethod(); 
  }

  // Interface extension
  interface MySecondInterface extends MyInterface { 
    Integer method2(Integer i); 
  }

  // Inner class - because it is virtual it can be extended.
  // This class implements an interface that, in turn, extends another interface.
  // Consequently the class must implement all methods.
  public virtual class InnerClass implements MySecondInterface {

    // Inner member variables
    private final String s;
    private final String s2;

    // Inner instance initialization block (this code could be located above)
    {
       this.s = 'x';
    }

    // Inline initialization (happens after the block above executes)
    private final Integer i = s.length();
 
    // Explicit no argument constructor
    InnerClass() {
       // This invokes another constructor that is defined later
       this('none');
    }

    // Constructor that assigns a final variable value
    public InnerClass(String s2) { 
      this.s2 = s2; 
    }

    // Instance method that implements a method from MyInterface.
    // Because it is declared virtual it can be overridden by a subclass.
    public virtual void myMethod() { /* does nothing */ }

    // Implementation of the second interface method above.
    // This method references member variables (with and without the "this" prefix)
    public Integer method2(Integer i) { return this.i + s.length(); }
  }

  // Abstract class (that subclasses the class above). No constructor is needed since
  // parent class has a no-argument constructor
  public abstract class AbstractChildClass extends InnerClass {

    // Override the parent class method with this signature.
    // Must use the override keyword
    public override void myMethod() { /* do something else */ }

    // Same name as parent class method, but different signature.
    // This is a different method (displaying polymorphism) so it does not need
    // to use the override keyword
    protected void method2() {}

    // Abstract method - subclasses of this class must implement this method
    abstract Integer abstractMethod();
  }

  // Complete the abstract class by implementing its abstract method
  public class ConcreteChildClass extends AbstractChildClass {
    // Here we expand the visibility of the parent method - note that visibility 
    // cannot be restricted by a sub-class
    public override Integer abstractMethod() { return 5; }
  }

  // A second sub-class of the original InnerClass
  public class AnotherChildClass extends InnerClass {
    AnotherChildClass(String s) {
      // Explicitly invoke a different super constructor than one with no arguments
      super(s);
    }
  }
  
  // Exception inner class
  public virtual class MyException extends Exception {
    // Exception class member variable
    public Double d;

    // Exception class constructor    
    MyException(Double d) {
      this.d = d;
    }
    
    // Exception class method, marked as protected
    protected void doIt() {}
  }
  
  // Exception classes can be abstract and implement interfaces
  public abstract class MySecondException extends Exception implements MyInterface {
  }
}

此代码示例演示：

• 顶级类定义（也称为外部类)
• 顶级类中的静态变量和静态方法，作为 以及静态初始化代码块
• 顶级类的成员变量和方法
• 没有用户定义构造函数的类 — 这些类具有 隐式、无参数构造函数
• 顶级类中的接口定义
• 扩展另一个接口的接口
• 顶级类中的内部类定义（一级深度）
• 实现接口（因此，其关联的接口）的类 子接口）来实现方法签名的公共版本
• 内部类构造函数定义和调用
• 内部类成员变量以及使用关键字对它的引用（不带参数）this
• 一个内部类构造函数，它使用关键字（带参数）来 调用其他构造函数this
• 构造函数之外的初始化代码 — 其中 定义变量，以及大括号中的匿名块 ().请注意，这些执行 每个构造都按照它们在文件中出现的顺序出现，如 爪哇岛。{}
• 类扩展和抽象类
• 重写基类方法（必须声明）的方法virtual)
• 关键字 对于重写子类方法的方法override
• 抽象方法及其通过具体子类的实现
• 交通 修饰语protected
• 作为具有成员、方法和构造函数的第一类对象的异常

此示例演示其他 Apex 代码如何调用上述类：

// Construct an instance of an inner concrete class, with a user-defined constructor
OuterClass.InnerClass ic = new OuterClass.InnerClass('x');

// Call user-defined methods in the class
System.assertEquals(2, ic.method2(1));

// Define a variable with an interface data type, and assign it a value that is of 
// a type that implements that interface
OuterClass.MyInterface mi = ic;

// Use instanceof and casting as usual
OuterClass.InnerClass ic2 = mi instanceof OuterClass.InnerClass ? 
                            (OuterClass.InnerClass)mi : null;
System.assert(ic2 != null);

// Construct the outer type
OuterClass o = new OuterClass();
System.assertEquals(2, OuterClass.getInt());

// Construct instances of abstract class children
System.assertEquals(5, new OuterClass.ConcreteChildClass().abstractMethod());

// Illegal - cannot construct an abstract class
// new OuterClass.AbstractChildClass();

// Illegal – cannot access a static method through an instance
// o.getInt();

// Illegal - cannot call protected method externally
// new OuterClass.ConcreteChildClass().method2();

此代码示例演示：

• 外层阶级的构造
• 内部类的构造和内部类的声明 接口类型
• 可以为声明为接口类型的变量分配一个实例 实现该接口的类
• 将接口变量转换为实现 该接口（使用运算符验证后）instanceof

ref

Apex 提供了 if-else 语句、switch 语句和循环来控制 代码执行。语句通常按照它们出现的顺序逐行执行。 使用控制流语句，可以根据某个条件使 Apex 代码执行， 或者让代码块重复执行。

• 条件 （If-else） 语句 Apex 中的条件语句
  的工作方式与 Java 类似。
• Switch 语句 Apex 提供了一个语句
  ，用于测试表达式是否与多个值之一匹配，并相应地分支。switch
• Loops
  Apex 支持五种类型的过程循环。

条件 （If-else） 语句

Apex 中的条件语句的工作方式与 Java 类似。

if ([Boolean_condition]) 
    // Statement 1
else
    // Statement 2

该部分始终是可选的，并且始终是可选的 具有最接近 .为 例：

elseif

Integer x, sign;
// Your code
if (x <= 0) if (x == 0) sign = 0; else sign = -1;

是 等效 自：

Integer x, sign;
// Your code
if (x <= 0) {
    if (x == 0) {
           sign = 0; 
    } else  {
           sign = -1;
    }
}

重复语句也是允许的。 为 例：

else if

if (place == 1) {
    medal_color = 'gold';
} else if (place == 2) {
    medal_color = 'silver';
} else if (place == 3) {
    medal_color = 'bronze';
} else {
    medal_color = null;
}

Switch 语句

Apex 提供了一个测试 表达式是否与多个值之一匹配，并相应地进行分支。

switch

语法为：

switch on expression {
    when value1 {		// when block 1
        // code block 1
    }	
    when value2 {		// when block 2
        // code block 2
    }
    when value3 {		// when block 3
        // code block 3
    }
    when else {		  // default block, optional
        // code block 4
    }
}

该值可以是单个值，也可以是多个值 值或 sObject 类型。例如：when

when value1 {
}

when value2, value3 {
}

when TypeName VariableName {
}

该语句计算表达式和 执行匹配值的代码块。如果没有匹配的值，则代码 块被执行。如果没有阻止，则不执行任何操作。switchwhenwhen elsewhen else

注意

没有落差。执行代码块后，语句将退出。switchApex 语句表达式可以是以下表达式之一 以下类型。

switch

• 整数
• 长
• s对象
• 字符串
• 枚举

当阻止

每个块都有一个值，即 expression 是匹配的。这些值可以采用以下形式之一。when

• when {} （a when 块可以有 多个逗号分隔的文字子句）literal
• 当 SObjectTypeidentifier {}
• 什么时候enum_value {}

该价值对所有人来说都是合法的价值 类型。null

每个值必须是唯一的。例如 您只能在一个块子句中使用文本。一个块最多匹配一次。whenxwhenwhen

何时 Else 阻止

如果没有值与表达式匹配，则执行该块。whenwhen else

注意

Salesforce 建议包含块，尤其是枚举类型，尽管这不是必需的。 使用枚举生成语句时 托管包提供的值，则代码可能无法按预期方式运行，如果 新版本的包包含其他枚举值。您可以防止这种情况发生 问题，包括一个块 处理意外值。when elseswitchwhen else

如果包含块，则它必须是 语句中的最后一个块。when elseswitch

文本示例

您可以使用文本值进行切换 在 Integer、Long 和 String 类型上。字符串子句区分大小写。例如 “orange”与“ORANGE”的值不同。when

单值示例

下面的示例对值使用整数文本。when

switch on i {
   when 2 {
       System.debug('when block 2');
   }
   when -3 {
       System.debug('when block -3');
   }
   when else {
       System.debug('default');
   }
}

Null 值示例

由于 Apex 中的所有类型都可以为 null，因此值可以为 .whennull

switch on i {
   when 2 {
       System.debug('when block 2');
   }
   when null {
       System.debug('bad integer');
   }
   when else {
       System.debug('default ' + i);
   }
}

多值示例

Apex 语句没有 回退，但子句可以包括 要匹配的多个文本值。您还可以嵌套 Apex 语句以提供多个执行 子句中的路径。switchwhenswitchwhen

switch on i {
   when 2, 3, 4 {
       System.debug('when block 2 and 3 and 4');
   }
   when 5, 6 {
       System.debug('when block 5 and 6');
   }
   when 7 {
       System.debug('when block 7');
   }
   when else {
       System.debug('default');
   }
}

方法示例

以下示例不是打开变量表达式，而是打开 方法调用的结果。

switch on someInteger(i) {
   when 2 {
       System.debug('when block 2');
   }
   when 3 {
       System.debug('when block 3');
   }
   when else {
       System.debug('default');
   }
}

sObjects 示例

通过打开 sObject 值，可以隐式执行检查和强制转换。例如 请考虑以下使用 if-else 语句的代码。instanceof

if (sobject instanceof Account) {
    Account a = (Account) sobject;
    System.debug('account ' + a);
} else if (sobject instanceof Contact) {
    Contact c = (Contact) sobject;
    System.debug('contact ' + c);
} else {
    System.debug('default');
}

您可以使用以下语句替换和简化此代码。switch

switch on sobject {
   when Account a {
       System.debug('account ' + a);
   }
   when Contact c {
       System.debug('contact ' + c);
   }
   when null {
       System.debug('null');
   }
   when else {
       System.debug('default');
   }
}

注意

每个块只能使用一种 sObject 类型。when

枚举示例

使用枚举值的语句不需要块，但建议这样做。您可以 每个块使用多个枚举值 第。switchwhenwhen elsewhen

switch on season {
   when WINTER {
       System.debug('boots');
   }
   when SPRING, SUMMER {
       System.debug('sandals');
   }
   when else {
       System.debug('none of the above');
   }
}

循环

Apex 支持五种类型的过程循环。支持以下类型的过程循环：

• do {statement} while (Boolean_condition);
• while (Boolean_condition) statement;
• for (initialization; Boolean_exit_condition; increment) statement;
• for (variable : array_or_set) statement;
• for (variable : [inline_soql_query]) statement;

所有环路都允许环路控制结构：

• break;退出整个循环
• continue;跳到下一个迭代 的循环

1. Do-While 循环
2. While 循环
3. For 循环

Do-While 循环

Apex 循环重复执行 代码块，只要特定的布尔条件保持为真。其语法 是：

do-while

do {
   code_block
} while (condition);

注意

大括号 （） 是 始终需要围绕 .{} code_block

与 Java 一样，Apex 循环没有 检查布尔条件语句，直到执行第一个循环之后。 因此，代码块始终至少运行一次。do-while例如，以下代码将数字 1 – 10 输出到调试中 日志：

Integer count = 1;

do {
    System.debug(count);
    count++;
} while (count < 11);

While 循环

Apex 循环重复执行一个块 只要特定的布尔条件保持为真。其语法 是：

while

while (condition) {
    code_block
}

注意

仅当块包含多个大括号 （） 时，才需要在 a 周围加上大括号 （） 陈述。{} code_block

与 不同的是，循环检查布尔条件语句 在执行第一个循环之前。因此，代码块可以 从不执行。do-whilewhile例如，以下代码将数字 1 – 10 输出到调试中 日志：

Integer count = 1;

while (count < 11) {
    System.debug(count);
    count++;
}

For 循环

Apex 支持循环的三种变体：

for

• 传统循环：forfor (init_stmt; exit_condition; increment_stmt) { code_block }
• 列表或设置迭代循环：forfor (variable : list_or_set) { code_block }其中必须是相同的基元或 sObject 类型为 。 variable list_or_set
• SOQL 循环：forfor (variable : [soql_query]) { code_block }或for (variable_list : [soql_query]) { code_block }两者必须属于相同的 sObject 类型 返回的 . variable variable_list soql_query

注意

仅当块包含多个大括号 （） 时，才需要在 a 周围加上大括号 （） 陈述。{} code_block

以下各节将进一步讨论每种方法。

• 传统 For 循环
• 列出或设置循环的迭代
• 迭代集合

传统 For 循环

Apex 中的传统循环对应于 Java 和其他语言中使用的传统语法。其语法 是：

for

for (init_stmt; exit_condition; increment_stmt) {
    code_block
}

执行此类循环时，Apex 运行时引擎按顺序执行以下步骤：

for

1. 执行循环的组件。请注意， 可以在此语句中声明和/或初始化多个变量。 init_stmt
2. 执行检查。如果为 true，则循环 继续。如果为 false，则循环退出。 exit_condition
3. 执行 . code_block
4. 执行语句。 increment_stmt
5. 返回到步骤 2。

例如，以下代码将数字 1 – 10 输出到调试日志中。注意 一个额外的初始化变量， 包含以演示语法：

j

for (Integer i = 0, j = 0; i < 10; i++) {
    System.debug(i+1);
}

列出或设置循环的迭代

列表或设置迭代循环循环 列表或集合中的所有元素。其语法 是：

for

for (variable : list_or_set) {
    code_block
}

其中必须具有相同的基元或 sObject 类型 如。

 variable list_or_set

执行此类循环时，Apex 运行时引擎将 分配给 中的每个元素，并运行 for each 值。for variable list_or_set code_block例如，以下代码将数字 1 – 10 输出到调试日志：

Integer[] myInts = new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

for (Integer i : myInts) {
    System.debug(i);
}

迭代集合

集合可以由列表、集合或地图组成。修改集合的 元素，而不支持循环访问该集合 并导致错误。请勿在以下情况下直接添加或删除元素 循环访问包含它们的集合。

在迭代期间添加元素

要添加 元素，在迭代列表、集合或映射时，保留新元素 在临时列表中，设置或映射并将它们添加到原始列表之后 完成循环访问。

在迭代期间删除元素

删除 元素，创建一个新列表，然后复制 您希望保留的元素。或者，添加您想要的元素 删除到临时列表并在完成迭代后将其删除 集合。

注意

该方法以线性方式执行。用它来删除元素有时间和 资源影响。List.remove

在迭代时删除元素 地图或集合，将要删除的键保存在临时列表中， 然后在完成循环访问集合后删除它们。

参考