What is the difference between Lookup relationship & Master detail relationship?

Look up relationship:

  • Parent field on child can be required or optional choice.
  • No impact on security and access.
  • If we delete parent record then child records are not deleted.
  • No limit to number of layers.
  • Up to 25 allowed for an object.
  • We can change parent object for child object.
  • Roll-up summary field is not allowed.

Master – Detail Relationship:

  • Parent field on child is required.
  • Access to parent determines access to children.
  • Deleting parent automatically delete children.
  • Limited number of layers.
  • Up to 2 allowed for an object.
  • We can’t change the parent object for child object once create. The only way is killing the both objects.
  • Roll-up summary field is allowed.

Pass variable to a custom label from visualforce page

To know more about custom label Click here
Step 1:
Go to Setup –> App Setup –> Custom Labels.
Step 2:

1

Step 3:
Here for dynamic populate custom label variable value, the custom label value has written like this “My name is {0} {1}”.

2

Step 4:
Now I’ll create an apex controller with two variable to send it custom label.

public class TestCustomLabel{
    public string FirstName{get;set;}
    public string LastName{get;set;}    
     
    public TestCustomLabel(){
        FirstName = 'Biswajeet';
        LastName = 'Samal';
    }
}

Step 5:
Now I’ll create a visualforce page and use the custom label with parameters in it. Here the first parameter “FirstName” is for custom label “{0}” and the second parameter “LastName” is for custom label “{1}”.

<apex:page controller="TestCustomLabel" tabstyle="Account">
    <apex:form>
        <apex:pageblock>
            <apex:outputtext value="{!$Label.TestCustomLabel}">
            <apex:param value="{!FirstName}">
            <apex:param value="{!LastName}">
            </apex:param></apex:param></apex:outputtext>
        </apex:pageblock>
    </apex:form>
</apex:page>

Here is the visualforce page output:

3

Custom label in visualforce page and apex Class

Custom labels are custom text values that can be accessed from Apex classes or Visualforce pages. The value of Custom label can be static or dynamic from visulaforce page and apex class. The values can be translated into any language Salesforce supports. Custom labels enable developers to create multilingual applications by automatically presenting information (for example, help text or error messages) in a user’s native language.
In this article I’ll demonstrate how to use custom labels in visualforce page and apex classes.

Note: We can create up to 5,000 custom labels for your organization, and they can be up to 1,000 characters in length.
Step 1:
Go to Setup –> App Setup –> Custom Labels.
Step 2:

download
Step 3:

2

Step 4:
Now I’ll create a visualforce page and use the custom label in it.

<apex:page tabstyle="Account">
   <apex:form>
     <apex:pageblock>
       <apex:outputtext value="Custom lable value is : ">
       <apex:outputtext style="font-weight: bold;" value="{!$Label.DemoCustomLabel}">
     </apex:outputtext></apex:outputtext></apex:pageblock>
   </apex:form>
</apex:page>

Here is the visualforce page output:

3

Now get custom label value in apex class.

string  LabelText = System.Label.DemoCustomLabel;

Difference between Constant, Readonly and Static in C#

Constants:

  • Classes and structs can declare constants as members.
  • Constant fields or variables must be assigned a value at the time of declaration and after that they cannot be modified.
  • By default constant is static and we cannot change the value of a const variable throughout the entire program.
  • Constants can be marked as public, private, protected, internal, or protected internal access modifiers.

Readonly:

  • The readonly keyword is a modifier, which we can use on fields.
  • A readonly field can be initialized either at the time of declaration or with in the constructor of same class.
  • We can change readonly field value during runtime or we can assign it at run time but only through the non-static constructor.

Static:

  • The static modifier can be used with classes, fields, methods, properties, operators, events, and constructors, but it cannot be used with indexers, destructors, or types other than classes.
  • If the static keyword is applied to a class, all the members of the class must be static and Static methods can only access static members of same class.
  • Static properties are used to get or set the value of static fields of a class.
  • Static constructor can’t be parametrized. Access modifiers can not be applied on Static constructor, it is always a public default constructor which is used to initialize static fields of the class.

 

1 Star2 Stars3 Stars4 Stars5 Stars (2 votes, average: 5.00 out of 5)
Loading...

An Introduction to Apex class

index

