OOP

[Former Member]

hi all,

What is Object and what is Object Oriented programming.

thanks

durga.

[Former Member]

Hi Durga,

Object orientation (OO), or to be more precise, object-oriented programming, is a problem-solving method in which the software solution reflects objects in the real world.

A comprehensive introduction to object orientation as a whole would go far beyond the limits of this introduction to ABAP Objects. This documentation introduces a selection of terms that are used universally in object orientation and also occur in ABAP Objects. In subsequent sections, it goes on to discuss in more detail how these terms are used in ABAP Objects. The end of this section contains a list of further reading, with a selection of titles about object orientation.

Objects

An object is a section of source code that contains data and provides services. The data forms the attributes of the object. The services are known as methods (also known as operations or functions). Typically, methods operate on private data (the attributes, or state of the object), which is only visible to the methods of the object. Thus the attributes of an object cannot be changed directly by the user, but only by the methods of the object. This guarantees the internal consistency of the object.

Classes

Classes describe objects. From a technical point of view, objects are runtime instances of a class. In theory, you can create any number of objects based on a single class. Each instance (object) of a class has a unique identity and its own set of values for its attributes.

Object References

In a program, you identify and address objects using unique object references. Object references allow you to access the attributes and methods of an object.

In object-oriented programming, objects usually have the following properties:

Encapsulation

Objects restrict the visibility of their resources (attributes and methods) to other users. Every object has an interface, which determines how other objects can interact with it. The implementation of the object is encapsulated, that is, invisible outside the object itself.

olymorphism

Identical (identically-named) methods behave differently in different classes. Object-oriented programming contains constructions called interfaces. They enable you to address methods with the same name in different objects. Although the form of address is always the same, the implementation of the method is specific to a particular class.

Inheritance

You can use an existing class to derive a new class. Derived classes inherit the data and methods of the superclass. However, they can overwrite existing methods, and also add new ones.

Uses of Object Orientation

Below are some of the advantages of object-oriented programming:

Complex software systems become easier to understand, since object-oriented structuring provides a closer representation of reality than other programming techniques.

In a well-designed object-oriented system, it should be possible to implement changes at class level, without having to make alterations at other points in the system. This reduces the overall amount of maintenance required.

Through polymorphism and inheritance, object-oriented programming allows you to reuse individual components.

In an object-oriented system, the amount of work involved in revising and maintaining the system is reduced, since many problems can be detected and corrected in the design phase.

Achieving these goals requires:

Object-oriented programming languages

Object-oriented programming techniques do not necessarily depend on object-oriented programming languages. However, the efficiency of object-oriented programming depends directly on how object-oriented language techniques are implemented in the system kernel.

Object-oriented tools

Object-oriented tools allow you to create object-oriented programs in object-oriented languages. They allow you to model and store development objects and the relationships between them.

Object-oriented modeling

The object-orientation modeling of a software system is the most important, most time-consuming, and most difficult requirement for attaining the above goals. Object-oriented design involves more than just object-oriented programming, and provides logical advantages that are independent of the actual implementation.

This section of the ABAP User’s Guide provides an overview of the object-oriented extension of the ABAP language. We have used simple examples to demonstrate how to use the new features. However, these are not intended to be a model for object-oriented design. More detailed information about each of the ABAP Objects statements is contained in the keyword documentation in the ABAP Editor. For a comprehensive introduction to object-oriented software development, you should read one or more of the titles listed below.

Further Reading

There are many books about object orientation, object-oriented programming languages, object-oriented analysis and design, project management for OO projects, patterns and frameworks, and so on. This is a small selection of good books covering the most important topics:

Scott Ambler, The Object Primer, SIGS Books & Multimedia (1996), ISBN: 1884842178

A very good introduction to object orientation for programmers. It provides comprehensive explanations of all essential OO concepts, and contains a procedure model for learning OO quickly and thoroughly. It is easy to read and practical, but still theoretically-founded.

Grady Booch, Object Solutions: Managing the Object-Oriented Project, Addison-Wesley Pub Co (1995), ISBN: 0805305947

