That was Awesome! I got real exam questions of 000-633 exam.

000-633 practice exam | 000-633 practice questions | 000-633 free practice tests | 000-633 free pdf download | 000-633 practice questions - partillerocken.com



000-633 - Object Oriented Analysis and Design - Part 1 - Dump Information

Vendor : IBM
Exam Code : 000-633
Exam Name : Object Oriented Analysis and Design - Part 1
Questions and Answers : 105 Q & A
Updated On : April 25, 2019
PDF Download Mirror : Pass4sure 000-633 Dump
Get Full Version : Pass4sure 000-633 Full Version


Preparing 000-633 exam with Q&A is matter of some hours now.

Failure to lie in the ones which means that it become those very moments that we couldnt discover ways to forget about but now we all recognize that whether or now not there was a few purpose to the little thing that we couldnt now not see simply yet the ones stuff that we werent speculated to recognise so now you should realize that I cleared my 000-633 test and it became higher than whatever and yes I did with partillerocken and it wasnt this kind of terrible factor in any respect to observe on line for a exchange and now not sulk at domestic with my books.

attempt out those actual 000-633 modern-day and up to date dumps.

partillerocken has pinnacle products for university students due to the truth the ones are designed for the ones students who are inquisitive about the training of 000-633 certification. It became exquisite selection because of the fact 000-633 exam engine has fantastic test contents which can be smooth to understand in brief time frame. I am grateful to the amazing crewbecause this helped me in my profession improvement. It helped me to apprehend a way to solution all essential questions to get maximum markss. It changed into brilliant choice that made me fan of partillerocken. i have decided to come back one moretime.

Do you need Latest dumps of 000-633 exam to pass the exam?

If you want right 000-633 training on how it works and what are the exams and all then dont waste your time and opt for partillerocken as it is an ultimate source of help. I also wanted 000-633 training and I even opted for this wonderful exam simulator and got myself the best training ever. It guided me with every aspect of 000-633 exam and provided the best questions and answers I have ever seen. The study guides also were of very much help.

Very comprehensive and authentic Q&A of 000-633 exam.

we all recognize that clearing the 000-633 test is a huge deal. I were given my 000-633 check cleared that i was so content simply due to partillerocken that gave me 87% marks.

tremendous source of notable actual test questions, accurate answers.

I was about to give up exam 000-633 because I wasnt confident in whether I would pass or not. With just a week remaining I decided to switch to partillerocken Q&A for my exam preparation. Never thought that the topics that I had always run away from would be so much fun to study; its easy and short way of getting to the points made my preparation lot easier. All thanks to partillerocken Q&A, I never thought I would pass my exam but I did pass with flying colors.

000-633 exam is not any more hard with those QAs.

Thanks to 000-633 exam sell off, I sooner or later were given my 000-633 Certification. I failed this exam the primary time round, and knew that this time, it become now or never. I nevertheless used the reliable e book, however kept practicing with partillerocken, and it helped. Last time, I failed by way of a tiny margin, actually missing some factors, but this time I had a solid pass score. partillerocken focused exactly what youll get on the exam. In my case, I felt they were giving to tons attention to various questions, to the point of asking irrelevant stuff, however thankfully I became prepared! Mission accomplished.

What is needed to clear 000-633 exam?

I favored to tell you that during beyond in idea that i would in no manner be capable of skip the 000-633 test. However after I take the 000-633 training then I got here to understand that the net offerings and dump is the fine bro! And when I gave the tests I passed it in first strive. I informed my friends approximately it, in addition they starting the 000-633 schooling shape right here and locating it simply top notch. Its my extraordinary enjoy ever. Thanks

am i able to find state-of-the-art dumps Q & A of 000-633 exam?

I passed 000-633 paper Within two weeks,thanks for your extraordinary QA test materials.Score 96 percentage. I am very assured now that I will do better in my remaining 3 Exams and honestly use your practice dump and propose it to my pals. Thank you very a great deal to your top class online trying out engine product.

how many days education required to bypass 000-633 examination?

I passed. Genuine, the exam become tough, so I simply got beyond it due to partillerocken Q&A and Exam Simulator. I am upbeat to record that I passed the 000-633 exam and feature as of past due acquired my assertion. The framework questions have been the element I turned into most stressed over, so I invested hours honing at the partillerocken exam simulator. It beyond any doubt helped, as consolidated with different segments.

Where can I find 000-633 Latest dumps questions?

Like many others, I actually have currently handed the 000-633 exam. In my case, widespread majority of 000-633 exam questions came precisely from this manual. The solutions are accurate, too, so if you are preparing to take your 000-633 exam, you could completely rely on this internet site.

See more IBM dumps

LOT-825 | 000-M50 | 000-M224 | 000-M646 | A2010-591 | A2160-667 | 000-596 | C2020-013 | 000-087 | 000-834 | C9510-669 | C2070-585 | BAS-010 | P2070-048 | 000-864 | A4040-129 | M2060-729 | 000-001 | C2090-304 | 00M-648 | 000-084 | 000-379 | M9520-233 | 000-079 | 000-907 | 000-M39 | 000-234 | 000-M97 | 000-714 | 000-594 | 000-274 | LOT-412 | A2180-181 | 000-007 | P6040-017 | C2180-529 | 000-M01 | C9530-001 | C2140-820 | 000-850 | 000-014 | 000-215 | 000-541 | LOT-828 | 000-350 | 000-867 | 000-123 | C2040-442 | P2140-020 | 000-284 |

Latest Exams added on partillerocken

156-727-77 | 1Z0-936 | 1Z0-980 | 1Z0-992 | 250-441 | 3312 | 3313 | 3314 | 3V00290A | 7497X | AZ-302 | C1000-031 | CAU301 | CCSP | DEA-41T1 | DEA-64T1 | HPE0-J55 | HPE6-A07 | JN0-1301 | PCAP-31-02 | 1Y0-340 | 1Z0-324 | 1Z0-344 | 1Z0-346 | 1Z0-813 | 1Z0-900 | 1Z0-935 | 1Z0-950 | 1Z0-967 | 1Z0-973 | 1Z0-987 | A2040-404 | A2040-918 | AZ-101 | AZ-102 | AZ-200 | AZ-300 | AZ-301 | FortiSandbox | HP2-H65 | HP2-H67 | HPE0-J57 | HPE6-A47 | JN0-662 | MB6-898 | ML0-320 | NS0-159 | NS0-181 | NS0-513 | PEGACPBA73V1 | 1Z0-628 | 1Z0-934 | 1Z0-974 | 1Z0-986 | 202-450 | 500-325 | 70-537 | 70-703 | 98-383 | 9A0-411 | AZ-100 | C2010-530 | C2210-422 | C5050-380 | C9550-413 | C9560-517 | CV0-002 | DES-1721 | MB2-719 | PT0-001 | CPA-REG | CPA-AUD | AACN-CMC | AAMA-CMA | ABEM-EMC | ACF-CCP | ACNP | ACSM-GEI | AEMT | AHIMA-CCS | ANCC-CVNC | ANCC-MSN | ANP-BC | APMLE | AXELOS-MSP | BCNS-CNS | BMAT | CCI | CCN | CCP | CDCA-ADEX | CDM | CFSW | CGRN | CNSC | COMLEX-USA | CPCE | CPM | CRNE | CVPM | DAT | DHORT | CBCP | DSST-HRM | DTR | ESPA-EST | FNS | FSMC | GPTS | IBCLC | IFSEA-CFM | LCAC | LCDC | MHAP | MSNCB | NAPLEX | NBCC-NCC | NBDE-I | NBDE-II | NCCT-ICS | NCCT-TSC | NCEES-FE | NCEES-PE | NCIDQ-CID | NCMA-CMA | NCPT | NE-BC | NNAAP-NA | NRA-FPM | NREMT-NRP | NREMT-PTE | NSCA-CPT | OCS | PACE | PANRE | PCCE | PCCN | PET | RDN | TEAS-N | VACC | WHNP | WPT-R | 156-215-80 | 1D0-621 | 1Y0-402 | 1Z0-545 | 1Z0-581 | 1Z0-853 | 250-430 | 2V0-761 | 700-551 | 700-901 | 7765X | A2040-910 | A2040-921 | C2010-825 | C2070-582 | C5050-384 | CDCS-001 | CFR-210 | NBSTSA-CST | E20-575 | HCE-5420 | HP2-H62 | HPE6-A42 | HQT-4210 | IAHCSMM-CRCST | LEED-GA | MB2-877 | MBLEX | NCIDQ | VCS-316 | 156-915-80 | 1Z0-414 | 1Z0-439 | 1Z0-447 | 1Z0-968 | 300-100 | 3V0-624 | 500-301 | 500-551 | 70-745 | 70-779 | 700-020 | 700-265 | 810-440 | 98-381 | 98-382 | 9A0-410 | CAS-003 | E20-585 | HCE-5710 | HPE2-K42 | HPE2-K43 | HPE2-K44 | HPE2-T34 | MB6-896 | VCS-256 | 1V0-701 | 1Z0-932 | 201-450 | 2VB-602 | 500-651 | 500-701 | 70-705 | 7391X | 7491X | BCB-Analyst | C2090-320 | C2150-609 | IIAP-CAP | CAT-340 | CCC | CPAT | CPFA | APA-CPP | CPT | CSWIP | Firefighter | FTCE | HPE0-J78 | HPE0-S52 | HPE2-E55 | HPE2-E69 | ITEC-Massage | JN0-210 | MB6-897 | N10-007 | PCNSE | VCS-274 | VCS-275 | VCS-413 |

See more dumps on partillerocken

ST0-250 | EX0-115 | FM0-307 | CFSW | LCP-001 | 7304 | FM0-308 | CTAL-TA | 190-712 | 000-657 | HP0-M47 | M2040-656 | ASC-012 | C2090-623 | HP0-921 | AHM-540 | 920-345 | MSC-121 | HCE-5710 | 000-023 | 000-555 | 1Z0-970 | 9A0-056 | 650-328 | 2B0-103 | 050-707 | 102-400 | BCP-223 | 70-537 | ST0-12W | M2060-730 | C2180-271 | A4040-332 | 1Z0-851 | HP0-P14 | NS0-141 | A2040-913 | C2020-004 | 000-035 | JK0-U21 | PK0-004 | 000-611 | 650-299 | C4060-156 | 050-634 | DTR | 700-280 | 000-588 | 9L0-511 | HP0-265 |

000-633 Questions and Answers

Pass4sure 000-633 dumps | Killexams.com 000-633 real questions | [HOSTED-SITE]

000-633 Object Oriented Analysis and Design - Part 1

Study Guide Prepared by Killexams.com IBM Dumps Experts

Exam Questions Updated On :



Killexams.com 000-633 Dumps and Real Questions

100% Real Questions - Exam Pass Guarantee with High Marks - Just Memorize the Answers



000-633 exam Dumps Source : Object Oriented Analysis and Design - Part 1

Test Code : 000-633
Test Name : Object Oriented Analysis and Design - Part 1
Vendor Name : IBM
Q&A : 105 Real Questions

WTF! questions have been exactly the equal in examination that I organized!
We need to discover ways to choose our brain simply the identical manner, we pick out out our garments everyday. This is the energy we are able to habitat.Having stated that If we need to do matters in our life, we should war difficult to recognize all its powers. I did so and worked tough on killexams.com to find out high-quality position in 000-633 exam with the assist of killexams.com that proved very energetic and extraordinary application to discover desired feature in 000-633 exam.It changed into a super application to make my existence relaxed.


Did you attempted this exceptional source of latest dumps.
I am scripting this because of the reality I want yo say way to you. I have effectively cleared 000-633 exam with 96%. The test monetary team series made via your organization is extremely good. It now not most effective gives a actual experience of an online exam but each offers every question with sure explananation in a easy language which is straightforward to recognize. I am extra than satisfied that I made the right desire by way of the use of shopping for your check series.


