Who has the book:Object-Oriented Programming with ABAP Objects

Hello everyone
Now i want to learn ABAP OO,and Lots' of guys told me that the book Object-Oriented Programming with ABAP Objects is realy a good book.but i searched on the net,and could not got PDF of this book,could some one gave me the net address if you know where to download the book or send me to my Mailbox:<email id removed by moderator>,I will very glad to receive any response from you,
of course,if you have some advise on how to learn ABAP OO or some other material ,hope you could share your meaning with me, hope to receive your response.
Best regards!
From Carl
Moderator message : Moved to career center.
Edited by: Vinod Kumar on Aug 27, 2011 9:21 AM

I'm sure you're not asking for illegal, "free" downloads. You can legally purchase the book, also in electronic format, at sap-press.com
Thomas

Similar Messages

Module pool programming with Abap Objects

Hi masters,
Somebody tell me that you can directly call a local class in a module pool.
Is that possible?
Can anybody refer me to any kind of information?
Thanks a lot.

Well, thanks for the answer, but not was the one i was waiting for... it wasn't helpful.
But, i've continued searching for answers... and i've found that:
OO Transactions Locate the document in its SAP Library structure
In transaction maintenance (SE93), you can specify a transaction code as an OO transaction.
You either link the transaction code to the Transaction Service of the Structure link ABAP Object Services for persistent objects or to a public method of a global or local class of a program. When calling up a transaction that is linked to an instance method, the system automatically generates an instance of the class in its own internal session.
An example of a link between a transaction code and an instance method of a local class of an unspecified ABAP program:
Example
*& Modulpool DEMO_OO_TRANSACTION *
program DEMO_OO_TRANSACTION.
class DEMO_CLASS definition.
public section.
methods INSTANCE_METHOD.
endclass.
class DEMO_CLASS implementation.
method INSTANCE_METHOD.
message 'Instance method in local class' type 'I'.
endmethod.
endclass.
The DEMO_OO_TRANSACTION program is a module pool of type M that does not contain any screens or dialog modules. Instead, the program contains the definition of a local class DEMO_CLASS.
The DEMO_OO_METHOD transaction code is linked to this program as follows:
The start object of the transaction is Method of a class (OO transaction).
OO transaction model is not selected.
The Class Name is DEMO_CLASS.
The Method is INSTANCE_METHOD.
Local in program is selected and DEMO_OO_TRANSACTION specified.
When the transaction is called up, the program is loaded, an instance of the class is created, and the method is executed.
Leaving content frame
That's what i wanted.
I hope it would be helpful for anyone else.

Object-oriented programming: state and behaivor

First of all, sorry for my level english.
In Object-Oriented programming, should an object save always some state?
What about session stateless bean service? What is the sense?
These objects have only behaivour and not state.
Perhaps, the sense is that you can send a message to this object, in oposite of a static methods in utility class?
Thanks and regards.

I suppose you could argue that if it doesn't have any state, then it's not really an "object" in the OOP sense, but who cares, really.
Personally, I use state and behavior as a way to help clarify the responsibilities of various classes in the system, and if I see a codebase with a lot of objects with state but no behavior or behavior but no state, then it's a a red flag that it's a messy, poorly-thought-out design (and it usually turns out to be exactly that). The whole point of OOP (IMHO) is encapsulation, and bundling state and behavior together makes things encapsulated (you can prove that state changes only in certain areas in certain circumstances). Encapsulation makes for more easily maintainable code.
It's easy to spot the blue squares in a Mondrian. It's difficult to spot the blue bits in a Pollock. The former is well-encapsulated OOP and the latter is poorly-encapsulated spaghetti code.
That said, it's not the end of the world if you have a static utility class here and there.

TO KNOW WHAT EXACTLY OBJECT ORIENTED PROGRAMMING

IS JAVA AN OBJECT ORIENTED PROGRAMMING LANGUAGE? WHAT ARE THE PARAMETERS WHICH DESCRIBES THE TERM "OBJECT ORIENTED LANGUAGE" ? WHAT IS EXACTLY OBJECT ORIENTED PROGRAMMING(WITH EXAMPLES).

