1. PRESENTED BY,
P.S.S.SWAMY.

2.  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).
 Access controls.
 Definition of methods.
 Abstract methods and properties.
 Interfaces.
 Constructors.
 Get/set methods &read only read write.
 Exception Handling.

3.  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.

4.  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.
Encapsulation.
Abstraction.
Polymorphism.
Inheritance.

5. Class :
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 :
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
memory.
ex: Object is house.
Encapsulation :
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.

6. Abstraction :
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.
Inheritance:
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).
Polymorphism :
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
1.method overloading.
2.method overriding.

7. 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.
ex :1.pack1A.class
2.pack1pack2A.class
Here ex1 fully qualified name ‘ A. class’ is different from ex2

8. Import MY_TEST : MyFormulaCruncher;
Local MY_TEST : MyFormulaCruncher & My_Nbr = create MY_TEST :
MyFormulaCruncher();
Local number &Result;
&Result = &My _ Nbr.AddNumbers(2, 1);
 Before calling any method in a class you must import the package.

9.  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
classes.
 Easier to debug because all the pieces are separate
 Easier to maintain because functionality is gathered into a single place
 Extensible by subclass.

11.  Import class
 Class name
 Class extensions
 Declaration of public external interface
 Declaration variables and methods
 Definition of methods

12. class MyFormulaCruncher
method MyFormulaCruncher();
method AddNumbers(&a As number, &b As number) Returns number;
method AddNumbers2();
property number FirstNumber;
property number SecondNumber;
property number MySum readonly;
protected
property number MySumProtected;
end-class;
method MyFormulaCruncher
end-method;
method AddNumbers
Local number &c;
&c = &a + &b;
MessageBox(0, "", 0, 0, "My AddNumbers result is: " | &c);
Return &c;
end-method;
method AddNumbers2
&MySum = &FirstNumber + &SecondNumber;
&MySumProtected = &FirstNumber + &SecondNumber;
MessageBox(0, "", 0, 0, "My AddNumbers2 result is: " | &MySumProtected);
end-method;
t

13.  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.

14. It is nothing but inheritance. We can extend the properties and
methods of one class into another class using ‘extends’ key word
Example:
class Fruit
method DoFruit();
property number FruitNum instance;
end-class;
​class Banana extends Fruit
​method DoBanana();
property number BananaNum instance;
end-class;
 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

15. We can control the access by public , private, protected access specifiers.
 Public
 Protected
 Private
ex: class A
property number a1;
method number a1;
protected:
property number a2;
method number a2;
private:
property number a3;
method number a3;

16.  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
reference.
Note : Application class properties are always passed by value .

17. Passing Parameters with Object Data Types value and reference:
Parameters with object data types are always passed by reference
Example:
method myMethod(&arg as MyObjectClass);
/*method myMethod(&arg as MyObjectClass out);
Local MyObjectClass &o1 = create MyObjectClass("A");
Local MyOtherObjectClass &o2 = create MyOtherObjectClass();
&o2.myMethod(&o1);
Method myMethod
&arg = create MyObjectClass("B");
end-method;
note : Since the method argument is reassigned within the body of
myMethod, &o1 does not point at the new instance of MyObjectClass

18. 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);
class AddStuff
​method DoAdd(&P1 as number, &P2 as number out);
​ end-class;
method DoAdd
&X = &P1 + &P2;
&P1 = 1;
&P2 = 2;
end-method;
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 */

19. Sample code:
class MyInterface
method MyMethod1() abstract;
method MyMethod2() Returns string abstract;
method MyMethod3();
property string myproperty1 abstract readonly;
property number myproperty2 abstract;
property number myproperty3 abstract;
end-class;
method MyMethod3
/*body
end-method;
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
abstract method.
 The method signatures must be identical between the abstract method
definition and the method implementation in the derived.

20. Defining an application class which is totally composed of abstract
methods and properties is called interface it avoids the problem in multiple
inheritance.
Interface MyInterface
method MyMethod1();
method MyMethod2() Returns string;
property string myproperty1 readonly;
property number myproperty2;
property number myproperty3;
end-class;
When you provide an implementation for an Interface you can also
use the keyword Implements instead of Extends

21.  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
instantiated
class a
method a();
end-class;

22. This section describes the naming standards for:
 Packages.
 Classes.
 Methods.
 Properties.
Packages :cc_xxx_[yyy]
classes:do not name classes to be Getxxx

23.  Import Fruit:*;
 Import Fruit:Banana;
 Import Fruit:Drinks:*;
Here any import classes having same short name we must use full
name of the class for creating or initiating object to that class.

24.  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
class.
%THIS :
Ex:1
class FactorialClass
method factorial(&I as number) returns number;
end-class;
method factorial
if &I <= 1 then
return 1;
end-if;
return &I * factorial(&I - 1); /* error - factorial undefined */
​return &I * %This.factorial(&I - 1); /* okay */
end-method;

25. 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
class.
class ​BuildingAsset
​ method DisasterPrep();
end-class;
​method DisasterPrep
/* some body*/
end-method;
class VancouverBuilding extends BuildingAsset
​method DisasterPrep();
​end-class;
method DisasterPrep
​%Super.DisasterPrep(); /* call superclass method */
end-method;
local BuildingAsset &Building = Create VancouverBuilding();
&Building. DisasterPrep();

26. class xxx
property string StringProp get set;
end-class;
get StringProp
return "string"; /* Get the value from somewhere. */
end-get;
set StringProp
/* Do something with &NewValue. */
end-set;

27. A property of a superclass can be overridden by a subclass
class A
property number Anum;
property string Astring ​get;
property string Astring2 ​get;
end-class;
​Get Astring
​return String(%This.Anum);
​end-get;
​Get Astring2
​return String(&Anum);
​end-get;
class B extends A
property number Anum;
end-class;
local B &B = Create B();
&B.Anum = 2;
&MyValue = &B.Astring; /* &MyValue is "2" */
&MyValue = &B.Astring2; /* &MyValue is now "0" */

28. 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.
syntax:
property number a1 read only;
&a=10;

29. Application classes can contain collections. Collections of objects
generally have at least the following methods and properties.
First()
Item(Index)
Next()
Count (as a property)

30.  Instance variables.
 Global variables.
 Overriding variables and properties.

31.  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.
1.Exception class.
2.try.
3.catch block.
Exception class: This class contained

32. try /* Code to manipulate &MyArray here */
&MyArray = GetArrayData(&Param1, &Param2, &Param3);
catch ExceptionNull &Ex1
If &Ex1.MessageSetNumber = 2 and &Ex1.MessageNumber = 236 Then
End-if;
End-try;
Example 2:
Local Exception
&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");
End-Function;
try t2 ();
Local number &res = t1 (2);
Catch Exception &caugh
t MessageBox (0, "", 0, 0, "Caught exception: " | &caught.ToString());
end-try;

33.  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.

34. This section discusses some ways you can design application classes.
 Base data classes
 Abstract base classes
 Generic base classes
 Utility classes

35.  Internal comments, which start with /* and end with */.
 Comments for methods.
 Comments for classes.
Method comments:
@param N.
@exception name.
@return Type.
Class Comments:
@version number.
@ author name.