Are there properly sources for 000-633 test guides?
Handed 000-633 exam a few days in the past and were given a super score. However, I cant take complete credit score scorefor this as I used killexams.com to prepare for the 000-633 exam. Two weeks after kicking off my practice with their finding out engine, I felt like I knew the solution to any question that might come my way. And that i surely did. Each query I examine at the 000-633 exam, I had already seen it on the same time as practicing. If not each, then brilliant majority of them. Everything that become within the guidance percentage grew to become out to be very relevant and useful, so I cant thank enough to killexams.com for making it manifest for me.


What is needed to take a look at and bypass 000-633 exam?
I used killexams.com Q&a dump which provides sufficient information to obtain my purpose. I commonly commonly memorize the matters earlier than going for any exam, but this is the great one exam, which I took with out trulymemorizing the wished things. I thank you actually from the lowest of my heart. I am able to come to you for my next exam.


simply depend upon this 000-633 actual examination source.
Like many others, I have recently passed the 000-633 exam. In my case, vast majority of 000-633 exam questions came exactly from this guide. The answers are correct, too, so if you are preparing to take your 000-633 exam, you can fully rely on this website.


precisely equal questions, WTF!
I used to be alluded to the killexams.com dumps as brisk reference for my exam. Genuinely they executed a terrific pastime, i really like their overall performance and fashion of opemarks. The quick-length solutions were a lot less demanding to keep in brain. I handled ninety eight% questions scoring 80% marks. The exam 000-633 modified right into a noteworthy undertaking for my IT profession. On the equal time, I didnt make a contribution a lot time to set up my-self nicely for this exam.


000-633 actual query bank is real have a look at, authentic result.
Passing the 000-633 turned into lengthy due as i used to be extraordinarily busy with my office assignments. however, when i found the question & solution by means of the killexams.com, it certainly stimulated me to take on the test. Its been truely supportive and helped clear all my doubts on 000-633 topic. I felt very happy to pass the exam with a large 97% marks. wonderful achievement indeed. And all credit is going to you killexams.com for this terrific help.


am i able to locate real exam Q & A modern 000-633 examination?
If you want to change your destiny and make sure that happiness is your fate, you need to work hard. Working hard alone is not enough to get to destiny, you need some direction that will lead you towards the path. It was destiny that I found this killexams.com during my exams because it lead me towards my fate. My fate was getting good grades and this killexams.com and its teachers made it possible my teaching we so well that I couldnt possibly fail by giving me the material for my 000-633 exam.


Can I find actual test questions Q & A of 000-633 exam?
Yes, very useful and I was able to score 82% in the 000-633 exam with 5 days preparation. Especially the facility of downloading as PDF files in your package gave me a good room for effective practice coupled with online tests - no limited attempts restriction. Answers given to each question by you is 100% accurate. Thanks a lot.


Get %. ultra-modern information to prepare 000-633 exam. first-rate Q&A for you.
i am 000-633 licensed now, thanks to this killexams.com internet site. they have a top notch collection of brain dumps and exam preparation sources, I extensively utilized them for my 000-633 certification last yr, and this time their sftuff is simply as true. The questions are actual, and the exam simulator works high-quality. No troubles detected. I just ordered it, practiced for every week or so, then went in and passed the 000-633 exam. this is what the precise exam preparation must be like for all of us, I advise killexams.


IBM Object Oriented Analysis and

Object-Oriented analysis and Design | killexams.com Real Questions and Pass4sure dumps

This chapter is from the book 

analysis emphasizes an investigation of the issue and necessities, as opposed to an answer. for example, if a brand new on-line buying and selling equipment is preferred, how will it's used? What are its functions?

"analysis" is a broad time period, optimum certified, as in requirements analysis (an investigation of the requirements) or object-oriented analysis (an investigation of the area objects).

Design emphasizes a conceptual solution (in application and hardware) that fulfills the requirements, in place of its implementation. as an instance, an outline of a database schema and utility objects. Design ideas frequently exclude low-stage or "obvious" particulars—glaring to the supposed consumers. eventually, designs can also be applied, and the implementation (comparable to code) expresses the proper and finished realized design.

As with analysis, the time period is most suitable qualified, as in object-oriented design or database design.

valuable evaluation and design were summarized in the phrase do the correct aspect (evaluation), and do the element right (design).


UNICOM Nabs Versant for Object-Oriented Databases | killexams.com Real Questions and Pass4sure dumps

UNICOM increased into the article oriented database facts realm this month when it announced plans to purchase Versant, a publicly traded developer of a number of object-oriented databases, for roughly $32 million.

established in 1988 as Object Sciences Corp., Versant turned into an early proponent of object oriented databases, which keep records as objects. Object database administration techniques (ODBMS) deliver performance merits over relational database administration programs (RDBMS) in powering functions that are written in object oriented languages and require storing of complex objects.

Versant’s first product turned into the Versant Object Database (VOD), which begun to gain steam in the early Nineties and is still actively developed nowadays. VOD runs on Unix, Linux, and home windows working programs, and excels at working functions with excessive concurrency and performance necessities such as buying and selling structures, telecom community management techniques, airline and resort reservation techniques, and risk evaluation for banks, in keeping with the Wikipedia entry on Versant.

Versant changed its identify to Versant Object know-how in 1993, went public on the NASDAQ change in 1996, and altered its identify to Versant Corp. in 1999. In 2004, it obtained Poet application, the German developer of an ODBMS referred to as FastObjects. In 2008 Versant obtained an extra ODBMS, known as db40, which is an open source ODBMS project headquartered in 2000 via Carl Rosenberger.

these days, Versant continues to promote and enhance VOD, FastObjects, and db40. The company has struggled to generate sales over the last a number of years, as revenues have dropped from $25.3 million in 2008 to about $16.three million final yr. The enterprise, which is based mostly in Redwood city, California, has remained ecocnomic, despite the fact, and continues to develop new utility and are seeking for new shoppers and OEM partnerships with ISVs.

Versant’s board accepted the sale to UNICOM. The deal requires Versant shareholders to be paid $eleven.50 per typical share, a 17 percent top rate on Versant’s closing expense on September 28. The transaction is anticipated to complete earlier than the conclusion of Versant’s existing quarter ending January 31, 2013. Versant is free to are seeking choice offers through October 29.

“This merger will bring top rate price and liquidity to Versant’s shareholders. Versant is happy to associate with UNICOM to proceed to expand the enterprise’s market management position,” stated Versant president and CEO Bernhard Woebker in a statement.

The sentiment changed into echoed through Corry Hong, founder, president, and CEO of Mission Hills, California-based UNICOM, who noted that Versant’s Redwood city and Hamburg workplaces “will increase our current presence in both California and Germany.”

UNICOM has obtained a few utility companies over the closing several years, including SoftLanding systems, a developer of alternate management utility for the IBM i server.

connected experiences

UNICOM Wheels and offers for two Public groups

UNICOM Acquires ITSM and z/OS software companies

UNICOM Loses enchantment of SoftLanding Lawsuit

SoftLanding declares Sale on New IBM i package

UNICOM Loses in court docket, Forces SoftLanding valued clientele to upgrade

UNICOM Acquires Macro four, Sees i OS Synergy with SoftLanding equipment

SoftLanding programs received by CICS professional Unicom techniques

                     publish this story to del.icio.us               put up this story to Digg    publish this story to Slashdot


Frenemies: a quick history of Apple and IBM Partnerships | killexams.com Real Questions and Pass4sure dumps

although Apple and IBM have had their share of fights over the years, this week's deal isn't their first pairing.

IBM Apple Merger

Steve Jobs battled a couple of tech opponents, however within the early 80s, his ire changed into generally directed at IBM. The professional squabble dates returned to as a minimum 1981 with Apple's "Welcome, IBM. critically" advert, and apparently ended just the day past with a joint agreement to deliver IBM's commercial enterprise utility to iOS instruments later this 12 months. but whereas the organizations have certainly clashed over the closing 30 years, the day gone by's pairing changed into not the first time these two behemoths have teamed up.

Take AIMJust 10 years after the primary salvo become fired between Apple and IBM, the two joined with Motorola in 1991 to strengthen a common for the PowerPC structure that could go towards the Microsoft-Intel Wintel alliance. The Apple-Intel-Motorola (intention) group took IBM's power instruction set architecture and grew to become it into a customer-pleasant edition that become manufactured through IBM and Motorola and utilized in Apple's Macintosh line from 1994 to 2006, when Apple - to which Jobs back in 1997 - transitioned to Intel-based mostly machines.

"or not it's been ten years when you consider that our transition to the PowerPC, and we believe Intel's expertise will help us create the most efficient own computers for the subsequent ten years," Jobs said in asserting the movement.

From OS to Oh NoIn the late 80s, Apple become engaged on an object-oriented operating gadget, codenamed crimson. but it was having main issue pulling all of it together. within the wake of the purpose alliance, Apple turned to IBM for suggestions, and crimson changed into reborn as a joint task called Taligent with IBM's Joe Guglielmi at the helm.

The Taligent construction team worked away for 2 years, eventually switching from an object-oriented OS to an object-oriented programming ambiance that would work on any modern OS. however regardless of support from Hewlett-Packard, Taligent all but fizzled by means of the mid-90s. Guglielmi left the company for Motorola in 1995, and after his successor, Dick Guarino, died of a heart attack later that year, Taligent grew to be just yet another IBM subsidiary. It was formally dissolved in 1998.

Bullet and a TargetAfter being spurned by Microsoft on an object linking and embedding challenge, Apple approached IBM about engaged on it collectively in 1992. It resulted within the OpenDoc be aware-processing program and browser but failed to have what it took to move against Java. When he lower back to Apple, Jobs "put a bullet through [OpenDoc's] head," as he noted.

The Enemy of My EnemyIn the last twenty years, Apple and IBM have taken separate paths. IBM jettisoned its laptop enterprise and focused firmly on the business, making headlines alongside the manner for its artificial intelligence work on Watson. Apple, in the meantime, grew to become a customer darling, with clients lining as much as nab the business's latest phones and drugs. with the aid of coming lower back together, although, Apple delves additional into the enterprise with a partner it is universal in that space, whereas IBM receives to offer up products with a certain "cool" aspect and faucet into the Apple mystique.

For greater, take a look at Apple and IBM Bury the Hammer and IBM and Apple suggest enterprise.


Whilst it is very hard task to choose reliable exam questions / answers resources regarding review, reputation and validity because people get ripoff due to choosing incorrect service. Killexams. com make it certain to provide its clients far better to their resources with respect to exam dumps update and validity. Most of other peoples ripoff report complaint clients come to us for the brain dumps and pass their exams enjoyably and easily. We never compromise on our review, reputation and quality because killexams review, killexams reputation and killexams client self confidence is important to all of us. Specially we manage killexams.com review, killexams.com reputation, killexams.com ripoff report complaint, killexams.com trust, killexams.com validity, killexams.com report and killexams.com scam. If perhaps you see any bogus report posted by our competitor with the name killexams ripoff report complaint internet, killexams.com ripoff report, killexams.com scam, killexams.com complaint or something like this, just keep in mind that there are always bad people damaging reputation of good services due to their benefits. There are a large number of satisfied customers that pass their exams using killexams.com brain dumps, killexams PDF questions, killexams practice questions, killexams exam simulator. Visit Killexams.com, our test questions and sample brain dumps, our exam simulator and you will definitely know that killexams.com is the best brain dumps site.

[OPTIONAL-CONTENTS-2]


9A0-041 dumps questions | M2140-649 exam prep | 310-110 free pdf download | HP0-D09 practice test | MD0-235 test prep | 9A0-055 sample test | 300-206 test questions | QIA study guide | 000-603 braindumps | C9510-819 cram | 250-308 Practice test | 72-640 real questions | CSTE exam prep | F50-531 questions answers | 642-241 dump | HP0-J15 free pdf | 201-400 free pdf | C2020-011 real questions | HP0-S17 study guide | CMS7 practice test |


