PRESENTED BY, P.S.S.SWAMY.

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.

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

Class : Class is a blueprint of the object .It consists of variable and methods. class doesnt 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 : Its 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 doesnt know what is the functionality when gear is changed one level to another level . But he change the gear against to the speed.

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.

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.pack1A.class 2.pack1pack2A.class Here ex1 fully qualified name A. class is different from ex2

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.

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.

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

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

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 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;

and

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. 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;

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 .

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

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 */

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.

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

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;

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

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.

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;

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();

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;

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" */

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;

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)

Instance variables. Global variables. 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. 1.Exception class. 2.try. 3.catch block. 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 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;

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 Utility classes

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.