What is an application package.
What is an application class.
Object oriented concepts.
Understanding application packages &classes.
Process for creating packages and classes in Application designer.
Application class structure.
How to use this packages and classes in people code.(import declaration).
Definition of methods.
Abstract methods and properties.
Get/set methods &read only read write.
Application package is a container for application subpackages and
application classes, which will provide a hierarchical structure to your
People Code programs and help you extend the common functionality of
existing People Code classes (Rowset, Array, and so on) from one
application to another.
App Class is a People Code Program at base level
Application classes are mainly used for reusability.
Application classes people code supports object oriented programming.
i .e it supports:
Classes and Objects.
Class is a blueprint of the object .It consists of variable and methods.
class doesn’t occupy any memory.
ex: Class is a map for building the house.
Object is a real entity any thing physically exists in the world is called an object.
But in programming languages object is instance of a class .It occupies some
ex: Object is house.
It’s came from the word capsule . It is a property to bind the variable and
methods and also it hides the internal structure. It prevents clients from
seeing the inside view. We can achieve abstraction through encapsulation.
ex : car driver doesn’t know what is the functionality when gear is changed
one level to another level . But he change the gear against to the speed.
Abstraction is process it allows to show the essential object information to the user i.e
hide the non essential object information. We can achieve this through encapsulation.
It is one of the most important feature of Object Oriented Programming. It is the
concept that is used for reusability purpose. Inheritance is the mechanism through which
we can derived classes from other classes. The derived class is called as child class or
subclass. The class from which the subclass is derived is called a superclass (also
a base class or a parent class).
A method having different forms is called polymorphism i.e method having the same
name but we can perform different tasks by using this polymorphism.
We have to concepts here
Application classes have a fully qualified name that is formed
hierarchically by the name of the top-level package. It means we can give
the same name of different classes but the fully qualified name of the class
must be unique.
Here ex1 fully qualified name ‘ A. class’ is different from ex2
Import MY_TEST : MyFormulaCruncher;
Local MY_TEST : MyFormulaCruncher & My_Nbr = create MY_TEST :
Local number &Result;
&Result = &My _ Nbr.AddNumbers(2, 1);
Before calling any method in a class you must import the package.
You can create Application Packages in Application Designer.
These packages contain application classes (and may contain other
packages also). An application class, at its base level, is just a People Code
program. However, using the Application Packages, you can create your
own classes, and extend the functionality of the existing People Code
Easier to debug because all the pieces are separate
Easier to maintain because functionality is gathered into a single place
Extensible by subclass.
Declaration of public external interface
Declaration variables and methods
Definition of methods
method AddNumbers(&a As number, &b As number) Returns number;
property number FirstNumber;
property number SecondNumber;
property number MySum readonly;
property number MySumProtected;
Local number &c;
&c = &a + &b;
MessageBox(0, "", 0, 0, "My AddNumbers result is: " | &c);
&MySum = &FirstNumber + &SecondNumber;
&MySumProtected = &FirstNumber + &SecondNumber;
MessageBox(0, "", 0, 0, "My AddNumbers2 result is: " | &MySumProtected);
Conventional data types include number, date, string. Use them for basic
computing. Object data types instantiate objects from PeopleTools class.
Conventional data types.
Object data types.
It is nothing but inheritance. We can extend the properties and
methods of one class into another class using ‘extends’ key word
property number FruitNum instance;
class Banana extends Fruit
property number BananaNum instance;
A subclass inherits all of the public methods and properties of the class it
extends. These members can be overridden by declarations of methods and
properties in the subclass.
Note. Application classes have no multiple inheritance
We can control the access by public , private, protected access specifiers.
ex: class A
property number a1;
method number a1;
property number a2;
method number a2;
property number a3;
method number a3;
The system never skips to the next top-level statement.
Pass parameters by value.
Parameter passing with object data types is by reference.
Application programs use the out specifier to pass a parameter by
Note : Application class properties are always passed by value .
Passing Parameters with Object Data Types value and reference:
Parameters with object data types are always passed by reference
method myMethod(&arg as MyObjectClass);
/*method myMethod(&arg as MyObjectClass out);
Local MyObjectClass &o1 = create MyObjectClass("A");
Local MyOtherObjectClass &o2 = create MyOtherObjectClass();
&arg = create MyObjectClass("B");
note : Since the method argument is reassigned within the body of
myMethod, &o1 does not point at the new instance of MyObjectClass
Passing variable by value and reference
/* argument passed by reference */
method increment(&value as number out);
/* argument passed by value */:
method increment(&value as number);
method DoAdd(&P1 as number, &P2 as number out);
&X = &P1 + &P2;
&P1 = 1;
&P2 = 2;
local AddStuff &Aref = Create AddStuff();
local number &I = 10;
local number &J = 20;
&Aref.DoAdd(&I, &J); /* changes &J but not &I */
&Aref.DoAdd(10, 20); /* error - second argument not variable */
method MyMethod1() abstract;
method MyMethod2() Returns string abstract;
property string myproperty1 abstract readonly;
property number myproperty2 abstract;
property number myproperty3 abstract;
Considerations using abstract methods:
You cannot have private abstract methods.
You will receive an error if you try to provide a method body for an
The method signatures must be identical between the abstract method
definition and the method implementation in the derived.
Defining an application class which is totally composed of abstract
methods and properties is called interface it avoids the problem in multiple
method MyMethod2() Returns string;
property string myproperty1 readonly;
property number myproperty2;
property number myproperty3;
When you provide an implementation for an Interface you can also
use the keyword Implements instead of Extends
The constructor for a class is the public method with the same name as the
(short name of the) class. The statements contained in this method (if any)
provide the initialization of the class.
This constructor is always executed when an object of the class is
This section describes the naming standards for:
classes:do not name classes to be Getxxx
Here any import classes having same short name we must use full
name of the class for creating or initiating object to that class.
A method can refer to the current object using the %This system variable.
%This is an object of either the method's class or a subclass of the method's
method factorial(&I as number) returns number;
if &I <= 1 then
return &I * factorial(&I - 1); /* error - factorial undefined */
return &I * %This.factorial(&I - 1); /* okay */
A method can refer to a member of its superclass by using the
%Super system variable. This construction is needed only to access
superclass members that are hidden by overriding members in the current
/* some body*/
class VancouverBuilding extends BuildingAsset
%Super.DisasterPrep(); /* call superclass method */
local BuildingAsset &Building = Create VancouverBuilding();
property string StringProp get set;
return "string"; /* Get the value from somewhere. */
/* Do something with &NewValue. */
A property of a superclass can be overridden by a subclass
property number Anum;
property string Astring get;
property string Astring2 get;
class B extends A
property number Anum;
local B &B = Create B();
&B.Anum = 2;
&MyValue = &B.Astring; /* &MyValue is "2" */
&MyValue = &B.Astring2; /* &MyValue is now "0" */
PeopleCode read-only properties are functionally similar to static
variables, as long as the class that defines the properties initializes them
and does not change them. The difference is that you need an instance of
the class to access them.
property number a1 read only;
Application classes can contain collections. Collections of objects
generally have at least the following methods and properties.
Count (as a property)
Overriding variables and properties.
Use the Exception class to do exception handling in your PeopleCode .
This class provides a try, catch, and throw mechanism so you don't need to
check after each operation for errors.
Exception class: This class contained
try /* Code to manipulate &MyArray here */
&MyArray = GetArrayData(&Param1, &Param2, &Param3);
catch ExceptionNull &Ex1
If &Ex1.MessageSetNumber = 2 and &Ex1.MessageNumber = 236 Then
&ex; Function t1(&i As integer) Returns number
Local number &res = &i / 0;
End-Function; Function t2 throw
CreateException (2, 160, "'%1' doesn't support property or method '%2'", "SomeClass", "SomeMethod");
try t2 ();
Local number &res = t1 (2);
Catch Exception &caugh
t MessageBox (0, "", 0, 0, "Caught exception: " | &caught.ToString());
Application classes can be instantiated only from PeopleCode.
These classes can be used anywhere you have PeopleCode, that is, in
message notification PeopleCode , Component Interface PeopleCode,
record field PeopleCode, and so on.
This section discusses some ways you can design application classes.
Base data classes
Abstract base classes
Generic base classes
Internal comments, which start with /* and end with */.
Comments for methods.
Comments for classes.
@ author name.