A good book about all of the non-technical aspects of OO that are equally important for effective object-oriented programming. Easy to read and full of practical tips.

Martin Fowler, UML Distilled: Applying the Standard Object Modeling Language, Addison-Wesley Pub Co (1997), ISBN: 0201325632

An excellent book about UML (Unified Modeling Language - the new standardized OO language and notation for modeling). Assumes knowledge and experience of object orientation.

Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides, Design Patterns. Elements of Reusable Object-Oriented Software, Addison-Wesley Pub Co (1998), ISBN: 0201634988

Provides a pattern, showing how recurring design problems can be solved using objects. This is the first big pattern book, containing many examples of good OO design.

James Rumbaugh, OMT Insights: Perspectives on Modeling from the Journal of Object-Oriented Programming, Prentice Hall (1996), ISBN: 0138469652

A collection of articles addressing the many questions and problems of OO analysis and design, implementation, dependency management, and so on. Highly recommended.

Notes

If you are new to object-orientation, you should read Scott Ambler’s ‘The Object Primer’ and then acquire some practical experience of your own. You should definitely use the CRC techniques described by Ambler and Fowler for object-oriented analysis and design. After this, you should learn UML, since this is the universal OO analysis and design notation. Finally, you should read at least one book about patterns.

At the beginning of a large OO project, the question immediately arises as to the sequence in which things should be done, which phases should be finished at what time, how to divide up and organize the development work, how to minimize risks, how to assemble a good team, and so on and so forth. Many of the best practices of project management have had to be redefined for the object-oriented world, and the opportunities that this has produced are significant. For further information about how to use OO in project management, see Grady Brooch’s book ‘Object solutions’, or the chapter entitles ‘An outline development process’ from Martin Fowler’s book.

There are, of course, many other good books about object orientation. The above list does not claim either to be complete, or necessarily to recommend the best books available.

Plzz reward if it is useful,

Mahi.

[Former Member]

Object-oriented programming (OOP) is a programming paradigm that uses "objects" and their interactions to design applications and computer programs. It is based on several techniques, including inheritance, modularity, polymorphism, and encapsulation. It was not commonly used in mainstream software application development until the early 1990s. Many modern programming languages now support OOP.

Object-oriented programming roots reach all the way back to the 1960s. As hardware and software became increasingly complex, researchers studied how software quality could be maintained. Object-oriented programming was deployed as an attempt to address this problem by strongly emphasizing discrete units of programming logic and re-usability in software.

The Simula programming language was the first to introduce the concepts underlying object-oriented programming (objects, classes, subclasses, virtual methods, coroutines, garbage collection, and discrete event simulation) as a superset of Algol. Simula was used for physical modeling, such as models to study and improve the movement of ships and their content through cargo ports. Smalltalk was the first programming language to be called "object-oriented".

Object-oriented programming may be seen as a collection of cooperating objects, as opposed to a traditional view in which a program may be seen as a list of instructions to the computer. In OOP, each object is capable of receiving messages , processing data, and sending messages to other objects. Each object can be viewed as an independent little machine with a distinct role or responsibility.

The concept of objects and instances in computing had its first major breakthrough with the PDP-1 system at MIT which was probably the earliest example of capability based architecture. Another early example was Sketchpad made by Ivan Sutherland in 1963; however, this was an application and not a programming paradigm. Objects as programming entities were introduced in the 1960s in Simula 67, a programming language designed for making simulations, created by Ole-Johan Dahl and Kristen Nygaard of the Norwegian Computing Center in Oslo. (Reportedly, the story is that they were working on ship simulations, and were confounded by the combinatorial explosion of how the different attributes from different ships could affect one another. The idea occurred to group the different types of ships into different classes of objects, each class of objects being responsible for defining its own data and behavior.) Such an approach was a simple extrapolation of concepts earlier used in analog programming. On analog computers, such direct mapping from real-world phenomena/objects to analog phenomena/objects (and conversely), was (and is) called 'simulation'. Simula not only introduced the notion of classes, but also of instances of classes, which is probably the first explicit use of those notions.

