CHAPTER 16 - PowerPoint PPT Presentation

chapter 16 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
CHAPTER 16 PowerPoint Presentation
play fullscreen
1 / 121
CHAPTER 16
93 Views
Download Presentation
huong
Download Presentation

CHAPTER 16

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. CHAPTER 16 SYSTEM DESIGN

  2. CHAPTER GOALS • To learn about the software life cycle • To learn how to discover new classes and methods • To understand the use of CRC cards for class discovery   • To be able to identify inheritance, aggregation, and dependence relationships between classes • To master the use of UML class diagrams to describe class relationships   • To learn how to use object-oriented design to build complex programs

  3. Software Life Cycle • Encompasses all activities from initial analysis until obsolescence

  4. Development Process • Analysis • Design • Implementation • Testing • Deployment

  5. Analysis • Decide what the project is suppose to do • Output: requirements document

  6. Design • Plan how to implement the system • Output: • description of classes and methods • diagrams showing the relationships among the classes

  7. Implementation • Write and compile the code • Output: completed code

  8. Testing • Run tests to verify the program works correctly • Output: a report of the tests and their results

  9. Deployment • Install the program and begin using it

  10. The Waterfall Model

  11. The Spiral Model • Describes an iterative process in which design and implementation are repeated

  12. The Spiral Model

  13. Extreme Programming • Development methodology that strives for simplicity by removing formal structure and focusing on best practices

  14. Extreme Programming • Realistic planning • Customers make business decisions • Programmers make technical decisions

  15. Extreme Programming • Small releases • Release a useful system quickly • Release updates on a short cycle

  16. Extreme Programming • Metaphor • A shared story to explain the system

  17. Extreme Programming • Simplicity • Design as simply as possible instead of preparing for future complexities

  18. Extreme Programming • Testing • Programmers and customers write test cases • Test continuously

  19. Extreme Programming • Refactoring • Restructure the system continuously to improve code and eliminate duplication

  20. Extreme Programming • Pair programming • Two programmers write code on the same computer

  21. Extreme Programming • Collective ownership • All programmers change all code as needed

  22. Extreme Programming • Continuous integration • Build the entire system and test it whenever a task is complete

  23. Extreme Programming • 40-hour week • Don't cover up unrealistic schedules with heroic effort

  24. Extreme Programming • On-site customer • A customer is accessible to the programming team at all times

  25. Extreme Programming • Coding standards • Follow standards that emphasize self-documenting code

  26. Object-Oriented Design • Discover classes • Determine responsibilities of each class • Describe the relationships among the classes

  27. Discovering Classes • A class represents some useful concept • Find classes by looking for nouns in the task description • Define the behavior for each class • Find methods by looking for verbs in the task description

  28. CRC Card • Stands for classes, responsibilities, collaborators • Use an index card for each class • Pick the class that should be responsible for each method (verb) • Write the responsibility onto the class card • Indicate what other classes are needed to fulfill the responsibility - the collaborators

  29. A CRC Card

  30. Relationships Between Classes • Inheritance • Association • Dependency

  31. "Is-a" Relationship • The "is-a" relationship is inheritance; use extends • a circle is an ellipse • a car is a vehicle

  32. "Has-a" Relationship • The "has-a" relationship is association; use an instance variable • a tire has a circle as its boundary • a car has a set of tire

  33. Uses Relationship • The "uses" relationship is dependency • an Applet uses a Graphics object

  34. "is-a" and "has-a"Example class Car extends Vehicle //inheritance "is-a" { ... private Tire[] tires; //association "has-a" }

  35. Association and Dependency • One class is associated with another if you can navigate from its objects to objects of the other class • One class depends on another if it comes into contact with the other class in some way. • Association is a stronger form of dependency

  36. UML Notation for Inheritance and Association

  37. UML Relationship Symbols

  38. Five-Part Development Process • Gather requirements • Use CRC cards to find classes, responsibilities, and collaborators • Use UML diagrams to record class relationships • Use javadoc to document method behavior • Implement your program

  39. Printing an Invoice - Requirements • Print billing address, all line items, amount due • Line item contains description, unit price, quantity ordered, total price

  40. Sample Invoice INVOICE Sam's Small Appliances     100 Main Street    Anytown, CA 98765  Description Price Qty Total Toaster  29.95 3 89.85 Hair dryer  24.95 1 24.95 Car vacuum  19.99 2 39.98     Amount Due:   $154.78  

  41. Printing an Invoice - CRC Cards • Discover classes • Nouns are possible classes Invoice Price Address Quantity Item Total Product AmountDue Description

  42. Printing an Invoice - CRC Cards • Classes after a process of elimination Invoice Address Item Product

  43. CRC Cards for Printing Invoice

  44. CRC Cards for Printing Invoice

  45. CRC Cards for Printing Invoice

  46. CRC Cards for Printing Invoice

  47. Printing an Invoice - UML Diagrams • The relationship between Invoice classes

  48. Printing an Invoice - Method Documentation • Use javadoc documentation comments to record the behavior of the classes • Leave the body of the methods blank • Run the javadoc utility to obtain a formatted version of the documentation in HTML format

  49. Method Documentation – Invoiceclass /** Describes an invoice for a set of purchased products. */ class Invoice { /** Adds a charge for a product to this invoice. @param aProduct the product that the customer ordered @param quantity the quantity of the product */ public void add(Product aProduct, int quantity) { } /** Formats the invoice. @return the formatted invoice

  50. */ public String format() { } /** Computes the total amount due. @Return the amount due */ public double getAmountDue() { } }