Nikh4ever wrote:
IS JAVA AN OBJECT ORIENTED PROGRAMMING LANGUAGE?Yes.
Nikh4ever wrote:
WHAT ARE THE PARAMETERS WHICH DESCRIBES THE TERM "OBJECT ORIENTED LANGUAGE" ? WHAT IS EXACTLY OBJECT ORIENTED PROGRAMMING(WITH EXAMPLES).[http://en.wikipedia.org/wiki/Object-oriented_programming]
BTW - why are you shouting ... or is your keyboard broken?

Trying to understand the basic concept of object oriented programming.

I am trying to understand the basic concept of object oriented programming.
Object - a region of storage that define is defined by both state/behavior.
( An object is the actual thing that behavior affects.)
State - Represented by a set of variables and the values they contain.
(Is the location or movement or action that is the goal that the behavior is trying to accomplish.)
Variables- (What does this mean?)
Value - (What does this mean?)
Behavior - Represented by a set of methods and the logic they implement.
( A set of methods that is built up to tell's the how object to change it's state. )
Methods - A procedure that is executed when an object receives a message.
( A very basic comand.For example the method tells the object to move up, another method tells the method to go left. Thus making the object move up/left that combination is the behavior.)
Class - A template from which the objects are created.
( I am very confused on what classes are.)
- The definitions of the words I obtained from the "Osborne Teach Yourself Java". The () statements are how I interperate the Mechanisms (I do not know if Thats what you call them.) interact with each other. I understand my interpretation may be horribly wrong. I will incredibly appreciate all the support I may get from you.
Thank you

Object oriented programming is a replacement for the older idea of procedural programming (you can research procedural programming in google). As I understand it, in procedural programming, you have a step by step set of function calls to accomplish some task. Each function receives a data structure, manipulates it, and passes it to the next function. The problem with this is that each function preforms some action for the overall task and can't easily be reused by some other task. Its also harder to read the flow of what is happening with raw data structures flying all over the place.
In object oriented programming, an object calls a function of another object and receives back, not a data structure, but another object. Objects contain a data structure that can only be accessed by its functions. An object is not so much a sub component of a bigger task, as it is a service that any other task can use for any purpose. Also, when you pass an object to the caller, the caller can ask questions about the data structure via its functions. The developer doesnt have to know what the previous function did to the data by reading up on any documentation, or having to reverse engineer the code.
I suggest the best way of learning this is to code something like a library object.
A library object contains a collection of book objects
A book object contains a collection of chapter objects
A chapter object contains a collection of paragraph objects
A paragraph object contains a collection of sentence objects
A sentence object contains a collection of word objects.
Add functions to each object to provide a service
Example: A library object should have a:
public void addBook(Book book)
public Book getBook(String title)
public boolean isBookInLibrary(String title)
The key is to add functions to provide a service to anyone who uses your object(s)
For example, what functions (service) should a paragraph object provide?
It shouldn't provide a function that tells how many words there are in a sentence. That function belongs to a sentence object.
Lets say you want to add a new chapter to a book. The task is easy to read
if you write your objects well:
Sentence sentence1=new Sentence("It was a dark and stormy night");
Sentence sentence2=new Sentence("Suddenly, a shot ran out");
Paragraph paragraph=new Paragraph();
paragraph.addSentence(sentence1);
paragraph.addSentence(sentence2);
Paragraphs paragraphs=new Paragraphs();
paragraphs.addParagraph(paragraph);
Library library= new Library();
library.getBook("My Novel").addChapter("Chapter 1",paragraphs).
Now, lets say you want to have a word count for the entire book.
The book should ask each chapter how many words it contains.
Each chapter should ask its paragraphs, each paragraph should ask
its sentences. The total of words should ripple up and be tallied at each
stage until it reaches the book. The book can then report the total.
Only the sentence object actually counts words. The other objects just tallies the counts.
Now, where would you assign a librarian? What object(s) and functions would you provide?
If written well, the project is easily extensible.

Anyone recommends a good book for object oriented programming

I am a college student in computer engineering (Software) and have been programming using Java for over a year. I have become really interested in the design of softwares and the "beauty" of object oriented programming, and thus would like to advance my knowledge about the topic (my university offers an advanced oop class but I would have to wait another 6 months to take it). So my question is, could you recommend me any book that covers the subject of object oriented programming extensively? (I have learned most of the oop I know from "An Introduction to Programming and Object Oriented Design Using Java" by Nino and Hosch.
Thanks in advance

Some years ago I remember cutting my teeth on OOP using an excellent book by Grady Booch. If it's still in print and has been updated, it may be worth a look. Again it was decent. Also consider picking up a book on design patterns. Good luck.
Edit: I found it, it's called "Object-Oriented Analysis and Design with Applications", and it's in its third edition. You can find it here on Amazon.
Edited by: Encephalopathic on Apr 22, 2008 2:48 PM

How to avoid the case of leaks memory in Object Oriented Programming

Hi, Everyone, I am writing a simple web-baed application for JSP and Servlet, I pass all data from JSP to Servlet, It is due to the number of row of record are variable, so I should write a Java Instance class to stored to specific data in a Java Object, and then stored those object in a arraylist In the Servlet class, and then pass the arraylist in to a session, to pass the session from the servlet to another JSP......
But some thing I am worried about is that if the no of row of record user input is large, then the number of object stored in the arraylist will also large. I am worried it will serious leaks memoary in my server. Because my server always occurs "Out Of Memoary Exception" in Tomcat, So If I use the above method. I affarid the memory will be further leaking in my server. So What can I do? Is it having any better method to prevent memory leaking when using Object Oriented Programming(Except using Hibernate)?
Can Anyone be help me?
Thank you very much for All, THX

Because many people say that the large amount of
using Object will lead to "memory leak", I am worried
about the size of object I use is too large and then
it will construct "memory leak". No it will not! You get a 'memory leak' by holding references to objects you no longer require.
>
The detail of my case is that:
In my web application, there is a session variable
pass through from one servlet to another jsp/servlet.You should only place small amounts of data in the session. If you need forward from a Servlet to a JSP (or JSP to Servlet) then you should place the data object in the request (using the setAttribute() method), not in the session. In this way, when the session is re-claimed so will be the data object.
And this session variable is stored a Instance Object
(which is a class write by me) with the following
issue:
1) This instance object having "has-a relationship"
with another four instance object (all are the
classes write by me)
2) This instance object having "has relationship"
with a arraylist, this arraylist is stored about 4-5
instance object(all are the classes write by me) .
If this object having the above issue, Will this
object construct a "leaks memory" when this object
stored in the session and pass through servlet to
another jsp/servlet?
Message was edited by:
sabre150

