Engr 691-10: Special Topics in Engineering Science
Software Architecture
Spring Semester 2002

Exam #1 Study Guide
5 March 2002 Version

This is a study guide I am providing to assist you in your study for the exam. However, I reserve the right to ask questions on any material that we have covered this semester -- unless I say explicitly that it will not be on the exam.

  1. Lecture Notes on Data Abstraction
    Introductory concepts:
    procedural and data abstraction, concrete data structures, abstract data structures, abstract data types, information hiding, encapsulation
    Definition of ADTs:
    name, sets, signatures, semantics
    axiomatic versus constructive approaches
    preconditions, postconditions, invariants (interface and implementation)
    constructors, mutators, accessors, destructors
    Defining ADTs as Java classes:
    instance and class methods, instance and class variables
    private versus public accessibility
    reference versus value (copy) semantics
    How can ADTs be implemented as Java classes? as Java interfaces?
    client-supplier relationship
    criteria for good class interfaces

  2. ADT Case Study: Ranked Sequence

    The key point of including this case study is to give a more sophisticated example of an ADT design/implementation using Java. The case study uses: Java interfaces to separate specification from implementation, Java exceptions, Javadoc annotations, iterators, an assertion checking mechanism, Java packages

    Improvement notes: use Java Iterator instead of Enumeration, use inner classes to implement iterator

  3. H. C. Cunningham and J. Wang. "Building a Layered Table Framework for the Table Abstraction,", Proceedings of the ACM Symposium on Applied Computing, March 2001.
    [Class presentation]

    Variant paper: H. C. Cunningham and J. Wang. "Applying Software Patterns in the Design of a Table Framework,", To appear in the Proceedings of the Conference on Applied Research in Data Engineering, Acxiom Data Engineering Laboratory, University of Arkansas at Little Rock, November 2001.

    What I wanted to illustrate when we talked about this paper was the use of design contracts (pre- and postconditions, invariants) as a means for being careful in the design. I also wanted to show an approach to building a data/file structure that separated concerns such as the access mechanisms from the storage mechanisms.

    Since we have now studied patterns, you will notice that this paper uses the Layered Architecture, Bridge, Proxy, and Iterator patterns.

    This paper also introduces the concept of framework.

  4. Reto Kramer, Examples of Design by Contract: Using iContract, the Design-by-Contract Tool for Java , Object World, Berlin, 1999.

    We did not discuss this paper, but it is another good resource on design by contract.

  5. Understanding Inheritance
    abstract concepts of data types and inheritance (subtypes) -- substitutability
    programming language constructs of classes and subclasses
    What is the relationship between class/subclass and type/subtype concepts?
    forms of inheritance -- which preserve substitutability?
    how are preconditions, postconditions, and invariants affected by inheritance?
    tree-structured versus forest-structured class hierarchies
    advantages/disadvantages of each
    Java inheritance and class hierarchy features?

  6. Replacement and Refinement

    This handout looked briefly at the difference between overriding by replacement and refinement in OOP languages.

  7. Mechanisms for Software Reuse

    The purpose of this handout is to discuss the differences between inheritance and composition (or aggregation) as reuse mechanisms. How do you do each of these in Java? advantages and disadvantages of each?

  8. Implications of Inheritance

    The purpose of this handout is to discuss other programming language issues that are affected by the choice to include inheritance: polymorphic variables, storage allocation/deallocation issues, copy versus reference semantics, copy creation, equality testing

  9. Multiple Inheritance

    This handout looked briefly at issues related to multiple inheritence in programming languages.

  10. Polymorphism

    The purpose of this handout is to discuss the polymorphism and its various forms in programming languages: polymorphic variables, overloading, overriding, deferred methods, pure polymorphism, and generics. What does Java have and not have?

  11. Second Look at Classes

    The purpose of this handout is to discuss the meta-class structure of Java. That is the class Class and the association of its instances with classes in Java. What facilities are provided by Class?

  12. Introduction to Unified Modeling Language (UML)

    In this lecture I discussed the primary features of the UML class diagram.

  13. Java programming

    You should understand well how to build abstract data types in Java as you did oin the first assignement.

    You should understand how inheritance and polymorphism work in Java. I am likely to give you a set of classes using inheritance and overriding and ask you to answer questions about them. In particular, I might ask you to show the output of a program that uses inheritance and polymorphism. Give the class diagrams. Show which mutators are accessors, mutators, etc. Maybe I will ask you to add a new class that does something useful (: or maybe does something useless :).

UP to ENGR 691 root document?

Copyright © 2002, H. Conrad Cunningham
Last modified: Tue Mar 5 14:59:37 2002