Precisely same 000-633 questions as in real test, WTF!
killexams.com IBM Certification is vital in career oportunities. Lots of students had been complaining that there are too many questions in such a lot of practice assessments and exam guides, and they are just worn-out to have enough money any more. Seeing killexams.com professionals work out this comprehensive version of brain dumps with real questions at the same time as nonetheless assure that just memorizing these real questions, you will pass your exam with good marks.

Are you searching out IBM 000-633 Dumps of actual questions for the Object Oriented Analysis and Design - Part 1 Exam prep? We provide most updated and Great 000-633 Dumps. Detail is at http://killexams.com/pass4sure/exam-detail/000-633. We have compiled a database of 000-633 Dumps from actual exams so as to permit you to prepare and pass 000-633 exam on the first attempt. Just memorize our Q&A and relax. You will pass the exam. killexams.com Huge Discount Coupons and Promo Codes are as beneath;
WC2017 : 60% Discount Coupon for all exams on website
PROF17 : 10% Discount Coupon for Orders extra than $69
DEAL17 : 15% Discount Coupon for Orders greater than $99
DECSPECIAL : 10% Special Discount Coupon for All Orders

The most ideal approach to get accomplishment in the IBM 000-633 exam is that you should achieve dependable preliminary materials. We guarantee that killexams.com is the greatest direct pathway closer to Implementing IBM Object Oriented Analysis and Design - Part 1 exam. You can be effective with full self conviction. You can see free questions at killexams.com sooner than you buy the 000-633 exam items. Our mimicked appraisals are in a few decision like the actual exam design. The questions and answers made by the ensured specialists. They offer you with the appreciate of taking the real exam. 100% guarantee to pass the 000-633 actual test.

killexams.com IBM Certification exam courses are setup by method for IT masters. Bunches of understudies have been griping that an excessive number of questions in such a ton of activity tests and exam courses, and they're simply exhausted to discover the cash for any more noteworthy. Seeing killexams.com experts instructional course this entire form in the meantime as in any case guarantee that every one the data is incorporated after profound research and assessment. Everything is to make comfort for hopefuls on their street to accreditation.

We have Tested and Approved 000-633 Exams. killexams.com gives the most right and latest IT exam materials which about contain all data references. With the guide of our 000-633 brain dumps, you don't need to squander your opportunity on examining greater part of reference books and just need to burn through 10-20 hours to ace our 000-633 actual questions and answers. Also, we furnish you with PDF Version and Software Version exam questions and answers. For Software Version materials, Its introduced to give the candidates reproduce the IBM 000-633 exam in a real domain.

We offer free supplant. Inside legitimacy length, if 000-633 brain dumps that you have acquired updated, we will advise you with the guide of email to down load best in class model of Q&A. if you don't pass your IBM Object Oriented Analysis and Design - Part 1 exam, We will give you full refund. You need to send the filtered imitation of your 000-633 exam record card to us. Subsequent to affirming, we will quick give you FULL REFUND.

killexams.com Huge Discount Coupons and Promo Codes are as under;
WC2017: 60% Discount Coupon for all exams on website
PROF17: 10% Discount Coupon for Orders greater than $69
DEAL17: 15% Discount Coupon for Orders greater than $99
DECSPECIAL: 10% Special Discount Coupon for All Orders


On the off chance that you set up together for the IBM 000-633 exam the utilization of our experimenting with engine. It is easy to prevail for all certifications in the first attempt. You don't must adapt to all dumps or any free deluge/rapidshare all stuff. We offer free demo of each IT Certification Dumps. You can test out the interface, question decent and ease of use of our activity appraisals before settling on a choice to purchase.

[OPTIONAL-CONTENTS-4]


Killexams HP0-064 questions and answers | Killexams 70-512-Csharp questions answers | Killexams 1Z0-514 mock exam | Killexams ST0-135 dump | Killexams 1Z0-321 dumps questions | Killexams COG-205 exam questions | Killexams 000-152 braindumps | Killexams C2160-667 braindumps | Killexams 312-50 test prep | Killexams CCP practice test | Killexams 000-226 test prep | Killexams 646-276 examcollection | Killexams 1Z1-591 real questions | Killexams HP3-C40 study guide | Killexams C2170-051 VCE | Killexams FM0-302 practice questions | Killexams 920-470 exam prep | Killexams 2V0-622 study guide | Killexams 0G0-081 test prep | Killexams PEGACPBA71V1 practice exam |


[OPTIONAL-CONTENTS-5]

View Complete list of Killexams.com Brain dumps


Killexams 9L0-062 practice exam | Killexams C8010-250 cheat sheets | Killexams 1Z0-595 VCE | Killexams 000-579 sample test | Killexams EE0-071 braindumps | Killexams 000-017 questions and answers | Killexams 250-824 brain dumps | Killexams C2040-928 questions answers | Killexams CTAL-TTA-001 free pdf | Killexams C2090-463 questions and answers | Killexams Hadoop-PR000007 free pdf | Killexams 000-342 pdf download | Killexams C9020-662 study guide | Killexams 6203-1 free pdf | Killexams 310-015 practice questions | Killexams 000-M249 test prep | Killexams 77-881 real questions | Killexams CWSP-205 mock exam | Killexams HP0-743 study guide | Killexams C2090-180 dumps questions |


Object Oriented Analysis and Design - Part 1

Pass 4 sure 000-633 dumps | Killexams.com 000-633 real questions | [HOSTED-SITE]

Object-oriented design patterns in the kernel, part 1 | killexams.com real questions and Pass4sure dumps

Please consider subscribing to LWN

Subscriptions are the lifeblood of LWN.net. If you appreciate this content and would like to see more of it, your subscription will help to ensure that LWN continues to thrive. Please visit this page to join up and keep LWN on the net.

June 1, 2011

This article was contributed by Neil Brown

Despite the fact that the Linux Kernel is mostly written in C, it makes broad use of some techniques from the field of object-oriented programming. Developers wanting to use these object-oriented techniques receive little support or guidance from the language and so are left to fend for themselves. As is often the case, this is a double-edged sword. The developer has enough flexibility to do really cool things, and equally the flexibility to do really stupid things, and it isn't always clear at first glance which is which, or more accurately: where on the spectrum a particular approach sits.

Instead of looking to the language to provide guidance, a software engineer must look to established practice to find out what works well and what is best avoided. Interpreting established practice is not always as easy as one might like and the effort, once made, is worth preserving. To preserve that effort on your author's part, this article brings another installment in an occasional series on Linux Kernel Design Patterns and attempts to set out - with examples - the design patterns in the Linux Kernel which effect an object-oriented style of programming.

Rather than providing a brief introduction to the object-oriented style, tempting though that is, we will assume the reader has a basic knowledge of objects, classes, methods, inheritance, and similar terms. For those as yet unfamiliar with these, there are plenty of resources to be found elsewhere on the web.

Over two weeks we will look for patterns in just two areas: method dispatch and data inheritance. Despite their apparent simplicity they lead to some rich veins for investigation. This first article will focus on method dispatch.

Method Dispatch

The large variety of styles of inheritance and rules for its usage in languages today seems to suggest that there is no uniform understanding of what "object-oriented" really means. The term is a bit like "love": everyone thinks they know what it means but when you get down to details people can find they have very different ideas. While what it means to be "oriented" might not be clear, what we mean by an "object" does seem to be uniformly agreed upon. It is simply an abstraction comprising both state and behavior. An object is like a record (Pascal) or struct (C), except that some of the names of members refer to functions which act on the other fields in the object. These function members are sometimes referred to a "methods".

The most obvious way to implement objects in C is to declare a "struct" where some fields are pointers to functions which take a pointer to the struct itself as their first argument. The calling convention for method "foo" in object "bar" would simply be: bar->foo(bar, ...args); While this pattern is used in the Linux kernel it is not the dominant pattern so we will leave discussion of it until a little later.

As methods (unlike state) are not normally changed on a per-object basis, a more common and only slightly less obvious approach is to collect all the methods for a particular class of objects into a separate structure, sometimes known as a "virtual function table" or vtable. The object then has a single pointer to this table rather than a separate pointer for each method, and consequently uses less memory.

This then leads to our first pattern - a pure vtable being a structure which contains only function pointers where the first argument of each is a pointer to some other structure (the object type) which itself contains a pointer to this vtable. Some simple examples of this in the Linux kernel are the file_lock_operations structure which contains two function pointers each of which take a pointer to a struct file_lock, and the seq_operations vtable which contains four function pointers which each operate on a struct seq_file. These two examples display an obvious naming pattern - the structure holding a vtable is named for the structure holding the object (possibly abbreviated) followed by "_operations". While this pattern is common it is by no means universal. Around the time of 2.6.39 there are approximately 30 "*_operations" structures along with well over 100 "*_ops" structures, most if not all of which are vtables of some sort. There are also several structs such as struct mdk_personality which are essentially vtables but do not have particularly helpful names.

Among these nearly 200 vtable structures there is plenty of variability and so plenty of scope to look for interesting patterns. In particular we can look for common variations from the "pure vtable" pattern described above and determine how these variations contribute to our understanding of object use in Linux.

NULL function pointers

The first observation is that some function pointers in some vtables are allowed to be NULL. Clearly trying to call such a function would be futile, so the code that calls into these methods generally contains an explicit test for the pointer being NULL. There are a few different reasons for these NULL pointers. Probably easiest to justify is the incremental development reason. Because of the way vtable structures are initialized, adding a new function pointer to the structure definition causes all existing table declarations to initialise that pointer to NULL. Thus it is possible to add a caller of the new method before any instance supports that method, and have it check for NULL and perform a default behavior. Then as incremental development continues those vtable instances which need it can get non-default methods.

A recent example is commit 77af1b2641faf4 adding set_voltage_time_sel() to struct regulator_ops which acts on struct regulator_dev. Subsequent commit 42ab616afe8844 defines that method for a particular device. This is simply the most recent example of a very common theme.

Another common reason is that certain methods are not particularly meaningful in certain cases so the calling code simply tests for NULL and returns an appropriate error when found. There are multiple examples of this in the virtual filesystem (VFS) layer. For instance, the create() function in inode_operations is only meaningful if the inode in question is a directory. So inode_operations structures for non-directories typically have NULL for the create() function (and many others) and the calling code in vfs_create() checks for NULL and returns -EACCES.

A final reason that vtables sometimes contain NULL is that an element of functionality might be being transitioned from one interface to another. A good example of this is the ioctl() operation in file_operations. In 2.6.11, a new method, unlocked_ioctl() was added which was called without the big kernel lock held. In 2.6.36, when all drivers and filesystems had been converted to use unlocked_ioctl(), the original ioctl() was finally removed. During this transition a file system would typically define only one of two, leaving the other defaulting to NULL.

A slightly more subtle example of this is read() and aio_read(), also in file_operations, and the corresponding write() and aio_write(). aio_read() was introduced to support asynchronous IO, and if it is provided the regular synchronous read() is not needed (it is effected using do_sync_read() which calls the aio_read() method). In this case there appears to be no intention of ever removing read() - it will remain for cases where async IO is not relevant such as special filesystems like procfs and sysfs. So it is still the case that only one of each pair need be defined by a filesystem, but it is not simply a transition, it is a long-term state.

Though there seem to be several different reasons for a NULL function pointer, almost every case is an example of one simple pattern - that of providing a default implementation for the method. In the "incremental development" examples and the non-meaningful method case, this is fairly straightforward. e.g. the default for inode->create() is simply to return an error. In the interface transition case it is only slightly less obvious. The default for unlocked_ioctl() would be to take the kernel lock and then call the ioctl() method. The default for read() is exactly do_sync_read() and some filesystems such as ext3 actually provide this value explicitly rather than using "NULL" to indicate a default.

