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?