Thursday 7 August 2014

Object-Oriented Programming in Apex

1.      Classes
2.      Properties
3.      Encapsulation
4.      Polymorphism and Inheritance
5.      Virtual Class
6.      Abstract class
7.      Interfaces 

Classes

  • A class is a template or blueprint from which objects are created.
  • They consist of methods and attributes
  • Are stored with the version of API that is used to compile it
  • May contain other classes, known as inner classes (but these can only be one level deep)
  • Even though Apex code is not case sensitive, it is recommended that you follow the Java naming convention
  • Static methods and attributes can only be declared in a top-level class definition
  • To create new exception classes, the Exception class must be extended
  • Classes can be enabled or disabled for profiles.
Ways to Create Classes
  • Through the UI:
    • Go to Setup -> Develop and Apex Classes.
    • Click “New” or “Generate from WSDL”
    • Enter code or upload a WSDL
  • Through a Force.com IDE project:
    • Right-click the src folder and click New -> Apex Class (this is the recommended way)
Class Syntax:
private | public | global
[virtual  | abstract | with sharing | without sharing | (none)]
Class ClassName [implements InterfaceNameList | (none)] [extends ClassOrInterfaceName | (none}] {
// The body of the class
}
Example
public class myOuterClass {
            // Additional myOuterClass code here
            class myInnerClass {
                                    // myInnerClass code here
            }
}

  • If global, the class is accessible everywhere. This must be used with the webService keyword. All methods, attributes and inner classes that are global must be within a global class
  • If public, the class is visible across the application, org or namespace that comprises the class.
  • If private is used for an inner class, the inner class is only accessible to the outer class. The default for inner classes is private.
  • Top level or outer classes must have either a global or public keyword.
  • A class can implement multiple interfaces, but it can only extend once class
  • A class can cast as a superclass and verify an objects class using the instanceof keyword
  • You can implement and extend classes using the keywords, virtual, abstract and extends
    • Virtual declares that the class allows extensions and overrides, Classes that are virtual cannot be global.
    • Abstract declares that the class contains abstract methods and can be extended. These classes just have a method signature and do not have code. You cannot instantiate an object of an abstract class until some other class extends it.
    • The Extends keyword declares that the class is a subclass. The “super” keyword can be used to invoke constructors and methods from the parent class.
  • All Apex code executes in the system mode and ignores all CRUD, field-level security and record sharing level privileges. You use with and without sharing keywords to implement sharing. By default a class will run in the without sharing mode.
    • With sharing – This means that when performing DML operations, the user can only update records to which he or she has edit level access
    • Without Sharing – This ensures that sharing model access is ignored and is referred to a running in system mode.
  • Interfaces are classes that only include the method signature. The methods are not implemented in the interfaces. Apex supports both top-level and inner interfaces
  • Avoid using standard object names for class names. Doing so causes unexpected results

Properties/ Attributes Syntax


Properties are the shortened form of a method that has access to static and instance variable.
modifiers dataType attributeName initialization;
For example:
public static final Integer MAX_AMOUNT = 200;
 private Integer cost;
public Integer getcost() { return cost; }
public void setcost(Integer cost) { this.cost=cost; }
  // Variable as Property
 public Integer cost { get { return cost; }  set { this.cost= cost;}}
  //Variable as Automatic Property
public Integer cost { get; set; }

//read-only and write - only Property
public Integer readOnly { get; private set;}
public Integer wrtieOnly { private get; set;}

 Methods Syntax:

Modifiers returnDataType methodName (inputParameterList) {
// method code
}
For example:
Public Integer getInt() {
Return myInt;
}
 Method and Attribute Access Modifiers
  • Private – Default access modifier, but is not available for top-level classes. It implies that the attribute or method is only available in the class where it is defined.
  • Protected – Available only to inner classes
  • Public – Can be used by an apex code in the application, org or namespace
  • Global – Accessible by all Apex everywhere. Note that Apex code cannot be shared between orgs, with the exception of Web Services, which are accessible to everyone.
Static Methods and Attributes
  • Static methods are accessed through the class itself and do not depend on an instance of a class
  • Static attributes are used to store data that is used within the class. They can be used to prevent recursive logic by setting flags.
Constants
  • Assign a value to a constant only once either at declaration or initialization
  • Define a constant using both the static and final keywords.
Instantiating Objects
  • Allows you to work with methods and attributes that are not defined as static
  • After instantiating, you can refer to methods and attributes using the dot notation. For example:
TestObject myObject1 = new TextObject();
myObject1.myMethod();
  • A constructor is a special method used to create an object of a class. It has the same name as the class and is the first method invoked in the class. It does not have an explicit return type and is available by default in each class as invisible and without parameters. It can be overloaded by defining multiple constructors with different parameters.
The “this” Keyword
  • With dot Notation – Used to represent the current instance of the class and can call methods or set attributes that are public or are available.
  • With Constructors – Developers can do constructor chaining by using the this keyword, but the this keyword must be the first statement in the constructor.
Apex System-Delivered Classes
  • System Class – Is a static class that contains only static methods. Includes the following:
    • Debug()
    • Now()
    • Today()
    • Assert()
    • AssertEquals()
    • AssertNotEquals()
  • UserInfo Class – Mostly getter methods used to get details. For example:
    • getUserId()
    • getUserName()
    • getUserRoleId()
    • getFirstName()
    • getLocale()
    • getLanguage()
Apex Workflow and Approval Processing
  • Apex process classes are used to submit workflow requests and process the results of those requests. The three classes provided are:
    • ProcessRequest – Used to process the results from a workflow process
    • ProcessSubmitRequest – Used to submit a workflow item for approval
    • ProcessWorkItemRequest – Used to process an item after it is submitted

Encapsulation

When a class is defined it becomes a new data type in Apex
public class MyClass()
{
    MyClass c  = new MyClass();
    List<MyClasss> myList = new List<MyClass>();
    myList.add(c);
}


Polymorphism and Inheritance

Apex supports single inheritance, it allows to extend one other class and implement many interfaces. Interface can also extend multiple interfaces 
 Over-riding methods is two step process
  • Parent class must provide virtual and abstract keyword on the methods to be over-ridden
  • In subclass, the override keyword is used on virtual and abstract methods to replace parent.
In Salesforce Non-virtual and non-abstract type cannot be extended.

Virtual Class

Virtual classes do not require any methods to be overriden and can be constructed as is without the need of extending. 
// SubClass with Method Override
 public virtual class myParentClass {
public virtual void dosomething(){
 System.Debug('Something');
            }
}
 public class myclass extends myParentClass{
 public override void dosomething(){
 super.dosomething();
 System.Debug('something else');
}
 new myclass().dosomething();
 }

Abstract class

Abstract classes can contain methods that don't require an override and methods that do require an override, since it can contain methods that do require and override it must be extended to be constructed.  Useful if you want to share code among several closely related classes that implement a common interface
public abstract class TestRow {
    public Double value;
    public virtual Double getValue() {
        return value==null ? 0 : value;
    }
    public void setValue(Double value) {
        this.value = value;
    }
}
public class SummaryTestRow extends TestRow {
    private list<TestRow> childRows;
    public override Double getValue() {
        Double totalValue = 0;
        for(TestRow childRow : childRows){
            totalValue += childRow.value;
        }
        return totalValue; 
    }

}

 

Interfaces 

Interface as skeletal class definitions containing list of methods with no implementations
//Declaring and using Interface
 public interface myInterface {
  void doSomething (String thing);
}
 public class MyClass implements MyInterface {
 public void doSomething(String x);
 }


Posted by at

2 comments:

Subscribe to: Post Comments (Atom)