With that in mind, a little reflection suggests that if the real goal is to provide a default, then maybe the best approach would be to explicitly give a default rather than using the circuitous route of using a default of NULL and interpreting it specially.

While NULL is certainly the easiest value to provide as a default - as the C standard assures us that uninitialized members of a structure do get set to NULL - it is not very much harder to set a more meaningful default. I am indebted to LWN reader wahern for the observation that C99 allows fields in a structure to be initialized multiple times with only the final value taking effect and that this allows easy setting of default values such as by following the simple model:

#define FOO_DEFAULTS .bar = default_bar, .baz = default_baz struct foo_operations my_foo = { FOO_DEFAULTS, .bar = my_bar, };

This will declare my_foo with a predefined default value for baz and a localized value for bar. Thus for the small cost of defining a few "default" functions and including a "_DEFAULTS" entry to each declaration, the default value for any field can easily be chosen when the field is first created, and automatically included in every use of the structure.

Not only are meaningful defaults easy to implement, they can lead to a more efficient implementation. In those cases where the function pointer actually is NULL it is probably faster to test and branch rather than to make an indirect function call. However the NULL case is very often the exception rather than the rule, and optimizing for an exception is not normal practice. In the more common case when the function pointer is not NULL, the test for NULL is simply a waste of code space and a waste of execution time. If we disallow NULLs we can make all call sites a little bit smaller and simpler.

In general, any testing performed by the caller before calling a method can be seen as an instance of the "mid-layer mistake" discussed in a previous article. It shows that the mid-layer is making assumptions about the behavior of the lower level driver rather than simply giving the driver freedom to behave in whatever way is most suitable. This may not always be an expensive mistake, but it is still best avoided where possible. Nevertheless there is a clear pattern in the Linux kernel that pointers in vtables can sometimes be NULLable, typically though not always to enable a transition, and the call sites should in these cases test for NULL before proceeding with the call.

The observant reader will have noticed a hole in the above logic denouncing the use NULL pointers for defaults. In the case where the default is the common case and where performance is paramount, the reasoning does not hold and a NULL pointer could well be justified. Naturally the Linux kernel provides an example of such a case for our examination.

One of the data structures used by the VFS for caching filesystem information is the "dentry". A "dentry" represents a name in the filesystem, and so each "dentry" has a parent, being the directory containing it, and an "inode" representing the named file. The dentry is separate from the inode because a single file can have multiple names (so an "inode" can have multiple "dentry"s). There is a dentry_operations vtable with a number of operations including, for example, "d_compare" which will compare two names and "d_hash" which will generate a hash for the name to guide the storage of the "dentry" in a hash table. Most filesystems do not need this flexibility. They treat names as uninterpreted strings of bytes so the default compare and hash functions are the common case. A few filesystems define these to handle case-insensitive names but that is not the norm.

Further, filename lookup is a common operation in Linux and so optimizing it is a priority. Thus these two operations appear to be good candidates where a test for NULL and an inlined default operation might be appropriate. What we find though is that when such an optimization is warranted it is not by itself enough. The code that calls d_compare() and d_hash() (and a couple of other dentry operations) does not test these functions for NULL directly. Rather they require that a few flag bits (DCACHE_OP_HASH, DCACHE_OP_COMPARE) in the "dentry" are set up to indicate whether the common default should be used, or whether the function should be called. As the flag field is likely to be in cache anyway, and the dentry_operations structure will often be not needed at all, this avoids a memory fetch in a hot path.

So we find that the one case where using a NULL function pointer to indicate a default could be justified, it is not actually used; instead, a different, more efficient, mechanism is used to indicate that the default method is requested.

Members other than function pointers

While most vtable-like structures in the kernel contain exclusively function pointers, there are a significant minority that have non-function-pointer fields. Many of these appear on the surface quite arbitrary and a few closer inspections suggest that some of them result of poor design or bit-rot and their removal would only improve the code.

There is one exception to the "functions only" pattern that occurs repeatedly and provides real value, and so is worth exploring. This pattern is seen in its most general form in struct mdk_personality which provides operations for a particular software RAID level. In particular this structure contains an "owner", a "name", and a "list". The "owner" is the module that provides the implementation. The "name" is a simple identifier: some vtables have string names, some have numeric names, and it is often called something different like "version", "family", "drvname", or "level". But conceptually it is still a name. In the present example there are two names, a string and a numeric "level".

The "list", while part of the same functionality, is less common. The mdk_personality structure has a struct list_head, as does struct ts_ops. struct file_system_type has a simple pointer to the next struct file_system_type. The underlying idea here is that for any particular implementation of an interface (or "final" definition of a class) to be usable, it must be registered in some way so that it can be found. Further, once it has been found it must be possible to ensure that the module holding the implementation is not removed while it is in use.

There seem to be nearly as many styles of registration against an interface in Linux as there are interfaces to register against, so finding strong patterns there would be a difficult task. However it is fairly common for a "vtable" to be treated as the primary handle on a particular implementation of an interface and to have an "owner" pointer which can be used to get a reference on the module which provides the implementation.

So the pattern we find here is that a structure of function pointers used as a "vtable" for object method dispatch should normally contain only function pointers. Exceptions require clear justification. A common exception allows a module pointer and possible other fields such as a name and a list pointer. These fields are used to support the registration protocol for the particular interface. When there is no list pointer it is very likely that the entire vtable will be treated as read-only. In this case the vtable will often be declared as a const structure and so could even be stored in read-only memory.

Combining Methods for different objects

A final common deviation from the "pure vtable" pattern that we see in the Linux kernel occurs when the first argument to the function is not always the same object type. In a pure vtable which is referenced by a pointer in a particular data structure, the first argument of each function is exactly that data structure. What reason could there be for deviating from that pattern? It turns out that there are few, some more interesting than others.

The simplest and least interesting explanation is that, for no apparent reason, the target data structure is listed elsewhere in the argument list. For example all functions in struct fb_ops take a struct fb_info. While in 18 cases that structure is the first argument, in five cases it is the last. There is nothing obviously wrong with this choice and it is unlikely to confuse developers. It is only a problem for data miners like your author who need to filter it out as an irrelevant pattern.

A slight deviation on this pattern is seen in struct rfkill_ops where two functions take a struct rkfill but the third - set_block() - takes a void *data. Further investigation shows that this opaque data is exactly that which is stored in rfkill->data, so set_block() could easily be defined to take a struct rfkill and simply to follow the ->data link itself. This deviation is sufficiently non-obvious that it could conceivably confuse developers as well as data miners and so should be avoided.

The next deviation in seen for example in platform_suspend_ops, oprofile_operations, security_operations and a few others. These take an odd assortment of arguments with no obvious pattern. However these are really very different sorts of vtable structures in that the object they belong to are singletons. There is only one active platform, only one profiler, only one security policy. Thus the "object" on which these operations act is part of the global state and so does not need to be included in the arguments of any functions.

Having filtered these two patterns out as not being very interesting we are left with two that do serve to tell us something about object use in the kernel.

quota_format_ops and export_operations are two different operations structures that operate on a variety of different data structures. In each case the apparent primary object (e.g. a struct super_block or a struct dentry) already has a vtable structure dedicated to it (such as super_operations or dentry_operations) and these new structures add new operations. In each case the new operations form a cohesive unit providing a related set of functionality - whether supporting disk quotas or NFS export. They don't all act on the same object simply because the functionality in question depends on a variety of objects.

The best term from the language of object-oriented programming for this is probably the "mixin". Though the fit may not be perfect - depending on what your exact understanding of mixin is - the idea of bringing in a collection of functionality without using strict hierarchical inheritance is very close to the purpose of quota_format_ops and export_operations.

Once we know to be on the lookout for mixins like these we can find quite a few more examples. The pattern to be alert for is not the one that led us here - an operations structure that operates on a variety of different objects - but rather the one we found where the functions in an "operations" structure operate on objects that already have their own "operations" structure. When an object has a large number of operations that are relevant and these operations naturally group into subsets, it makes a lot of sense to divide them into separate vtable-like structures. There are several examples of this in the networking code where for instance both tcp_congestion_ops and inet_connection_sock_af_ops operate (primarily) on a struct sock, which itself has already got a small set of dedicated operations.

So the pattern of a "mixin" - at least as defined as a set of operations which apply to one or more objects without being the primary operations for those objects - is a pattern that is often found in the kernel and appears to be quite valuable in allowing better modularization of code.

The last pattern which explains non-uniform function targets is probably the most interesting, particularly in its contrast to the obvious application of object-oriented programming style. Examples of this pattern abound with ata_port_operations, tty_operations, nfs_rpc_ops and atmdev_ops all appearing as useful examples. However we will focus primarily on some examples from the filesystem layer, particularly super_operations and inode_operations.

There is a strong hierarchy of objects in the implementation of a filesystem where the filesystem - represented by a "super_block" - has a number of files (struct inode) which may have a number of names or links (struct dentry). Further each file might store data in the page cache (struct address_space) which comprises a number of individual pages (struct page). There is a sense in which all of these different objects belong to the filesystem as a whole. If a page needs to be loaded with data from a file, the filesystem knows how to do that, and it is probably the same mechanism for every page in every file. Where it isn't always the same, the filesystem knows that too. So we could conceivably store every operation on every one of these objects in the struct super_block, as it represents the filesystem and could know what to do in each case.

In practice that extreme is not really helpful. It is quite likely that while there are similarities between the storage of a regular file and a directory, there are also important differences and being able to encode those differences in separate vtables can be helpful. Sometimes small symbolic links are stored directly in the inode while larger links are stored like the contents of a regular file. Having different readlink() operations for the two cases can make the code a lot more readable.

While the extreme of every operation attached to the one central structure is not ideal, it is equally true that the opposite extreme is not ideal either. The struct page in Linux does not have a vtable pointer at all - in part because we want to keep the structure as small as possible because it is so populous. Rather the address_space_operations structure contains the operations that act on a page. Similarly the super_operations structure contains some operations that apply to inodes, and inode_operations contains some operations that apply to dentries.

It is clearly possible to have operations structures attached to a parent of the target object - providing the target holds a reference to the parent, which it normally does - though it is not quite so clear that it is always beneficial. In the case of struct page which avoids having a vtable pointer altogether the benefit is clear. In the case of struct inode which has its own vtable pointer, the benefit of having some operations (such as destroy_inode() or write_inode()) attached to the super_block is less clear.

As there are several vtable structures where any given function pointer could be stored, the actual choice is in many cases little more than historical accident. Certainly the proliferation of struct dentry operations in inode_operations seems to be largely due to the fact that some of them used to act directly on the inode, but changes in the VFS eventually required this to change. For example in 2.1.78-pre1, each of link(), readlink(), followlink() (and some others which are now defunct) were changed from taking a struct inode to take a struct dentry instead. This set the scene for "dentry" operations to be in inode_operations, so when setattr and getattr were added for 2.3.48, it probably seemed completely natural to include them in inode_operations despite the fact that they acted primarily on a dentry.

Possibly we could simplify things by getting rid of dentry_operations altogether. Some operations that act on dentries are already in inode_operations and super_operations - why not move them all there? While dentries are not as populous as struct page there are still a lot of them and removing the "d_op" field could save 5% of the memory used by that structure (on x86-64).

With two exceptions, every active filesystem only has a single dentry operations structure in effect. Some filesystem implementations like "vfat" define two - e.g. one with case-sensitive matching and one with case-insensitive matching - but there is only one active per super-block. So it would seem that the operations in dentry_operations could be moved to super_operations, or at least accessed through "s_d_op". The two exceptions are ceph and procfs. These filesystems use different d_revalidate() operations in different parts of the filesystem and - in the case of procfs - different d_release() operations. The necessary distinctions could easily be made in per-superblock versions of these operations. Do these cases justify the 5% space cost? Arguably not.