The Smalltalk language, which was developed at Xerox PARC in the 1970s, introduced the term Object-oriented programming to represent the pervasive use of objects and messages as the basis for computation. Smalltalk creators were influenced by the ideas introduced in Simula 67, but Smalltalk was designed to be a fully dynamic system in which classes could be created and modified dynamically rather than simply using static ones as in Simula 67.[3] The ideas in Simula 67 were also used in many other languages, from derivatives of Lisp to Pascal.

Object-oriented programming developed as the dominant programming methodology during the mid-1990s, largely due to the influence of C++citation needed. Its dominance was further cemented by the rising popularity of graphical user interfaces, for which object-oriented programming is well-suited. An example of a closely related dynamic GUI library and OOP language can be found in the Cocoa frameworks on Mac OS X, written in Objective C, an object-oriented, dynamic messaging extension to C based on Smalltalk. OOP toolkits also enhanced the popularity of event-driven programming (although this concept is not limited to OOP). Some feel that association with GUIs (real or perceived) was what propelled OOP into the programming mainstream.

OOP also became increasingly popular for developing computer games during the 1990s. As the complexity of games grew, as faster hardware became more widely available and compilers (especially C+) matured, more and more games and their engines were written in OOP languages. Prominent C+ examples[4] include Starcraft, Diablo, and Warcraft III. Since almost all video games feature virtual environments which contain many, often thousands of objects that interact with each other in complex ways, OOP languages are particularly suited for game development.citation needed

At ETH Zürich, Niklaus Wirth and his colleagues had also been investigating such topics as data abstraction and modular programming. Modula-2 included both, and their succeeding design, Oberon, included a distinctive approach to object orientation, classes, and such. The approach is unlike Smalltalk, and very unlike C++.

Object-oriented features have been added to many existing languages during that time, including Ada, BASIC, Lisp, Fortran, Pascal, and others. Adding these features to languages that were not initially designed for them often led to problems with compatibility and maintainability of code.

In the past decade Java has emerged in wide use partially because of its similarity to C and to C++, but perhaps more importantly because of its implementation using a virtual machine that is intended to run code unchanged on many different platforms. This last feature has made it very attractive to larger development shops with heterogeneous environments. Microsoft's .NET initiative has a similar objective and includes/supports several new languages, or variants of older ones.

More recently, a number of languages have emerged that are primarily object-oriented yet compatible with procedural methodology, such as Python and Ruby. Besides Java, probably the most commercially important recent object-oriented languages are Visual Basic .NET and C# designed for Microsoft's .NET platform.

Just as procedural programming led to refinements of techniques such as structured programming, modern object-oriented software design methods include refinements such as the use of design patterns, design by contract, and modeling languages (such as UML).

Reward if useful.

[Former Member]

Hi

We can implement OOPS concepts in SAP using ABAP objets concept.

ABAP Objects is a new concept in R/3 Release 4.0. The term has two meanings. On the one hand, it stands for the entire ABAP runtime environment. On the other hand, it represents the object-oriented extension of the ABAP language.

The Runtime Environment

The new name ABAP Objects for the entire ABAP runtime environment is an indication of the way in which SAP has, for some time, been moving towards object orientation, and of its commitment to pursuing this line further. The ABAP Workbench allows you to create R/3 Repository objects such as programs, authorization objects, lock objects, Customizing objects, and so on. Using function modules, you can encapsulate functions in separate programs with a defined interface. The Business Object Repository (BOR) allows you to create SAP Business Objects for internal and external use (DCOM/CORBA). Until now, object-oriented techniques have been used exclusively in system design, and have not been supported by the ABAP language.

The Object-Oriented Language Extension

ABAP Objects is a complete set of object-oriented statements that has been introduced into the ABAP language. This object-oriented extension of ABAP builds on the existing language, and is fully compatible with it. You can use ABAP Objects in existing programs, and can also use "conventional" ABAP in new ABAP Objects programs.