Apex is a strongly-typed Object-Oriented Programming (OOP) language that executes on the Force.com platform. Apex is used to add business logic to applications, to write database triggers, and to program controllers in the user interface layer. It has a tight integration with the database and query language, good web services support, and includes features such as futures and governors for execution in a multi-tenant environment.

Apex Class:

  • A class is a template or blueprint from which objects are created.
  • It consist of methods and attributes.
  • It stored with the version of API that is used to compile it.
  • 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 to follow the Java naming convention.
  • Static methods and attributes can only be declared in a top-level class definition.
  • Apex classes can be enabled or disabled for profiles and can only be 100,000 characters in length.
  • When a class is defined it becomes a new data type in Apex.

Apex Class Syntax:

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

Apex allows to use the private, protected, public, and global access modifiers when defining classes, methods and variables. By default, a method or variable is visible only to the Apex code within the defining class. We must explicitly specify a method or variable as public in order for it to be available to other classes in the same application namespace. We can change the level of visibility by using the following access modifiers:

private – This is the default, and means that the method or variable is accessible only within the Apex class in which it is defined. If we do not specify an access modifier, the method or variable is private.

protected – This means that the method or variable is visible to any inner classes in the defining Apex class, and to the classes that extend the defining Apex class. We can only use this access modifier for instance methods and member variables.

public – This means the method or variable can be used by any Apex in this application or namespace.

global – This means the method or variable can be used by any Apex code that has access to the class, not just the Apex code in the same application. This access modifier should be used for any method that needs to be referenced outside of the application, either in the SOAP API or by other Apex code. If we declare a method or variable as global, we must also declare the class that contains it as global.

with sharing or without sharing:

  • We use the with sharing or without sharing keywords on a class to specify whether or not to enforce sharing rules.
  • The with sharing keyword allows to specify that the sharing rules for the current user be taken into account for a class.
  • We use the without sharing keywords when declaring a class to ensure that the sharing rules for the current user are not enforced.
  • If a class isn’t declared as either with or without sharing, the current sharing rules remain in effect, this means that if the class is called by a class that has sharing enforced, then sharing is enforced for the called class.
  • Both inner classes and outer classes can be declared as with sharing.
  • The sharing setting applies to all code contained in the class, including initialization code, constructors, and methods.
  • Inner classes do not inherit the sharing setting from their container class.
  • Classes inherit this setting from a parent class when one class extends or implements another.

virtual – The virtual definition modifier declares that this class allows extension and overrides. We cannot override a method with the override keyword unless the class has been defined as virtual. We cannot override a public or protected virtual method of a global class of an installed managed package.

Example of SubClass with Method Override:

public virtual class myParentClass {
 
 public myParentClass{
  //Constructor
 }
  
 public virtual void doSomething(){
  System.Debug('Do something'); 
 }
}
//Extension for the myParentClass class
public class myClass extends myParentClass{
 
 public myClass{
  //Constructor
 }
 
 public override void doSomething(){
   System.Debug('Do something else');
 } 
}

abstract – The abstract definition modifier declares that this class contains abstract methods, that is, methods that only have their signature declared and no body defined. Abstract class methods MUST be overridden. We cannot add an abstract method to a global class after the class has been uploaded in a Managed – Released package version. If the class in the Managed – Released package is virtual, the method that we can add to it must also be virtual and must have an implementation.

Example of Abstract class with abstract method and Override:

public abstract class myParentClass{
 
 public myParentClass{
  //Constructor
 }
  
 public virtual void doSomething(){
  System.Debug('Do something'); 
 }
 
 //Abstract method without body
 public abstract void myAbstractMethod();
}
//Extension for the myParentClass abstract class
public class myClass extends myParentClass{
 
 public myClass{
  //Constructor
 }
 
 public override void doSomething(){
   System.Debug('Do something else');
 }
 
 public override void myAbstractMethod(){
   System.Debug('Do something');
 } 
}

Interface – An interface is like a class in which none of the methods have been implemented, the method signatures are there, but the body of each method is empty. To use an interface, another class must implement it by providing a body for all of the methods contained in the interface.

Example of Interface and its implementation on class:

public interface myInterface{
 
 public void doSomething();
}
//This class implements the myInterface interface.
public class myClass implements myInterface{
 
 public myClass{
  //Constructor
 }
 
 public void doSomething(){
   System.Debug('Do something else');
 }
}