Directly embedded function pointers

Finally it is appropriate to reflect on the alternate pattern mentioned at the start, where function pointers are stored directly in the object rather than in a separate vtable structure. This pattern can be seen in struct request_queue which has nine function pointers, struct efi which has ten function pointers, and struct sock which has six function pointers.

The cost of embedded pointers is obviously space. When vtables are used, there is only one copy of the vtable and multiple copies of an object (in most cases) so if more than one function pointer is needed, a vtable would save space. The cost of a vtable is an extra memory reference, though cache might reduce much of this cost in some cases. A vtable also has a cost of flexibility. When each object needs exactly the same set of operations a vtable is good, but if there is a need to individually tailor some of the operations for each object, then embedded function pointer can provide that flexibility. This is illustrated quite nicely by the comment with "zoom_video" in struct pcmcia_socket

/* Zoom video behaviour is so chip specific its not worth adding this to _ops */

So where objects are not very populous, where the list of function pointers is small, and where multiple mixins are needed, embedded function pointers are used instead of a separate vtable.

Method Dispatch Summary

If we combine all the pattern elements that we have found in Linux we find that:

Method pointers that operate on a particular type of object are normally collected in a vtable associated directly with that object, though they can also appear:

  • In a mixin vtable that collects related functionality which may be selectable independently of the base type of the object.
  • In the vtable for a "parent" object when doing so avoids the need for a vtable pointer in a populous object
  • Directly in the object when there are few method pointers, or they need to be individually tailored to the particular object.
  • These vtables rarely contain anything other than function pointers, though fields needed to register the object class can be appropriate. Allowing these function pointers to be NULL is a common but not necessarily ideal technique for handling defaults.

    So in exploring the Linux Kernel code we have found that even though it is not written in an object-oriented language, it certainly contains objects, classes (represented as vtables), and even mixins. It also contains concepts not normally found in object-oriented languages such as delegating object methods to a "parent" object.

    Hopefully understanding these different patterns and the reasons for choosing between them can lead to more uniform application of the patterns across the kernel, and hence make it easier for a newcomer to understand which pattern is being followed. In the second part of our examination of object oriented patterns we will explore the various ways that data inheritance is achieved in the Linux kernel and discuss the strengths and weaknesses of each approach so as to see where each is most appropriate.

    (Log in to post comments)

    MET CS 770 Object-Oriented Analysis & Design | killexams.com real questions and Pass4sure dumps

    Last updated: November 13, 2002 Recent updates are often in red.

    Contacting Eric Braude changed if this is red Materials changed if this is red Forums changed if this is red Overview changed if this is red Grading changed if this is red Project Organization changed if this is red Homework and Due Dates changed if this is red        Phase 3 Required Background changed if this is red Learning Objectives changed if this is red Syllabus and Dates for Classes changed if this is red Overview

    A major engineering problem today is the predictable development of reliable software-intensive systems. The object-oriented paradigm is an important part of such development.

    Object-oriented methods can be divided into languages, distribution, and analysis and design. There change in the language category, particularly Java and C#. Distribution includes the use of vendor libraries of classes and also distributed objects as specified by the Object Management Group etc.  Basic to the entire enterprise, however, are analysis and design, which has remained remarkable stable for years. Object-Oriented Analysis and Design includes the overall goals of the object paradigm, the selection of classes, the relationships among them, and their utilization to implement systems.

    Required Background

    A knowledge of C++ or Java (MET CS 565) and software engineering methods (MET CS 673) are required.   It is preferable to have taken Design Patterns (MET CS 665).

    Materials and references

    The recommended textbook is “Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design, and the Unified Process ” by Larman (Prentice Hall) 2nd edition, Published July 2001, 627 pages, ISBN 0130925691.  This is the first time that this instructor has used this book, and it is not clear how much the book will be used.

    The instructor will provide notes for all classes.

    Other references:

  • The Unified Modeling Language User Guide by Booch et al (Prentice Hall) ISBN0-201-57168-4
  • The Unified Modeling Language Reference Manual James Rumbaugh, Ivar Jacobson, Grady Booch Addison-Wesley Pub Co; ISBN: 020130998X
  • Design Patterns by Gamma et al
  • Object-Oriented Software Engineering by I Jacobson
  • Object-Oriented Analysis & Design by G. Booch
  • Modeling the world in data by S. Schlaer and S. Mellor
  • Modeling the world in states by S. Schlaer and S. Mellor
  • The Unified Method draft www.rational.com
  • Object-oriented Analysis by P. Coad and E. Yourdon
  • Object-oriented Design by P. Coad and E. Yourdon
  • Object-oriented Programming by P. Coad and A Nicola
  • Software Engineering: An Object-Oriented Perspective by Eric Braude
  • Learning Objectives

    Students will be able to …

  • … analyze problems from an object perspective
  • … create OO designs which are ready for coding
  • … implement a pilot OO project
  • Grading

    The course will consist of homework and a project, weighted as follows:

    1.      Homework:                  30%

    2.      Project:                        70%

    There are three phases for the project, graded as follows:

  • phase 1 (problem statement):                            1/9
  • phase 2 (analysis):                                             2/9
  • phase 3 (design):                                               1/3
  • phase 4 (implementation and critical review): 1/3
  • Parts are evaluated equally unless otherwise stated.

    Late homework is not accepted unless there is a reason why it was impossible for you. If there is such an impossibility, the work will be graded on a pass/fail basis.

    Project Organization

    You will be required to submit an analyzed, designed and implemented project according to the deadlines shown in the schedule. Detailed requirements will follow.

    With the instructor’s permission, it may be possible to substitute all or part of the project with an investigation of tools for OOA&D such as Rational Rose or Together.  This will require a detailed evaluation and an investigation of how these tools are being used extensively in a particular company.

    Teams two are permitted, and will be evaluated at a higher standard. All members must know all parts.

    You will be required to give a presentation on at least two of the phases in your project.

    Syllabus:

    This syllabus is subject to about 15% modification.

    The order of topics will be driven by the notes, which the instructor will hand out, not by the textbook. The textbook will serve as background and reference.

    Wk. Date Topic Text

    chapters

    Project

    Times are approximate.  See “date homework due” section for final dates

    1 9/3
  • Review Syllabus
  • Review Software Development Process
  • Notes 0-1 Phase 1 assigned 2 9/10
  • Introduction, Overview, and Goals of Design
  • UML as required
  • Extreme programming and refactoring
  • Notes 1-3 3 9/17
  • Requirements I: Use Cases
  • Notes 13 part 1 Presentations;

    Assign phase 2

    4 9/24
  • Requirements II: Sequence Diagrams
  • Notes 13 part 2 Phase 1 due; 5 10/1
  • Requirements III:  Completing Domain Classes
  • Writing Detailed Requirements
  • Review Student Designs
  • Notes 13 part 3

    Larman 10

    6 10/8 Notes 14 part 1 Assign phase 3 7 10/22 To be determined Presentations; Phase 2 due; 8 10/29
  • Review Design Patterns as required
  • Discussion of Tools
  • Review Student Designs
  • Notes 4-6 9 11/5
  • Frameworks
  • Review Student Designs
  • Presentations on architectures 10 11/12
  • Design Topics
  • Review Student Designs
  • Notes 14 part 2 Assign phase 4

    Phase 3 due

    11 11/19 Presentations on detailed designs 12 11/26
  • Detailed Design
  • Review Student Designs
  • Presentations 13 12/3
  • Implementing OO designs
  • Shlaer-Mellor
  • Presentation of results (1 of 2) 14 12/10
  • Presentations on Finished Applications
  • Phase 4 due Presentation of results (2 of 2)
  • Notes are from Software Design (Braude, to be published by Wiley in March 2002)
  • ** Applying UML and Patterns: … (Larman)
  • Dates Homework is due

    Num-ber Name Due date Project phase 1 9/24 1 “Design Issues” 9/17 1 3.4 (Pass Fail) 9/17 Project phase 2: (10/2/2002

    )

    1.Attach first a copy of your phase 1.  Respond specifically to whatever comments I may have made on your phase 1.   You can write these directly on the copy.

    2.

    Show the sequence diagrams for at least the two use cases you have introduced.  Key them to the use case steps, which you should number.3.List requirements by “domain class” paragraphs, including

    — The testable functionality that the application will definitely accomplish

    –What you would like to have the application accomplish if time permits

    Criterion: a. Requirements clearly written. (A = very clear description of application’s goals; no detail omitted)

    4.Provide a class diagram for your project consisting of all of the domain classes as well as the domain packages that you will use.

    Criteria:

    b. Clarity and completeness Sufficiency of key classes for committed requirements and use cases (A = very clear class meanings; no domain class missing no other domain classes required)

    g. Economy (A = no redundancy at all in the class model)

    Here are some typical improvements.

    Most room for improvement

    1.      Make your domain names specific to your application; e.g., PetStoreTransaction, FootballGame, FootballTeam rather than Transaction or Game or Team.

    2.      Use the “entities” section correctly.  This applies when there are specific entities that the application is required to have. It does not include entities that will be created at runtime that you can’t specify entirely at requirements time.

    3.      Many internal classes have corresponding GUI classes.  For example, PetStoreAccount entities may get their data from a PetStoreAccountGUI entity.  Specify the latter in its own category rather than under PetStoreAccount.

    4.      In your requirements, distinguish between the initiator and the substance of functionality.

    For example, under “Courses” a functionality might be “12.1.5 The application shall be able to display the catalog description of each course in the following format …”  (Corresponds to class Course).  Under the “Course GUI” paragraph an event might be “When the display course button is pressed, the functionality described in section 12.1.5 is initated.”  Under the “Student GUI” paragraph an event might be “When the show course button is pressed, the functionality described in section 12.1.5 is initated.” Etc.

    Do not say “12.1.5 When the display course button is pressed on the Course GUI, the application can display the catalog description of each course in the following format …”  Otherwise you will have a maintenance nightmare and a poor mapping to the design and implementation.

    5.

    Room for improvement

    1. Most

    2.

    3.

    4.

    5.

    6.

    7.

    objects are not sensitive to events unless they are GUI objects.  Buttons are examples.  Many objects have functionality that may be invoked as a result of an event on an

    other object.  For example, a customer’s information may be displayed when the button is clicked.  But “display” is a function of Customer: Any one of clients can invoke it, some event-sensitive and others not.  The object with (direct) event reaction is the button, not the customer.

    2. In your requirements document, don’t say “The customer shall include a name …” (which is strange English).  Instead: “The application shall maintain the name of customers ….”

    3. Distinguish between objects and object aggregates.  For example, you could have a “Customers” requirements paragraph with functionality such as “App shall be able to send a customer profile to the central database.”  This will correspond to a class Customer.  You could also have a “Customer List”  paragraph with functionality such as “It shall be possible to add new customers …”  This will correspond to a class such as CustomerList.

    4. Don’t waste words. In particular, give a sentence or two under each paragraph that adds value.

    NOT:

    1.4 Customers

    This section describes the requirements for customers.

    BUT

    1.4 Customers

    The application shall track the customers of the video store as follows. …

    1.

    10/22 3 Clown problem 10/9/02

    Draw a class model for an application for drawing human figures.  The picture shown is a typical product of the application.  The figures are always neck-upward; mouths are always lines, necks always rectangles, etc. – the shapes that appear in the figure.  Assume that the business will never change — but we want to be able to easily upgrade the shop’s capability within these constraints (e.g., draw necks with various colors, new kinds of border lines).  The class model should make figure drawing convenient (e.g., allowing the retrieval of previously constructed figure parts). Show attributes or operations whenever they clarify your solution.  Include useful abstractions (but to extend the current business).

    There is no requirement to take into account the GUI for the application (icons, menu’s etc.)

    Here is a scenario:

    The user … pulls onto the monitor “abeLincolnFace14” (which excludes the ears and neck)

    … adds “ear123” on the left by dragging to its vicinity and releasing

    The application places ear123 in a correct position

    The user invokes the “complete with suitable parts” command.

    The application

    … completes the figure with a neck and hat that it considers most suitable.

    … creates an ear on the right, complete with matching position, interior texture and color, and styles of border lines

    Criteria: a. completeness relative to requirements (A = sufficient classes for requirements, including appropriate generalizations)

    b. economy of classes (A = no more than necessary for requirements)

    10/29 4 14.1 – 14.6 11/5 see more below see below

    Project Phase 3: Due 11/12

    1.  Attach a copy of your phase 2 as graded by me, with specific responses to whatever comments I may have made on your phase 2.

    2. Provide a class diagram for your project, showing inheritance and aggregation.  Show key methods, key dependencies, and inheritance and aggregation.   Use your packages and Facades to avoid a single overwhelming figure.

    3. Show at least one additional model that completes your design.

    Criteria:

    a. Clarity of the model (A = very clear class meanings; very clear organization; no unnecessary details)

    b. Adequacy of class model for effecting the requirements.  (A= detailed enough to clearly allow an implementation that satisfies the requirements.)

    g. Completeness **** of models to specify the entire design. (A=right models selected; clearly no gaps in description)

    Most room for improvement

    1. If you use a data flow diagram, indicate the data types that flow.

    2. If you use a data flow diagram, indicate the functionality at each processing node.

    3. In the interest of clarity, show the relationships among the packages.  You can employ <<uses>> relationships.  Omit the classes from such a figure.

    Room for improvement

    1. In this course we did not give meaning to solid lines with arrows.  Explain what you mean by them, or don’t use them.

    2. Be specific about associations: Do you mean two-way aggregations?

    3. You have introduced a class whose name does not indicate a clear purpose and which is not a domain class.  Explain it’s purpose.

    A Little room for improvement

    1. …..

    Project Phase 4:     Due 12/10

    Section 1 Attach Phases 2 and 3. Response to my comments on phase 3. ( not graded, but required)

    Section 2 Show representative input and output.

    Section 3 Explain the application of all of the steps covered in the notes — explain if they did not apply.

    (criterion: a. Clarity and completeness — A = all relevant steps thoroughly implemented where applicable and explained where not)

    Section 4 Provide a complete class diagram and other appropriate model(s), building on the models you submitted for phase 3.

    (criterion: b. clarity and completeness — A = very clearly chosen and arranged models)

    Section 5 Account of the degree to which you accomplished your requirements as given in phase 2.  Please refer to them by number (e.g., 11.3.5).

    (criterion: g. degree of accomplishment.  A = excellent functional capabilities for a graduate course)

    Section 6. Source code.

    (d. criterion: clarity — A = extremely clear layout & code; each part easily traceable to the corresponding design element)

    Please …

    note that your class diagrams and code must be consistent;

    indicate all differences with prior design decisions;

    indicate all sections using numbered tabs (e.g., Post-it notes)

    Forums — past and present

    Fall 2001

    Fall 2002 email to the group is: 770F02@yahoogroups.com


    Java and Object-Oriented Programming | killexams.com real questions and Pass4sure dumps

    This chapter is from the book 

    Many seasoned Java developers will scoff at the fact that this section even exists in this book. It is here for two very important reasons. The first is that I continually run across Java applications built with a procedural mind-set. The fact that you know Java doesn't mean that you have the ability to transform that knowledge into well-designed object-oriented systems. As both an instructor and consultant, I see many data-processing shops send COBOL and/or Visual Basic developers to a three-day class on UML and a five-day class on Java and expect miracles. Case in point: I was recently asked to review a Java application to assess its design architecture and found that it had only two classes—SystemController and ScreenController—which contained over 70,000 lines of Java code.

    The second reason for the emphasis on how the language maps to object-oriented principles is that people like language comparisons and how they stack up to their counterparts. To appease those that live and die by language comparisons, let's put Java under the scrutiny of what constitutes an object-oriented language.

    No definitive definition of what makes a language object-oriented is globally accepted. However, a common set of criteria I personally find useful is that the language must support the following:

  • Classes
  • Complex types (Java reference types)
  • Message passing
  • Encapsulation
  • Inheritance
  • Polymorphism
  • These are discussed in the next subsections.

    Java and Classes

    Java allows classes to be defined. There are no stray functions floating around in Java. A class is a static template that contains the defined structure (attributes) and behavior (operations) of a real-world entity in the application domain. At runtime, the class is instantiated, or brought to life, as an object born in the image of that class. In my seminars, when several folks new to the object world are in attendance, I often use the analogy of a cookie cutter. The cookie cutter is merely the template used to stamp out what will become individually decorated and unique cookies. The cookie cutter is the class; the unique blue, green, and yellow gingerbread man is the object (which I trust supports a bite operation).

    Java exposes the class to potential outside users through its public interface. A public interface consists of the signatures of the public operations supported by the class. A signature is the operation name and its input parameter types (the return type, if any, is not part of the operation's signature).

    Good programming practice encourages developers to declare all attributes as private and allow access to them only via operations. As with most other languages, however, this is not enforced in Java. Figure 2-1 outlines the concept of a class and its interface.

    FIGURE 2-1 Public interface of a class

    The figure uses a common eggshell metaphor to describe the concept of the class's interface, as well as encapsulation. The internal details of the class are hidden from the outside via a well-defined interface. In this case, only four operations are exposed in the classes interface (Operation_A, B, C, and D). The other attributes and operations are protected from the outside world. Actually, to the outside world, it's as if they don't even exist.

    Suppose you want to create an Order class in Java that has three attributes—orderNumber, orderDate, and orderTotal—and two operations—calcTotalValue() and getInfo(). The class definition could look like this:

    /** * Listing 1 * This is the Order class for the Java/UML book */ package com.jacksonreed; import java.util.*; public class Order { private Date orderDate; private long orderNumber; private long orderTotal; public Order() { } public boolean getInfo() { return true; } public long calcTotalValue() { return 0; } public Date getOrderDate() { return orderDate; } public void setOrderDate(Date aOrderDate) { orderDate = aOrderDate; } public long getOrderNumber() { return orderNumber; } public void setOrderNumber(long aOrderNumber) { orderNumber = aOrderNumber; } public long getOrderTotal() { return orderTotal; } public void setOrderTotal(long aOrderTotal) { orderTotal = aOrderTotal; } public static void main(String[] args) { Order order = new Order(); System.out.println("instantiated Order"); System.out.println(order.getClass().getName()); System.out.println(order.calcTotalValue()); try { Thread.currentThread().sleep(5*1000); } catch(InterruptedException e) {} } }

    A few things are notable about the first bit of Java code presented in this book. Notice that each of the three attributes has a get and a set operation to allow for the retrieval and setting of the Order object's properties. Although doing so is not required, it is common practice to provide these accessor-type operations for all attributes defined in a class. In addition, if the Order class ever wanted to be a JavaBean, it would have to have "getters and setters" defined in this way.

    Some of the method code in the main() operation does a few things of note. Of interest is that a try block exists at the end of the operation that puts the current thread to sleep for a bit. This is to allow the console display to freeze so that you can see the results.

    If you type in this class and then compile it and execute it in your favorite development tool or from the command prompt with

    javac order.java //* to compile it java order //* to run it

    you should get results that look like this:

    instantiated Order com.jacksonreed.Order 0

    NOTE

    Going forward, I promise you will see no code samples with class, operation, or attribute names of foo, bar, or foobar.

    More on Java and Classes

    A class can also have what are called class-level operations and attributes. Java supports these with the static keyword. This keyword would go right after the visibility (public, private, protected) component of the operation or attribute. Static operations and attributes are needed to invoke either a service of the class before any real instances of that class are instantiated or a service that doesn't directly apply to any of the instances. The classic example of a static operation is the Java constructor. The constructor is what is called when an object is created with the New keyword. Perhaps a more business-focused example is an operation that retrieves a list of Customer instances based on particular search criteria.

    A class-level attribute can be used to store information that all instances of that class may access. This attribute might be, for example, a count of the number of objects currently instantiated or a property about Customer that all instances might need to reference.

    Java and Complex Types (Java Reference Types)

    A complex type, which in Java is called a reference type, allows variables typed as something other than primitive types (e.g., int and boolean) to be declared. In Java, these are called reference types. In object-oriented systems, variables that are "of" a particular class, such as Order, Customer, or Invoice, must be defined. Taken a step further, Order could consist of other class instances, such as OrderHeader and OrderLine.

    In Java, you can define different variables that are references to runtime objects of a particular class type:

    Public Order myOrder; Public Customer myCustomer; Public Invoice myInvoice;

    Such variables can then be used to store actual object instances and subsequently to serve as recipients of messages sent by other objects. In the previous code fragment, the variable myOrder is an instance of Order. After the myOrder object is created, a message can be sent to it and myOrder will respond, provided that the operation is supported by myOrder's interface.

    Java and Message Passing

    Central to any object-oriented language is the ability to pass messages between objects. In later chapters you will see that work is done in a system only by objects that collaborate (by sending messages) to accomplish a goal (which is specified in a use-case) of the system.

    Java doesn't allow stray functions floating around that are not attached to a class. In fact, Java demands this. Unfortunately, as my previous story suggested, just saying that a language requires everything to be packaged in classes doesn't mean that the class design will be robust, let alone correct.

    Java supports message passing, which is central to the use of Java's object-oriented features. The format closely resembles the syntax of other languages, such as C++ and Visual Basic. In the following code fragment, assume that a variable called myCustomer, of type Customer, is defined and that an operation called calcTotalValue() is defined for Customer. Then the calcTotalValue() message being sent to the myCustomer object in Java would look like this:

    myCustomer.calcTotalValue();

    Many developers feel that, in any other structured language, this is just a fancy way of calling a procedure. Calling a procedure and sending a message are similar in that, once invoked, both a procedure and a message implement a set of well-defined steps. However, a message differs in two ways:

  • There is a designated receiver, the object. Procedures have no designated receiver.

  • The interpretation of the message—that is, the how-to code (called the method) used to respond to the message—can vary with different receivers. This point will become more important later in the chapter, when polymorphism is reviewed.

  • The concepts presented in this book rely heavily on classes and the messaging that takes place between their instances, or objects.

    Java and Encapsulation

    Recall that a class exposes itself to the outside world via its public interface and that this should be done through exposure to operations only, and not attributes. Java supports encapsulation via its ability to declare both attributes and operations as public, private, or protected. In UML this is called visibility.

    Using the code from the previous Order example, suppose you want to set the value of the orderDate attribute. In this case, you should do so with an operation. An operation that gets or sets values is usually called a getter or a setter, respectively, and collectively such operations are called accessors. The local copy of the order date, orderDate, is declared private. (Actually, all attributes of a class should be declared private or protected, so that they are accessible only via operations exposed as public to the outside world.)

    Encapsulation provides some powerful capabilities. To the outside world, the design can hide how it derives its attribute values. If the orderTotal attribute is stored in the Order object, the corresponding get operation defined previously looks like this:

    public long getOrderTotal() { return orderTotal; }

    This snippet of code would be invoked if the following code were executed by an interested client:

    private long localTotal; private Order localOrder; localOrder = New Order(); localTotal = localOrder.getOrderTotal()

    However, suppose the attribute orderTotal isn't kept as a local value of the Order class, but rather is derived via another mechanism (perhaps messaging to its OrderLine objects). If Order contains OrderLine objects (declared as a Vector or ArrayList of OrderLine objects called myOrderLines) and OrderLine knows how to obtain its line totals via the message getOrderLineTotal(), then the corresponding get operation for orderTotal within Order will look like this:

    public long getOrderTotal() { long totalAmount=0; for (int i=0; i < myOrderLines.length; i++) { totalAmount = totalAmount + myOrderLines[i].getOrderLineTotal(); } return totalAmount; }

    This code cycles through the myOrderLines collection, which contains all the Orderline objects related to the Order object, sending the getOrderLineTotal() message to each of Order's OrderLine objects. The getOrderTotal() operation will be invoked if the following code is executed by an interested client:

    long localTotal; Order myOrder; myOrder = new Order(); localTotal = localOrder.getOrderTotal()

    Notice that the "client" code didn't change. To the outside world, the class still has an orderTotal attribute. However, you have hidden, or encapsulated, just how the value was obtained. This encapsulation allows the class's interface to remain the same (hey, I have an orderTotal that you can ask me about), while the class retains the flexibility to change its implementation in the future (sorry, how we do business has changed and now we must derive orderTotal like this). This kind of resiliency is one of the compelling business reasons to use an object-oriented programming language in general.

    Java and Inheritance

    The inclusion of inheritance is often the most cited reason for granting a language object-oriented status. There are two kinds of inheritance: interface and implementation. As we shall see, Java is one of the few languages that makes a clear distinction between the two.

    Interface inheritance (Figure 2-2) declares that a class that is inheriting an interface will be responsible for implementing all of the method code of each operation defined in that interface. Only the signatures of the interface are inherited; there is no method or how-to code.

    FIGURE 2-2 Interface inheritance

    Implementation inheritance (Figure 2-3) declares that a class that is inheriting an interface may, at its option, use the method code implementation already established for the interface. Alternatively, it may choose to implement its own version of the interface. In addition, the class inheriting the interface may extend that interface by adding its own operations and attributes.

    FIGURE 2-3 Implementation inheritance

    Each type of inheritance should be scrutinized and used in the appropriate setting. Interface inheritance is best used under the following conditions:

  • The base class presents a generic facility, such as a table lookup, or a derivation of system-specific information, such as operating-system semantics or unique algorithms.

  • The number of operations is small.

  • The base class has few, if any, attributes.

  • Classes realizing or implementing the interface are diverse, with little or no common code.

  • Implementation inheritance is best used under the following conditions:

  • The class in question is a domain class that is of primary interest to the application (i.e., not a utility or controller class).

  • The implementation is complex, with a large number of operations.

  • Many attributes and operations are common across specialized implementations of the base class.

  • Some practitioners contend that implementation inheritance leads to a symptom called the fragile base class problem. Chiefly, this term refers to the fact that over time, what were once common code and attributes in the superclass may not stay common as the business evolves. The result is that many, if not all, of the subclasses, override the behavior of the superclass. Worse yet, the subclasses may find themselves overriding the superclass, doing their own work, and then invoking the same operation again on the superclass. These practitioners espouse the idea of using only interface inheritance. Particularly with the advent of Java and its raising of the interface to a first-class type, the concept and usage of interface-based programming have gained tremendous momentum.

    As this book evolves, keeping in mind the pointers mentioned here when deciding between the two types of inheritance will be helpful. Examples of both constructs will be presented in the theme project that extends throughout this book.

    Implementation Inheritance

    Java supports implementation inheritance with the extends keyword. A class wanting to take advantage of implementation inheritance simply adds an extendsClassName statement to its class definition. To continue the previous example, suppose you have two different types of orders, both warranting their own subclasses: Commercial and Retail. You would still have an Order class (which isn't instantiated directly and which is called abstract). The previous fragment showed the code for the Order class. Following is the code for the Commercial class.

    package com.jacksonreed; public class Commercial extends Order { public Commercial() { } /* Unique Commercial code goes here */ }

    Implementation inheritance allows the Commercial class to utilize all attributes and operations defined in Order. This will be done automatically by the Java Virtual Machine (JVM) in conjunction with the language environment. In addition, implementation inheritance has the ability to override and/or extend any of Order's behavior. Commercial may also add completely new behavior if it so chooses.

    Interface Inheritance

    Java supports interface inheritance with the implements keyword. A class wanting to realize a given interface (actually being responsible for the method code) simply adds an implements InterfaceName statement. However, unlike extension of one class by another class, implementation of an interface by a class requires that the interface be specifically defined as an interface beforehand.

    Looking again at the previous example with Order, let's assume that this system will contain many classes—some built in this release, and some built in future releases—that need the ability to price themselves. Remember from earlier in this chapter that one of the indicators of using interface inheritance is the situation in which there is little or no common code but the functional intent of the classes is the same. This pricing functionality includes three services: the abilities to calculate tax, to calculate an extended price, and to calculate a total price. Let's call the operations for these services calcExtendedPrice(), calcTax(), and calcTotalPrice(), respectively, and assign them to a Java interface called IPrice. Sometimes interface names are prefixed with the letter I to distinguish them from other classes:

    package com.jacksonreed; interface IPrice { long calcExtendedPrice(); long calcTax(); long calcTotalPrice(); }

    Notice that the interface contains only operation signatures; it has no implementation code. It is up to other classes to implement the actual behavior of the operations. For the Order class to implement, or realize, the IPrice interface, it must include the implements keyword followed by the interface name:

    public class Order implements IPrice { }

    If you try to implement an interface without providing implementations for all of its operations, your class will not compile. Even if you don't want to implement any method code for some of the operations, you still must have the operations defined in your class.

    One very powerful aspect of interface inheritance is that a class can implement many interfaces at the same time. For example, Order could implement the IPrice interface and perhaps a search interface called ISearch. However, a Java class may extend from only one other class.

    Java and Polymorphism

    Polymorphism is one of those $50 words that dazzles the uninformed and sounds really impressive. In fact, polymorphism is one of the most powerful features of any object-oriented language.

    Roget's II: The New Thesaurus cross-references the term polymorphism to the main entry of variety. That will do for starters. Variety is the key to polymorphism. The Latin root for polymorphism means simply "many forms." Polymorphism applies to operations in the object-oriented context. So by combining these two thoughts, you could say that operations are polymorphic if they are identical (not just in name but also in signatures) but offer variety in their implementations.

    Polymorphism is the ability of two different classes each to have an operation that has the same signature, while having two very different forms of method code for the operation. Note that to take advantage of polymorphism, either an interface inheritance or an implementation inheritance relationship must be involved.

    In languages such as COBOL and FORTRAN, defining a routine to have the same name as another routine will cause a compile error. In object-oriented languages such as Java and C++, several classes might have an operation with the same signature. Such duplication is in fact encouraged because of the power and flexibility it brings to the design.

    As mentioned previously, the implements and extends keywords let the application take advantage of polymorphism. As we shall see, the sample project presented later in this book is an order system for a company called Remulak Productions. Remulak sells musical equipment, as well as other types of products. There will be a Product class, as well as Guitar, SheetMusic, and Supplies classes.

    Suppose, then, that differences exist in the fundamental algorithms used to determine the best time to reorder each type of product (called the economic order quantity, or EOQ). I don't want to let too much out of the bag at this point, but there will be an implementation inheritance relationship created with Product as the ancestor class (or superclass) and the other three classes as its descendants (or subclasses). The scenario that follows uses implementation inheritance with a polymorphic example. Note that interface inheritance would yield the same benefits and be implemented in the same fashion.

    To facilitate extensibility and be able to add new products in the future in a sort of plug-and-play fashion, we can make calcEOQ() polymorphic. To do this in Java, Product would define calcEOQ() as abstract, thereby informing any inheriting subclass that it must provide the implementation. A key concept behind polymorphism is this: A class implementing an interface or inheriting from an ancestor class can be treated as an instance of that ancestor class. In the case of a Java interface, the interface itself is a valid type.

    For example, assume that a collection of Product objects is defined as a property of the Inventory class. Inventory will support an operation, getAverageEOQ(), that needs to calculate the average economic order quantity for all products the company sells. To do this requires that we iterate over the collection of Product objects called myProducts to get each object's unique economic order quantity individually, with the goal of getting an average:

    public long getAverageEOQ() { long totalAmount=0; for (int i=0; i < myProducts.length; i++) { totalAmount = totalAmount + myProducts[i].calcEOQ(); } return totalAmount / myProducts.length; }

    But wait! First of all, how can Inventory have a collection of Product objects when the Product class is abstract (no instances were ever created on their own)? Remember the maxim from earlier: Any class implementing an interface or extending from an ancestor class can be treated as an instance of that interface or extended class. A Guitar "is a" Product, SheetMusic "is a" Product, and Supplies "is a" Product. So anywhere you reference Guitar, SheetMusic, or Supplies, you can substitute Product.

    Resident in the array myProducts within the Inventory class are individual concrete Guitar, SheetMusic, and Supplies objects. Java figures out dynamically which object should get its own unique calcEOQ() message. The beauty of this construct is that later, if you add a new type of Product—say, Organ—it will be totally transparent to the Inventory class. That class will still have a collection of Product types, but it will have four different ones instead of three, each of which will have its own unique implementation of the calcEOQ() operation.

    This is polymorphism at its best. At runtime, the class related to the object in question will be identified and the correct "variety" of the operation will be invoked. Polymorphism provides powerful extensibility features to the application by letting future unknown classes implement a predictable and well-conceived interface without affecting how other classes deal with that interface.



    Direct Download of over 5500 Certification Exams

    3COM [8 Certification Exam(s) ]
    AccessData [1 Certification Exam(s) ]
    ACFE [1 Certification Exam(s) ]
    ACI [3 Certification Exam(s) ]
    Acme-Packet [1 Certification Exam(s) ]
    ACSM [4 Certification Exam(s) ]
    ACT [1 Certification Exam(s) ]
    Admission-Tests [13 Certification Exam(s) ]
    ADOBE [93 Certification Exam(s) ]
    AFP [1 Certification Exam(s) ]
    AICPA [2 Certification Exam(s) ]
    AIIM [1 Certification Exam(s) ]
    Alcatel-Lucent [13 Certification Exam(s) ]
    Alfresco [1 Certification Exam(s) ]
    Altiris [3 Certification Exam(s) ]
    Amazon [2 Certification Exam(s) ]
    American-College [2 Certification Exam(s) ]
    Android [4 Certification Exam(s) ]
    APA [1 Certification Exam(s) ]
    APC [2 Certification Exam(s) ]
    APICS [2 Certification Exam(s) ]
    Apple [69 Certification Exam(s) ]
    AppSense [1 Certification Exam(s) ]
    APTUSC [1 Certification Exam(s) ]
    Arizona-Education [1 Certification Exam(s) ]
    ARM [1 Certification Exam(s) ]
    Aruba [8 Certification Exam(s) ]
    ASIS [2 Certification Exam(s) ]
    ASQ [3 Certification Exam(s) ]
    ASTQB [8 Certification Exam(s) ]
    Autodesk [2 Certification Exam(s) ]
    Avaya [101 Certification Exam(s) ]
    AXELOS [1 Certification Exam(s) ]
    Axis [1 Certification Exam(s) ]
    Banking [1 Certification Exam(s) ]
    BEA [5 Certification Exam(s) ]
    BICSI [2 Certification Exam(s) ]
    BlackBerry [17 Certification Exam(s) ]
    BlueCoat [2 Certification Exam(s) ]
    Brocade [4 Certification Exam(s) ]
    Business-Objects [11 Certification Exam(s) ]
    Business-Tests [4 Certification Exam(s) ]
    CA-Technologies [20 Certification Exam(s) ]
    Certification-Board [10 Certification Exam(s) ]
    Certiport [3 Certification Exam(s) ]
    CheckPoint [43 Certification Exam(s) ]
    CIDQ [1 Certification Exam(s) ]
    CIPS [4 Certification Exam(s) ]
    Cisco [318 Certification Exam(s) ]
    Citrix [48 Certification Exam(s) ]
    CIW [18 Certification Exam(s) ]
    Cloudera [10 Certification Exam(s) ]
    Cognos [19 Certification Exam(s) ]
    College-Board [2 Certification Exam(s) ]
    CompTIA [76 Certification Exam(s) ]
    ComputerAssociates [6 Certification Exam(s) ]
    Consultant [2 Certification Exam(s) ]
    Counselor [4 Certification Exam(s) ]
    CPP-Institute [4 Certification Exam(s) ]
    CSP [1 Certification Exam(s) ]
    CWNA [1 Certification Exam(s) ]
    CWNP [13 Certification Exam(s) ]
    CyberArk [1 Certification Exam(s) ]
    Dassault [2 Certification Exam(s) ]
    DELL [11 Certification Exam(s) ]
    DMI [1 Certification Exam(s) ]
    DRI [1 Certification Exam(s) ]
    ECCouncil [22 Certification Exam(s) ]
    ECDL [1 Certification Exam(s) ]
    EMC [128 Certification Exam(s) ]
    Enterasys [13 Certification Exam(s) ]
    Ericsson [5 Certification Exam(s) ]
    ESPA [1 Certification Exam(s) ]
    Esri [2 Certification Exam(s) ]
    ExamExpress [15 Certification Exam(s) ]
    Exin [40 Certification Exam(s) ]
    ExtremeNetworks [3 Certification Exam(s) ]
    F5-Networks [20 Certification Exam(s) ]
    FCTC [2 Certification Exam(s) ]
    Filemaker [9 Certification Exam(s) ]
    Financial [36 Certification Exam(s) ]
    Food [4 Certification Exam(s) ]
    Fortinet [14 Certification Exam(s) ]
    Foundry [6 Certification Exam(s) ]
    FSMTB [1 Certification Exam(s) ]
    Fujitsu [2 Certification Exam(s) ]
    GAQM [9 Certification Exam(s) ]
    Genesys [4 Certification Exam(s) ]
    GIAC [15 Certification Exam(s) ]
    Google [4 Certification Exam(s) ]
    GuidanceSoftware [2 Certification Exam(s) ]
    H3C [1 Certification Exam(s) ]
    HDI [9 Certification Exam(s) ]
    Healthcare [3 Certification Exam(s) ]
    HIPAA [2 Certification Exam(s) ]
    Hitachi [30 Certification Exam(s) ]
    Hortonworks [4 Certification Exam(s) ]
    Hospitality [2 Certification Exam(s) ]
    HP [752 Certification Exam(s) ]
    HR [4 Certification Exam(s) ]
    HRCI [1 Certification Exam(s) ]
    Huawei [21 Certification Exam(s) ]
    Hyperion [10 Certification Exam(s) ]
    IAAP [1 Certification Exam(s) ]
    IAHCSMM [1 Certification Exam(s) ]
    IBM [1533 Certification Exam(s) ]
    IBQH [1 Certification Exam(s) ]
    ICAI [1 Certification Exam(s) ]
    ICDL [6 Certification Exam(s) ]
    IEEE [1 Certification Exam(s) ]
    IELTS [1 Certification Exam(s) ]
    IFPUG [1 Certification Exam(s) ]
    IIA [3 Certification Exam(s) ]
    IIBA [2 Certification Exam(s) ]
    IISFA [1 Certification Exam(s) ]
    Intel [2 Certification Exam(s) ]
    IQN [1 Certification Exam(s) ]
    IRS [1 Certification Exam(s) ]
    ISA [1 Certification Exam(s) ]
    ISACA [4 Certification Exam(s) ]
    ISC2 [6 Certification Exam(s) ]
    ISEB [24 Certification Exam(s) ]
    Isilon [4 Certification Exam(s) ]
    ISM [6 Certification Exam(s) ]
    iSQI [7 Certification Exam(s) ]
    ITEC [1 Certification Exam(s) ]
    Juniper [65 Certification Exam(s) ]
    LEED [1 Certification Exam(s) ]
    Legato [5 Certification Exam(s) ]
    Liferay [1 Certification Exam(s) ]
    Logical-Operations [1 Certification Exam(s) ]
    Lotus [66 Certification Exam(s) ]
    LPI [24 Certification Exam(s) ]
    LSI [3 Certification Exam(s) ]
    Magento [3 Certification Exam(s) ]
    Maintenance [2 Certification Exam(s) ]
    McAfee [8 Certification Exam(s) ]
    McData [3 Certification Exam(s) ]
    Medical [68 Certification Exam(s) ]
    Microsoft [375 Certification Exam(s) ]
    Mile2 [3 Certification Exam(s) ]
    Military [1 Certification Exam(s) ]
    Misc [1 Certification Exam(s) ]
    Motorola [7 Certification Exam(s) ]
    mySQL [4 Certification Exam(s) ]
    NBSTSA [1 Certification Exam(s) ]
    NCEES [2 Certification Exam(s) ]
    NCIDQ [1 Certification Exam(s) ]
    NCLEX [3 Certification Exam(s) ]
    Network-General [12 Certification Exam(s) ]
    NetworkAppliance [39 Certification Exam(s) ]
    NI [1 Certification Exam(s) ]
    NIELIT [1 Certification Exam(s) ]
    Nokia [6 Certification Exam(s) ]
    Nortel [130 Certification Exam(s) ]
    Novell [37 Certification Exam(s) ]
    OMG [10 Certification Exam(s) ]
    Oracle [282 Certification Exam(s) ]
    P&C [2 Certification Exam(s) ]
    Palo-Alto [4 Certification Exam(s) ]
    PARCC [1 Certification Exam(s) ]
    PayPal [1 Certification Exam(s) ]
    Pegasystems [12 Certification Exam(s) ]
    PEOPLECERT [4 Certification Exam(s) ]
    PMI [15 Certification Exam(s) ]
    Polycom [2 Certification Exam(s) ]
    PostgreSQL-CE [1 Certification Exam(s) ]
    Prince2 [6 Certification Exam(s) ]
    PRMIA [1 Certification Exam(s) ]
    PsychCorp [1 Certification Exam(s) ]
    PTCB [2 Certification Exam(s) ]
    QAI [1 Certification Exam(s) ]
    QlikView [1 Certification Exam(s) ]
    Quality-Assurance [7 Certification Exam(s) ]
    RACC [1 Certification Exam(s) ]
    Real Estate [1 Certification Exam(s) ]
    Real-Estate [1 Certification Exam(s) ]
    RedHat [8 Certification Exam(s) ]
    RES [5 Certification Exam(s) ]
    Riverbed [8 Certification Exam(s) ]
    RSA [15 Certification Exam(s) ]
    Sair [8 Certification Exam(s) ]
    Salesforce [5 Certification Exam(s) ]
    SANS [1 Certification Exam(s) ]
    SAP [98 Certification Exam(s) ]
    SASInstitute [15 Certification Exam(s) ]
    SAT [1 Certification Exam(s) ]
    SCO [10 Certification Exam(s) ]
    SCP [6 Certification Exam(s) ]
    SDI [3 Certification Exam(s) ]
    See-Beyond [1 Certification Exam(s) ]
    Siemens [1 Certification Exam(s) ]
    Snia [7 Certification Exam(s) ]
    SOA [15 Certification Exam(s) ]
    Social-Work-Board [4 Certification Exam(s) ]
    SpringSource [1 Certification Exam(s) ]
    SUN [63 Certification Exam(s) ]
    SUSE [1 Certification Exam(s) ]
    Sybase [17 Certification Exam(s) ]
    Symantec [135 Certification Exam(s) ]
    Teacher-Certification [4 Certification Exam(s) ]
    The-Open-Group [8 Certification Exam(s) ]
    TIA [3 Certification Exam(s) ]
    Tibco [18 Certification Exam(s) ]
    Trainers [3 Certification Exam(s) ]
    Trend [1 Certification Exam(s) ]
    TruSecure [1 Certification Exam(s) ]
    USMLE [1 Certification Exam(s) ]
    VCE [6 Certification Exam(s) ]
    Veeam [2 Certification Exam(s) ]
    Veritas [33 Certification Exam(s) ]
    Vmware [58 Certification Exam(s) ]
    Wonderlic [2 Certification Exam(s) ]
    Worldatwork [2 Certification Exam(s) ]
    XML-Master [3 Certification Exam(s) ]
    Zend [6 Certification Exam(s) ]





    References :


    Dropmark : http://killexams.dropmark.com/367904/11907233
    Wordpress : http://wp.me/p7SJ6L-29O
    Dropmark-Text : http://killexams.dropmark.com/367904/12884845
    Blogspot : http://killexamsbraindump.blogspot.com/2017/12/never-miss-these-000-633-questions.html
    RSS Feed : http://feeds.feedburner.com/Real000-633QuestionsThatAppearedInTestToday
    Box.net : https://app.box.com/s/wdklbk01o0dfxqs19d45xbs77f9ucb8o






    Back to Main Page

    IBM 000-633 Exam (Object Oriented Analysis and Design - Part 1) Detailed Information



    References:


    Pass4sure Certification Exam Study Notes- Killexams.com
    Download Hottest Pass4sure Certification Exams - CSCPK
    Complete Pass4Sure Collection of Exams - BDlisting
    Latest Exam Questions and Answers - Ewerton.me
    Pass your exam at first attempt with Pass4Sure Questions and Answers - bolink.org
    Here you will find Real Exam Questions and Answers of every exam - dinhvihaiphong.net
    Hottest Pass4sure Exam at escueladenegociosbhdleon.com
    Download Hottest Pass4sure Exam at ada.esy
    Pass4sure Exam Download from aia.nu
    Pass4sure Exam Download from airesturismo
    Practice questions and Cheat Sheets for Certification Exams at linuselfberg
    Study Guides, Practice questions and Cheat Sheets for Certification Exams at brondby
    Study Guides, Study Tools and Cheat Sheets for Certification Exams at assilksel.com
    Study Guides, Study Tools and Cheat Sheets for Certification Exams at brainsandgames
    Study notes to cover complete exam syllabus - crazycatladies
    Study notes, boot camp and real exam Q&A to cover complete exam syllabus - brothelowner.com
    Study notes to cover complete exam syllabus - carspecwall
    Study Guides, Practice Exams, Questions and Answers - cederfeldt
    Study Guides, Practice Exams, Questions and Answers - chewtoysforpets
    Study Guides, Practice Exams, Questions and Answers - Cogo
    Study Guides, Practice Exams, Questions and Answers - cozashop
    Study Guides, Study Notes, Practice Test, Questions and Answers - cscentral
    Study Notes, Practice Test, Questions and Answers - diamondlabeling
    Syllabus, Study Notes, Practice Test, Questions and Answers - diamondfp
    Updated Syllabus, Study Notes, Practice Test, Questions and Answers - freshfilter.cl
    New Syllabus, Study Notes, Practice Test, Questions and Answers - ganeshdelvescovo.eu
    Syllabus, Study Notes, Practice Test, Questions and Answers - ganowebdesign.com
    Study Guides, Practice Exams, Questions and Answers - Gimlab
    Latest Study Guides, Practice Exams, Real Questions and Answers - GisPakistan
    Latest Study Guides, Practice Exams, Real Questions and Answers - Health.medicbob
    Killexams Certification Training, Q&A, Dumps - kamerainstallation.se
    Killexams Syllabus, Killexams Study Notes, Killexams Practice Test, Questions and Answers - komsilanbeagle.info
    Pass4sure Study Notes, Pass4sure Practice Test, Killexams Questions and Answers - kyrax.com
    Pass4sure Brain Dump, Study Notes, Pass4sure Practice Test, Killexams Questions and Answers - levantoupoeira
    Pass4sure Braindumps, Study Notes, Pass4sure Practice Test, Killexams Questions and Answers - mad-exploits.net
    Pass4sure Braindumps, Study Notes, Pass4sure Practice Test, Killexams Questions and Answers - manderije.nl
    Pass4sure study guides, Braindumps, Study Notes, Pass4sure Practice Test, Killexams Questions and Answers - manderije.nl


    killcerts.com (c) 2017