Bev Facey Community High

CSE3130: Object-oriented Programming 2

Students extend their knowledge of object-oriented programming (OOP). They add to their expertise in object-oriented design by using some of the techniques associated with the UML design approach and to their programming expertise by writing programs that explore association between classes. Students work with abstract classes, developing algorithms that employ the object diagram approach and programs that use templated classes, containment and inheritance to promote reusability.

Theory

Explain and represent class and object interactions possible in OOP:

  1. outline the key properties of the OOP approach
  2. describe and demonstrate how coding can be reduced and responsibilities distributed through the appropriate use of polymorphism and inheritance
  3. describe and represent the relationship among the classes, objects, instances and methods including:
    • inheritance
    • association
    • composition and aggregation
  4. describe and represent ways in which inheritance and polymorphism are promoted
  5. outline how static classes, polymorphism and inheritance may be used to hide and/or protect data

Create a transitional strategy to accommodate personal changes and build personal values:

  1. identify short-term and long-term goals
  2. identify steps to achieve goals

Coding

  1. Demonstrate OOP skills by writing algorithms employing an object-oriented approach to solving problems
    • apply an object-oriented analysis and design model to decompose a data processing problem into a form that is accessible to an OOP approach by using:
      • an informal domain analysis
      • an informal use case analysis
      • a general design model
    • analyze a data processing problem and use a top-down design approach to transform a design model into a class diagram that represents the matrix of interacting classes required to solve the problem
    • describe and represent the relationship among the classes; e.g., inheritance, association, aggregation, composition
    • use an iterative and incremental approach to refine the architecture into appropriate class or object diagrams showing their relationships
    • analyze and refine the diagrams identifying the client/server relationship among the objects and determine the messages that need to be passed between objects and how the objects interface
    • draft an informal object message sequence indicating the flow of messages in the system
    • analyze and refine the object design by adding private methods, functions and data structures required to implement the various objects
    • test and modify, as required, the developing algorithm at each stage with appropriate data
  2. translate algorithms into source code, convert the source code into machine executable form, execute and debug, as required
    • demonstrate the use iterative and incremental approaches in the implementation, testing and maintenance phases of the software development process
    • demonstrate the use of iterative prototyping or a similar approach to break the algorithm into appropriate sections for implementation
    • use original (user-created) or pre-existing classes, as necessary, to instantiate the objects called for by the algorithm using an iterative and incremental approach
    • as the classes are constructed, use the server classes to create the client classes establishing the client/server relationships called for by the algorithm
    • test and modify the sections as required
    • where appropriate, collaborate with other students to carry out OOP tasks
    • create internal and external documentation
    • analyze the program and eliminate syntax, run-time and logic errors by using appropriate test data for each programming task at each stage of development
  3. compare the results of the program with the intent of the algorithm and modify, as required

Competencies and Skills

You will also be evaluated on your basic competencies such as your ability to:

This site is open source. Improve this page.