Module pool with object oriented programming

can anyone send me links for module pool with object oriented programming.

hi,
some helful links.
Go through the below links,
For Materials:
1) http://help.sap.com/printdocu/core/Print46c/en/data/pdf/BCABA/BCABA.pdf -- Page no: 1291
2) http://esnips.com/doc/5c65b0dd-eddf-4512-8e32-ecd26735f0f2/prefinalppt.ppt
3) http://esnips.com/doc/2c76dc57-e74a-4539-a20e-29383317e804/OO-abap.pdf
4) http://esnips.com/doc/0ef39d4b-586a-4637-abbb-e4f69d2d9307/SAP-CONTROLS-WORKSHOP.pdf
5) http://esnips.com/doc/92be4457-1b6e-4061-92e5-8e4b3a6e3239/Object-Oriented-ABAP.ppt
6) http://esnips.com/doc/448e8302-68b1-4046-9fef-8fa8808caee0/abap-objects-by-helen.pdf
7) http://esnips.com/doc/39fdc647-1aed-4b40-a476-4d3042b6ec28/class_builder.ppt
8) http://www.amazon.com/gp/explorer/0201750805/2/ref=pd_lpo_ase/102-9378020-8749710?ie=UTF8
1) http://www.erpgenie.com/sap/abap/OO/index.htm
2) http://help.sap.com/saphelp_nw04/helpdata/en/ce/b518b6513611d194a50000e8353423/frameset.htm
<u>Sample std pgms.</u>
ABAP_OBJECTS_ENJOY_0           Template for Solutions of ABAP Object Enjoy Course
ABAP_OBJECTS_ENJOY_1           Model Solution 1: ABAP Objects Enjoy Course
ABAP_OBJECTS_ENJOY_2           Model Solution 2: ABAP Objects Enjoy Course
ABAP_OBJECTS_ENJOY_3           Model Solution 3: ABAP Objects Enjoy Course
ABAP_OBJECTS_ENJOY_4           Model Solution 4: ABAP Objects Enjoy Course
ABAP_OBJECTS_ENJOY_5           Model Solution 5: ABAP Objects Enjoy Course
DEMO_ABAP_OBJECTS              Complete Demonstration for ABAP Objects
DEMO_ABAP_OBJECTS_CONTROLS     GUI Controls on Screen
DEMO_ABAP_OBJECTS_EVENTS       Demonstration of Events in ABAP Objects
DEMO_ABAP_OBJECTS_GENERAL      ABAP Objects Demonstration
DEMO_ABAP_OBJECTS_INTERFACES   Demonstration of Interfaces in ABAP Objects
DEMO_ABAP_OBJECTS_METHODS      Demonstration of Methods in ABAP Objects
DEMO_ABAP_OBJECTS_SPLIT_SCREEN Splitter Control on Screen
Rgds
Reshma

Anyone recommends a good book for object oriented programming (advanced)