ABAP Objects supports object-oriented programming. Object orientation (OO), also know as the object-oriented paradigm, is a programming model that unites data and functions in objects. The rest of the ABAP language is primarily intended for structured programming, where data is stored in a structured form in database tables and function-oriented programs access and work with it.

The object-oriented enhancement of ABAP is based on the models of Java and C++. It is compatible with external object interfaces such as DCOM and CORBA. The implementation of object-oriented elements in the kernel of the ABAP language has considerably increased response times when you work with ABAP Objects. SAP Business Objects and GUI objects - already object-oriented themselves - will also profit from being incorporated in ABAP Objects.

Please check these links ...

http://help.sap.com/printdocu/core/Print46c/en/data/pdf/BCABA/BCABA.pdf -- Page no: 1291

http://esnips.com/doc/5c65b0dd-eddf-4512-8e32-ecd26735f0f2/prefinalppt.ppt

http://esnips.com/doc/2c76dc57-e74a-4539-a20e-29383317e804/OO-abap.pdf

http://esnips.com/doc/0ef39d4b-586a-4637-abbb-e4f69d2d9307/SAP-CONTROLS-WORKSHOP.pdf

http://esnips.com/doc/92be4457-1b6e-4061-92e5-8e4b3a6e3239/Object-Oriented-ABAP.ppt

http://esnips.com/doc/448e8302-68b1-4046-9fef-8fa8808caee0/abap-objects-by-helen.pdf

http://esnips.com/doc/39fdc647-1aed-4b40-a476-4d3042b6ec28/class_builder.ppt

regards,

pavan.

[Former Member]

Hi

Classes

It can be regarded as instruction for building an Object

The type of an object is known as its Class

Abstract description of an object

Classes contain components which describe state and behavior of an object.

Global classes can be defined using SE24(Class Builder) and local classes using SE38

Note : Instance of a Class is called Object

Complete definition includes :

Declaration part

Implementation part (If required)

Class MyClass Definition.

… Declaration Part ( For attributes, Methods

EndClass. and Events)

If Declaration part contains Methods, then these methods must be implemented in the Implementation part using statement

Class MyClass Implementation.

…

EndClass

The Components of Class can be :

Attributes

Methods

Events

The declaration part can be divided into three sections namely

PUBLIC SECTION, PROTECTED SECTION and PRIVATE SECTION

which controls the visibility.

Each component of class must be explicitly assigned to one of these three

visibility sections

Components Types

Instance Components :

Instance Dependent

Exist for each Object

Static Components :

Instance Independent

Exist only once for each class

They are retained for the entire Runtime

All objects of a class can access the static attributes of the class

When a static attribute is changed, this change is reflected in all other objects of the class

Attributes

Attributes are data fields in the Class

Can have any ABAP datatype

The contents of the Attribute determine the status of the object.

Can be Instance( DATA Statement) or

Static ( CLASS-DATA Statement)

Note : Within the Class, the addition LIKE can only be used for reference to other attributes of the class. For references to data types from the ABAP Dictionary, only the addition TYPE can be used

Methods

Internal procedures in the Class

Determine behavior of an Object

Can access all attributes of the Class and can thus change the status of an Object

Similar to other ABAP procedures (Subroutines and Function Modules)

Can be Instance ( METHODS) or Static (CLASS-METHODS)

They are declared in the Declaration part and implemented in the Implementation part using statement

Method MyMethod.

….

EndMethod.

Calling a Method

The additions to the above statement are

1. ... EXPORTING p1 = f1 ... pn = fn ( By Value/ By Reference)

2. ... IMPORTING p1 = f1 ... pn = fn ( By Value/ By Reference)

3. ... CHANGING p1 = f1 ... pn = fn ( By Value/ By Reference)

4. ... RETURNING p = f ( By Value)

5. ... EXCEPTIONS except1 = rc1 ... exceptn = rcn

6. ... PARAMETER-TABLE itab

7. ... EXCEPTION-TABLE itab

Variant 2 : CALL METHOD meth( f ).

If it has only one input (IMPORTING) parameter and no other interface

