Apex - Métodos

Métodos de clase

Hay dos modificadores para los métodos de clase en Apex: público o protegido. El tipo de retorno es obligatorio para el método y si el método no devuelve nada, debe mencionar void como el tipo de retorno. Además, Body también es necesario para el método.

Syntax

[public | private | protected | global]
[override]
[static]

return_data_type method_name (input parameters) {
   // Method body goes here
}

Explicación de la sintaxis

Los parámetros mencionados entre corchetes son opcionales. Sin embargo, los siguientes componentes son esenciales:

  • return_data_type
  • method_name

Modificadores de acceso para métodos de clase

Usando modificadores de acceso, puede especificar el nivel de acceso para los métodos de clase. Por ejemplo, se podrá acceder al método público desde cualquier lugar de la clase y fuera de ella. El método privado será accesible solo dentro de la clase. Global será accesible para todas las clases de Apex y se puede exponer como un método de servicio web accesible para otras clases de Apex.

Example

//Method definition and body
public static Integer getCalculatedValue () {
   
   //do some calculation
   myValue = myValue+10;
   return myValue;
}

Este método tiene un tipo de retorno como Integer y no toma ningún parámetro.

Un método puede tener parámetros como se muestra en el siguiente ejemplo:

// Method definition and body, this method takes parameter price which will then be used 
// in method.

public static Integer getCalculatedValueViaPrice (Decimal price) {
   // do some calculation
   myValue = myValue+price;
   return myValue;
}

Constructores de clases

Un constructor es un código que se invoca cuando se crea un objeto a partir del plano de la clase. Tiene el mismo nombre que el nombre de la clase.

No necesitamos definir el constructor para cada clase, ya que por defecto se llama a un constructor sin argumentos. Los constructores son útiles para la inicialización de variables o cuando se debe realizar un proceso en el momento de la inicialización de la clase. Por ejemplo, le gustará asignar valores a ciertas variables Integer como 0 cuando se llame a la clase.

Example

// Class definition and body
public class MySampleApexClass2 {
   public static Double myValue;   // Class Member variable
   public static String myString;  // Class Member variable

   public MySampleApexClass2 () {
      myValue = 100; //initialized variable when class is called
   }

   public static Double getCalculatedValue () { // Method definition and body
      // do some calculation
      myValue = myValue+10;
      return myValue;
   }

   public static Double getCalculatedValueViaPrice (Decimal price) {
      // Method definition and body
      // do some calculation
      myValue = myValue+price; // Final Price would be 100+100=200.00
      return myValue;
   }
}

También puede llamar al método de clase a través del constructor. Esto puede resultar útil al programar Apex para el controlador de fuerza visual. Cuando se crea el objeto de clase, se llama al constructor como se muestra a continuación:

// Class and constructor has been instantiated
MySampleApexClass2 objClass = new MySampleApexClass2();
Double FinalPrice = MySampleApexClass2.getCalculatedValueViaPrice(100);
System.debug('FinalPrice: '+FinalPrice);

Constructores de sobrecarga

Los constructores pueden estar sobrecargados, es decir, una clase puede tener más de un constructor definido con diferentes parámetros.

Example

public class MySampleApexClass3 {  // Class definition and body
   public static Double myValue;   // Class Member variable
   public static String myString;  // Class Member variable

   public MySampleApexClass3 () {
      myValue = 100; // initialized variable when class is called
      System.debug('myValue variable with no Overaloading'+myValue);
   }

   public MySampleApexClass3 (Integer newPrice) { // Overloaded constructor
      myValue = newPrice; // initialized variable when class is called
      System.debug('myValue variable with Overaloading'+myValue);
   }

      public static Double getCalculatedValue () { // Method definition and body
      // do some calculation
      myValue = myValue+10;
      return myValue;
   }

   public static Double getCalculatedValueViaPrice (Decimal price) {
      // Method definition and body
      // do some calculation
      myValue = myValue+price;
      return myValue;
   }
}

Puede ejecutar esta clase como la hemos ejecutado en el ejemplo anterior.

// Developer Console Code
MySampleApexClass3 objClass = new MySampleApexClass3();
Double FinalPrice = MySampleApexClass3.getCalculatedValueViaPrice(100);
System.debug('FinalPrice: '+FinalPrice);