I am a college student in computer engineering (Software) and have been programming using Java for over a year. I have become really interested in the design of softwares and the "beauty" of object oriented programming, and thus would like to advance my knowledge about the topic (my university offers an advanced oop class but I would have to wait another 6 months to take it). So my question is, could you recommend me any book that covers the subject of object oriented programming extensively? (I have learned most of the oop I know from "An Introduction to Programming and Object Oriented Design Using Java" by Nino and Hosch.
Thanks in advance

jwenting wrote:
I never tire of pushing ["Agile Software Development, Principles, Patterns, and Practices "|http://www.amazon.com/Software-Development-Principles-Patterns-Practices/dp/0135974445] by Robert Martin.
You probably meant [Agile Software Development, Principles, Patterns, and Practices|http://www.amazon.com/Software-Development-Principles-Patterns-Practices/dp/0135974445] ;-)
Remember, quotes in link names break the forum ...

I can't get my ipod touch 2nd generation to sync with itunes, at the end of the sync the message ''the ipod cannot be synced, an unknown error occurred (13019)'' my sister who has the same ipod also has the same problem.

my sister who has the same ipod also has the same problem, i ve tried re downloading itunes and restoring factory settings on my ipod but nothing works!

Did you try all the suggestions mentioned here? iTunes Error 13019 during sync

Object oriented programming in LabVIEW

Please send this message to everybody who has an opinion about this.
Please try to keep it short, but if you can't control yourselves, let
it all out!
I would like to have your opinions about the nature of Labview and it's
ability to support object oriented programming.
I have a couple of questions to fire the discussion.
1- Do you think that LV was built to support OO Programming?
2- Is OO the only way we have to support large applications, or is it
feasible to support it with a good dataflow architecture including all
the flowcharts and all the data definitions?
3- Is LV going to stay "dataflow" or is it going to become OO?
4- What would be the great benefits of turning LV to OO that we don't
already have w
ith the dataflow approach?
5- My opinion is that trying to implement OO in LabVIEW, is like trying
to
Thank you all for your time.
Sent via Deja.com
http://www.deja.com/

> 1- Do you think that LV was built to support OO Programming?
LV was initially designed in 1983. OOP existed at that point,
but LV wasn't designed to be OO. It was designed to allow
engineers and researchers a simple language appropriate
for controlling their research labs from a computer.
> 2- Is OO the only way we have to support large applications, or is it
> feasible to support it with a good dataflow architecture including all
> the flowcharts and all the data definitions?
OO lends itself to large projects because it provides
abstraction, encapsulation, and organizes code into
modules that can more easily be implemented independent
of one another since they can be specified in finer
detail. Also, the compilers help to enforce the
specifications providing they can be encoded in the
interface between objects.
These OO principles were already a part of big projects
long before there were OO languages. It was just that
the language didn't necessarily have features which
supported it. Similarly, they can be a part of big
projects today despite the language being used.
LV 2 style globals, which as the name suggests were
in use long ago, encapsulate data with an interface.
They disallow arbitrary access to the data and can be
used to enforce correct access. With other functions
layered on top, you get a nice interface to stored data.
Functions and structs/clusters abstract away details.
Building a subVI that does an FFT means that for 99%
of the uses, you don't need any more information except
that this block performs an abstract mathematical function,
an FFT. The implementation can be completely changed
to speed it up or make it more accurate and your code
isn't affected. Its abstract definition still holds, so
your code still works.
There are other things that OO languages bring to the
table that LV, and GOOP don't yet offer. In my opinion,
a few more OO features can be added to LV to allow for
even larger projects in the future provided they are used
well.
Earlier posts pointed out that C++ doesn't guarantee that
a project will succeed. OO features are just another tool,
and the tool can be misused leading to a failed project.
This is true to LV, C, C++, and all other engineering tools.
The key is using the tools at hand to best solve the
problems we face. Not glorifying or blaming the tools for
the state of the project.
> 3- Is LV going to stay "dataflow" or is it going to become OO?
LV is dataflow to the core. The definition of what data
is flowing may be expanded, but it will still be data
flowing down wires from one node to another that accounts
for how the program executes.
One of the limitations of the current GOOP is that all
objects are dealt with by a reference. By adding
language features, objects could be made to flow down
the wire, just like strings and arrays, meaning that
branching a wire doesn't lead to side-effects,
and there is no need to dispose objects.
> 4- What would be the great benefits of turning LV to OO that we don't
> already have with the dataflow approach?
Remember when LV didn't have typedefs? It was easy for
a cluster datatype to change once a project was underway.
That usually led to lots of edits on other panels to get
them back in synch. Without the unbundle by name, you
then went through the diagrams fixing all of the bundlers
and unbundlers to have the right number of terminals.
Changing the order of the cluster was even worse since
the diagrams may not bread, they might just access the
wrong field instead.
In many respects, an object is just another step along the
same path. An object is a typedef that can have code
associated with it for access -- maybe like Array and
Cluster Tools. Some of the typedef contents might be
publicly accessable, like now, while other elements are
hidden, only available to the implementation of the
typedef. That would force the user to use your functions
to manipulate things rather than hacking away at the
typedef contents. As an example, a LV string is really
just a cluster of size and characters. Since the diagram
can only modify the string using the string functions, you
never get the size and characters out of synch. That is
until you take it into LV generated code, a DLL or CIN
where you have access to the inner fields.
A related problem is that current typedefs are transparent
to built-in LV functions. If your typedef is just some
numbers, LV will be happy to perform arithmetic on your
typedef. Maybe this is what you want, but if this doesn't
make sense on your typedef, then your left with adding a
Boolean or a string so that the arithmetic isn't allowed.
Ideally, you would be able to state that = makes sense, >
and < don't, + and - only operates on the first numeric, and
* is something that you implement yourself. There would be
some safeguards so that the user of your typedef, which
includes you, wouldn't accidentally mangle the typedef
contents.
These may not seem like much at first, but they allow for
much more abstraction and better encapsulation. Finally,
there is a technique called inheritance that allows for
similar objects to be acted on by common code in one
location, and by specific code in another location depending
on which type of object is actually there at runtime.
This of usually done today by switching out on some inner
tag and dealing with each type in its own diagram. This
works fine until projects get large and teams get large.
Inheritance is a different way of implementing the exact
same thing that usually works much better for bigger teams
and bigger projects.
> 5- My opinion is that trying to implement OO in LabVIEW, is like trying
> to
Is this a fill-in-the blank question? It is difficult today
because the LV language doesn't yet support OO very well.
Early C++ was implemented on top of C using just a bunch
of macros and the preprocessor to mangle the C++ back into
C so that it could be compiled and run. Debugging was
done on practically unreadable text that vaguely resembled
your original code. By comparison, GOOP actually looks
pretty good. It is written entirely on top of the current
LV language and makes clever use of things like datalog
refnums to make strict types.
Over time I think GOOP will mature, and like typedefs,
some users will come to rely on it in a big way.
Other users will hopefully not even notice that anything
changed. If their project grows in complexity and they
need another tool to manage things, it will be just
another feature that helps them to get useful things done.
Greg McKaskle

Object oriented programming aspects in Oracle

Dear All,
Can you one explain me the aspects of Object Oriented Programming in Oracle. How to use oops concepts in Oracle Procedures, functions, packages, etc.
Thanks,
Moorthy.GS

Oracle 9i introduces support for inheritance, method overriding and dynamic method dispatch (or "dynamic binding", or "virtual").
A method call is dispatched to the nearest implementation, working back up the inheritance hierarchy from the current or specified type.
See, for example, how we can implement the Template Design Pattern in PL/SQL, using inheritance, method overriding and dynamic method dispatch:
http://www.quest-pipelines.com/pipelines/plsql/tips06.htm#OCTOBER
Oracle 11g introduces support for "super" object-oriented keyword. One attempt to do this in PLSQL 9i/10g:
Calling the Parent Object's Version of an Overridden Method
http://www.quest-pipelines.com/pipelines/plsql/tips03.htm#JUNE
I expect some OO improvements in the future (in Oracle 12oo ...):
1. References between transient objects (instances of objects types) and (then) garbage collector
2. Generic classes (templates, generics) like in Eiffel, C++, Java 5 (PL/SQL was modeled after ADA 83, and ADA 83 has generic packages)
3. Multiple inheritance like in Eiffel (inner classes like in Java - no, please)
4. Design By Contract like in Eiffel (C++ / Java 1.4 assert is not enough)
Design by contract (DBC) is a method whose author is Bertrand Mayer, also maker of OOPL language Eiffel
(Eiffel was designed in 1985, commercialy released in 1986, ISO-standardized in 2006).
Simplified, DBC is based on principle that in each routine (procedure or function) with standard code,
two additional parts – PRECONDITION and POSTCONDITION - need to be asserted.
An additional assertion in class is called INVARIANT.
Contract is based on routine's putting up an obligation to caller (to some other routine)
to satisfy conditions of precondition and conditions of invariant, and hers (called routine's) obligation
to satisfy conditions of postcondition and conditions of invariant.
The object oriented Eiffel programming language was created to implement DBC.
For now, other OO (object-oriented) languages don’t support directly the ideas behind DBC.
However, precondition and postcondition are applicable to many programming languages, both OO and not OO.
Invariants are applicable only in OOPL.
This is my attempt to use DBC methodology (including invariants) in Oracle PL/SQL.
Eiffel class interface (not like Java interface, but more like PL/SQL package specification)
from Bertrand Meyer's book "Object oriented software construction", second edition (OOSC2), 1997, page 390-391:
class interface STACK [G]
creation make
feature -- Initialization
make (n: INTEGER) is -- Alocate stack for a maximum of n elements
    require
      non_negative_capacity: n >= 0
    ensure
      capacity_set: capacity = n
    end
feature -- Access
capacity: INTEGER -- Maximum number of stack elements
count: INTEGER -- Number of stack elements
item: G is -– Top element
    require
      not_empty: not empty
    end
feature -- Status report
empty: BOOLEAN is –- Is stack empty?
    ensure
      empty_definition: Result = (count = 0)
    end
full: BOOLEAN is –- Is stack full?
    ensure
      full_definition: Result = (count = capacity)
    end
feature -- Element change
put (x: G) is –- Add x on top
    require
      not_full: not full
    ensure
      not_empty: not empty
      added_to_top: item = x
      one_more_item: count = old count + 1
    end
remove is -– Remove top element
    require
      not_empty: not empty
    ensure
      not_full: not full
      one_fewer: count = old count - 1
    end
invariant
count_non_negative: 0 <= count
count_bounded: count <= capacity
empty_if_no_elements: empty = (count = 0)
end -– class interface STACK
-- PL/SQL "equivalent":
-- Stack implementation - TABLE of INTEGER.
-- Eiffel has generic classes (like C++ templates and better than Java generics).
-- PL/SQL (now) has not generic classes or generic packages.
CREATE OR REPLACE TYPE array_t AS TABLE OF INTEGER
-- utility package:
CREATE OR REPLACE PACKAGE dbc AS
-- 0 = no check
-- 1 = check preconditions
-- 2 = check preconditions + postconditions
-- 3 = check preconditions + postconditions + invariants
c_no_check                  CONSTANT INTEGER := 0;
c_check_preconditions       CONSTANT INTEGER := 1;
c_check_pre_postconditions CONSTANT INTEGER := 2;
c_check_pre_post_invariants CONSTANT INTEGER := 3;
FUNCTION check_preconditions       RETURN BOOLEAN;
FUNCTION check_pre_postconditions RETURN BOOLEAN;
FUNCTION check_pre_post_invariants RETURN BOOLEAN;
PROCEDURE set_level (p_level INTEGER);
PROCEDURE display_error (p_error VARCHAR2);
END;
CREATE OR REPLACE PACKAGE BODY dbc AS
m_level INTEGER := c_no_check;
FUNCTION check_preconditions RETURN BOOLEAN IS
BEGIN
    IF m_level >= c_check_preconditions THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
FUNCTION check_pre_postconditions RETURN BOOLEAN IS
BEGIN
    IF m_level >= c_check_pre_postconditions THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
FUNCTION check_pre_post_invariants RETURN BOOLEAN IS
BEGIN
    IF m_level >= c_check_pre_post_invariants THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
PROCEDURE set_level (p_level INTEGER) IS
BEGIN
    IF p_level NOT IN
      (c_no_check, c_check_preconditions, c_check_pre_postconditions, c_check_pre_post_invariants)
    THEN
      RAISE_APPLICATION_ERROR (-20000, 'Wrong checking level');
    END IF;
    m_level := p_level;
END;
PROCEDURE display_error (p_error VARCHAR2) IS
BEGIN
    RAISE_APPLICATION_ERROR (-20000, 'ERROR in method ' || p_error);
END;
END;
CREATE OR REPLACE TYPE stack AS OBJECT (
-- Maximum number of stack elements
capacity INTEGER,
-- Number of stack elements
el_count INTEGER,
-- Stack implementation
stack_implementation array_t,
-- Alocate stack for a maximum of n elements
CONSTRUCTOR FUNCTION stack (n INTEGER) RETURN SELF AS RESULT,
-- Top element
MEMBER FUNCTION item (SELF IN OUT stack) RETURN INTEGER,
-- Is stack empty?
MEMBER FUNCTION empty RETURN BOOLEAN,
-- Is stack full?
MEMBER FUNCTION full RETURN BOOLEAN,
-- Add x on top
MEMBER PROCEDURE put (x INTEGER),
-- Remove top element
MEMBER PROCEDURE remove,
-- INVARIANTS
-- Note:
-- If subprogram is declared in an object type body (in PL/SQL 8i/9i/10g)
-- it must be defined in the object type specification too.
MEMBER FUNCTION count_non_negative RETURN BOOLEAN,
MEMBER FUNCTION count_bounded RETURN BOOLEAN,
MEMBER FUNCTION empty_if_no_elements RETURN BOOLEAN,
MEMBER PROCEDURE check_invariants
) NOT FINAL;
CREATE OR REPLACE TYPE BODY stack AS
CONSTRUCTOR FUNCTION stack (n INTEGER) RETURN SELF AS RESULT IS
BEGIN
    IF dbc.check_preconditions AND n < 0 THEN
      dbc.display_error ('stack - PRE');
    END IF;
    check_invariants;
    capacity := n;
    stack_implementation := array_t();
    stack_implementation.EXTEND (n);
    IF dbc.check_pre_postconditions AND capacity <> n THEN
      dbc.display_error ('stack - POST');
    END IF;
    check_invariants;
END;
MEMBER FUNCTION item (SELF IN OUT stack) RETURN INTEGER IS
BEGIN
    IF dbc.check_preconditions AND empty THEN
      dbc.display_error ('item - PRE');
    END IF;
    check_invariants;
    RETURN stack_implementation(el_count);
END;
MEMBER FUNCTION empty RETURN BOOLEAN IS
BEGIN
    IF el_count = 0 THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
MEMBER FUNCTION full RETURN BOOLEAN IS
BEGIN
    IF el_count = capacity THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
MEMBER PROCEDURE put (x INTEGER) IS
BEGIN
    IF dbc.check_preconditions AND full THEN
      dbc.display_error ('put - PRE');
    END IF;
    check_invariants;
    el_count := el_count + 1;
    stack_implementation(el_count) := x;
    -- PL/SQL has not Eiffel's OLD
    -- one_more_item: count = old count + 1
    IF dbc.check_pre_postconditions AND (empty OR item <> x) THEN
      dbc.display_error ('put - POST');
    END IF;
    check_invariants;
END;
MEMBER PROCEDURE remove IS BEGIN
    IF dbc.check_preconditions AND empty THEN
      dbc.display_error ('remove - PRE');
    END IF;
    check_invariants;
    el_count := el_count - 1;
    -- PL/SQL has not Eiffel's OLD
    -- one_fewer: count = old count - 1
    IF dbc.check_pre_postconditions AND full THEN
      dbc.display_error ('remove - POST');
    END IF;
    check_invariants;
END;
-- INVARIANTS
MEMBER FUNCTION count_non_negative RETURN BOOLEAN IS
BEGIN
    IF el_count >= 0 THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
MEMBER FUNCTION count_bounded RETURN BOOLEAN IS
BEGIN
    IF el_count <= capacity THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
MEMBER FUNCTION empty_if_no_elements RETURN BOOLEAN IS
BEGIN
    IF empty AND (el_count = 0)
       OR
       NOT empty AND (el_count <> 0)
    THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
MEMBER PROCEDURE check_invariants IS
BEGIN
    IF NOT dbc.check_pre_post_invariants THEN
      RETURN; -- without checking invariants
    END IF;
    IF NOT count_non_negative THEN
      dbc.display_error ('INVARIANT count_non_negative');
    END IF;
    IF NOT count_bounded THEN
      dbc.display_error ('INVARIANT count_bounded');
    END IF;
    IF NOT empty_if_no_elements THEN
      dbc.display_error ('INVARIANT empty_if_no_elements');
    END IF;
END;
END; -- class body STACK
/Regards,
Zlatko Sirotic

Object-Oriented Programming

I'm working on a code associated with object-oriented programming:
The StreetAddress class has this constructor:
StreetAddress( String street, String city,
               String state, String zip );
and the following methods:
void SetStreet( String street ); and String GetStreet();
void SetCity( String city); and String GetCity();
void SetState( String state ); and String GetState();
void SetZIP( String zip ); and String GetZIP();
String MailingLabel();.
The last of these returns the mailing address in the following form:
street
city, state zipand this is what i have so far:
public class StretAddress
private String myStreet;
private String myCity;
private String myState;
private String myZip;
public StreetAddress( String street, String city, String state, String zip)
    myStreet = street;
    myCity = city;
    myState = state;
    myZip = zip;
public String getStreet()
      return myStreet;
public void SetStreet( String street )
    myStreet = street;
public String getCity()
      return myCity;
public void SetCity( String city )
    myCiy = city;
public String getState()
     return myState;
public void SetState( String state )
    myState = state;
public String getZip()
    return myZip;
public void SetZip( String zip )
    myZip = zip;
public String MailingLabel()
System.out.println(street \n city, state + " " + zip);
}I have no idea what to do now, can someone please help me with this?

ejp wrote:
personally, i don't think you need all four in order to be object-oriented.Without all four it might be class-based, or object-based, but not object-oriented. See Peter Wegner's paper which defined all this in 1987:
http://www.cse.msu.edu/~stire/cse891f04/wegner.pdf
With all due respect, I find this "definition" more meaningful:
http://www.youtube.com/watch?v=bfx7tvGisbA

Article: Object-flow Programming - Merging Dataflow and Object-Oriented Programming

I just posted an ExpressionFlow article:
Object-flow Programming - Merging Dataflow and Object-Oriented Programming
I guess you may find it interesting. If you like it, you should
bookmark it with one of the social bookmarking tools (click the
bookmark link next to the timeline image in the article). That may help
us to get readers and comments from outside the LabVIEW community. And
don't hesitate to participate the discussion. I'd love to hear you
comments on the subject.
Tomi
Tomi Maila

After having problems with spam block software malfunction, I was able recover the following comments to the EXPRESSIONFLOW article Object-flow Programming - Merging Dataflow and Object-Oriented Programming
Written by Zen:
Some combination of data-flow and object-oriented programming, I think,
could make a great impact on sysytem development. However, I see it in
slightly different way than yours....
Written by Matt Holt:
I don't believe NI can get object-flow programming to move far enough
into mainstream that Forbes would cover it. NI has a bit of a
stranglehold on LabVIEW with it's price as compared to say… VS2005. It
seems that by promoting it as "easy to use" that NI may have shot
itself in the foot….
Written by Jim Kring:
Hi Tomi, In my opinion, LabVIEW's native object-oriented programming
capabilities (LabVOOP) do not currently provide a complete tool for
allowing us to implement our OOP system designs. Nearly all of my
system designs require distributed active objects by reference. I think
that National Instruments certainly can evolve LabVIEW to address such
requirements, but I think that it is not a real focus of NI....
If anybody else is missing their comments, I'm sorry I was unable to recover them. Please repost your comments, I appology for the inconvenience.
Tomi Maila

Join Query in Object Oriented Programming

Hi,
I am trying to understand better how OO programming should work in CFC context. For example, I have two database tables: Customer and Order. So I create two CFCs, one for Customer and another for Order. In the CFCs I have query functions (select, insert, update) to access and manipulate data in the underlying tables.
Now, I need to create a new CFC, OrderReport. This CFC takes in customerID and returns data pulled from both Customer and Order tables. I can just have a join query that pulls data from these two tables. However, I have been wondering whether this method is within the spirit of Object Oriented programming. Should this CFC be able to access directly to the two tables? Or should I pull data separately using Customer CFC and Order CFC, and join them locally (ie. in OrderReport CFC)? This latter method would be a lot slower to run than the first method.
Can you advise me as to what the best practice is in the context of OO programming? Thank you.

This is a common question for those new to OO programming. Here are some of
my thoughts on the topic.
OO programming has nothing to do with tables. Your tables are essentially a
relational storage of one part of a business concept. It just so happens
that most of the data you need to support the business concept of Customer
and the business concept of Order are stored in tables named Customer and
Order. This is because database tables often relate to a business concept. I
think you'd find that to get the entire customer, you'd have to get data
from other tables, like State and Gender and other such tables.
The reason why I bring this up is to begin to separate your thinking.
Databases are concerned with efficient storage and retrieval of data.
Objects (CFCs) are not concerned at all with storage of data. Objects are
concerned with encapsulating business logic relating to a business concept.
Just like your database may have columns not needed by your CFCs, your CFCs
likely have methods not needed by your database.
For example, if you wanted to know, in your application, whether to show an
In Store Pickup option, you may wish to add an isLocal() method to your
customer object. This would ( we'll pretend) get the customer's zip code,
and look it up in GeographicalPostalServiceMapper object to tell us how far
away the customer is.
The point is, the right OO (CFC) design has nothing to do with how your
tables are organized in the database. You would do well to concern yourself
with the needs of the application and what sort of questions you need your
customer object to be able to answer to the other parts of your application.
Like, isLocal(), isOver21(), isBadCreditRisk() and so on.
As to your question about joins, you would do well to use joins in your
application. Do not be afraid of using queries to get the information you
need. Especially for reporting queries. In these cases, I often make an
object called a xxxList. My CustomerList.cfc would have the different ways
to list customer data, like CustomerOrders and CustomerOrderReturns. I'd
hide this join relationship inside of the CustomerList object so only the
CustomerList object has the SQL. That's usually enough encapsulation for the
needs of my application.
Truly, it doesn't matter what the name of the object is, just that you
assign it the responsibility of managing a business concept and keep that
business concept inside that object. You seem to have suggested
CustomerReport.cfc and that would be a fine name for an object that can
return numerous Customer Reports.
Happy Coding
DW

Who has the book:Object-Oriented Programming with ABAP Objects

Similar Messages

Maybe you are looking for