parameters. Here f is actual parameter.

Variant 3 : CALL METHOD meth( p1 = f1 ... pn = fn ).

If the method has only input parameters(IMPORTING) parameter and no other

interface parameters. Here f1 …. fn are actual parameter.

Events

Events enable objects or classes to trigger Event Handler Methods in other objects or Classes

Events are of two types : Instance and Static

Instance Events

Declared using the statement EVENTS.

Instance events can only be triggered in Instance Methods.

Static Events

Declared using statement CLASS-EVENTS

Static events can be triggered both by Instance Methods and Static Methods

Registers and deregisters Event Handler Methods dynamically at Runtime

SET HANDLER

This statement can be used in three ways

SET HANDLER h1 ….hn FOR ref

This form is used for instance events and registers the Event Handler Methods for only one instance (i.e one object )

ref stands for Class Reference Variable or Interface Reference Variable

SET HANDLER h1…..hn FOR ALL INSTANCES

This form is used for instance events and registers the Event Handler Methods for all Instances

ref stands for Class Reference Variable or Interface Reference Variable

SET HANDLER h1…..hn.

This form is used for static events.

In case of Class Reference : It registers Event Handler Methods for triggering from class where the event has been declared.

In case of Interface Reference : It registers the event handler methods for all triggering classes that implement the interface intf.

Creating Object

To create objects we have to use the CREATE OBJECT statement.

CREATE OBJECT cref.

where, cref = Class Reference Variable

Can have interface parameters like EXPORTING or EXCEPTIONS.

If the Class has instance constructor (CONSTRUCTOR), the CREATE OBJECT statement calls it after the object has been created completely

If the Class has static constructor (CLASS_CONSTRUCTOR), and it has not yet been executed, the CREATE OBJECT statement calls it before creating the Object

Sample Program:

Prg1:

CLASS C1 DEFINITION.

PUBLIC SECTION.

DATA: I_PUB_V1 TYPE I VALUE 10.

PROTECTED SECTION.

DATA: I_PRO_V1 TYPE I VALUE 20.

PRIVATE SECTION.

DATA: I_PRI_V1 TYPE I VALUE 30.

ENDCLASS. "C1 DEFINITION

START-OF-SELECTION.

DATA: OBJ TYPE REF TO C1.

CREATE OBJECT OBJ.

WRITE:/ OBJ->I_PUB_V1.

Prog2:

CLASS C1 DEFINITION.

PUBLIC SECTION.

EVENTS: E1.

METHODS: M1,

M2 FOR EVENT E1 OF C1.

ENDCLASS. "C1 DEFINITION

-

---

CLASS C1 IMPLEMENTATION

-

---

*

-

---

CLASS C1 IMPLEMENTATION.

METHOD M1.

WRITE:/ 'IM M1 RAISING EVENT E1'.

RAISE EVENT E1.

ENDMETHOD. "M1

METHOD M2.

WRITE:/ 'I M M2 EVENT HANDLER METHOD EXECUTED VIA EVENT E1'.

ENDMETHOD. "M2

ENDCLASS. "C1 IMPLEMENTATION

START-OF-SELECTION.

DATA: OBJ TYPE REF TO C1.

CREATE OBJECT OBJ.

SET HANDLER OBJ->M2 FOR OBJ.

CALL METHOD OBJ->M1.

prog3:

EPORT ZLCL_IF .

-

---

INTERFACE IF1

-

---

*

-

---

INTERFACE IF1.

METHODS: M1 IMPORTING P1 TYPE I

P2 TYPE I

EXPORTING P3 TYPE I.

ENDINTERFACE. "IF1

-

---

CLASS CL_ABS DEFINITION

-

---

*

-

---

CLASS CL_ABS DEFINITION ABSTRACT.

PUBLIC SECTION.

METHODS: M1,

M2 ABSTRACT IMPORTING P1 TYPE I

P2 TYPE I

EXPORTING P3 TYPE I.

ENDCLASS. "CL_ABS DEFINITION

If these helpful rewards points.

Regards

Pratap.M