619 Final Review
Last updated Fall 2012
Paul Ammann
Agenda



Review Topics Covered
Highlight Key Technical Concepts
Identify Areas for Study on Final


Final May Test Several Concepts in a Given
Question
Goal:

Strong Showing on Final
619 Final Review
Procedural Abstractions
(Liskov 1-3)

Specifications





Preconditions (Requires Clause)
Postconditions (Effects Clause)
Modifies Clause
You Can Read and Write Such Specifications
Issues:




Minimality
Underdetermined Behavior
Deterministic Implementations
Generality
619 Final Review
Exceptions (Liskov 4, Bloch 9)

Rationale for Exceptions







Total vs. Partial Specifications
Replacing Preconditions with Defined
Behavior
Role of “FailureException”
Specifications Include Exception Returns
Checked vs. Unchecked Exceptions
Bloch’s List of Standard Exceptions
Masking vs. Reflection
619 Final Review
Data Abstraction (Liskov 5)

Fundamental Topic


Specifications for:





Expect Significant Exam Coverage
Overview (Typical “Object”)
Abstraction Function (toString())
Representation Invariant (repOk())
Methods
You Can Expect to Write/Modify Some or All of
These

Understanding, not Formality, is the Focus
619 Final Review
More Data Abstraction (Liskov
5)

IntSet and Poly Examples


Mutability
Reasoning about Data Abstractions

Role of Abstraction Function


Role of Representation Invariant



Value of Abstraction Function in Specific Examples
Value of Representation Invariant in Specific Examples
How to Argue a that Method Meets its Contract
Other Issues


Exposing the Rep
Adequacy
619 Final Review
Iteration Abstraction (Liskov
6)

Specifying Iterators




Preconditions and Postconditions
Constraints on Modifications While Generator is in
Use
Implementing Iterators in Java
Abstraction Functions for Iterators


Value of Abstraction Function in Specific Examples
Abstraction Function For Extensions


Allowing a prev() as well as a next() method
Allowing a remove() method
619 Final Review
Type Hierarchy (Liskov 7)

Fundamental Topic


Uses of Type Hierarchy


Extending Behavior vs. Multiple Implementations
Mechanisms


Substitution Principle
Extensions, Abstract Classes, Interfaces
Understanding Overriding vs. Overloading


Dynamic Dispatching
Apparent Type vs. Actual Type
619 Final Review
Type Hierarchy (Liskov 7)

Reasoning About Subtypes

Signature Rule


Methods Rule



Rules for Exceptions
Preconditions/Postconditions
More Rules for Exceptions
Properties Rule
619 Final Review
Polymorphic Abstraction
(Liskov 8)

Element Subtype vs. Related Subtype



Comparable vs Comparator
Addable vs. Adder
Be Prepared to Analyze and/or Complete
an Implementation
619 Final Review
Specifications (Liskov 9)



Specificand Sets
Generality vs. Restrictiveness
Redundancy



Definitions
Examples
Relevance to Type Abstraction Methods
Rule
619 Final Review
Design Patterns (Liskov 15)


Introduction to Design Patterns
Characterization of Patterns





Name
Problem
Solution
Consequences
Example Patterns

Factory, Singleton, Bridge, Decorator,
Command, Iterator, State, Template
619 Final Review
Creating and Destroying
Objects (Bloch 2)






Static Factories
Builders vs. Parameterized Constructors
Singletons
Noninstantiability
Unnecessary Object Creation
Eliminate Obsolete References
619 Final Review
Methods Common to All
Objects (Bloch 3)

equals()


hashcode()



Consistency with equals()
toString()
clone()


Transitivity, Symmetry, Substitution for
Subtypes
Why is Liskov’s clone() (page 97) wrong?
Comparable
619 Final Review
Classes and Interfaces (Bloch
4)

Immutability



Composition vs. Inheritance



Why it is Preferable
How to Achieve
Why is Composition Preferable?
Potential Problems for Inheritance
Mechanisms to Prohibit Inheritance
619 Final Review
Generics (Bloch 5)



Replacing raw types with generics
Eliminating unchecked warnings
Generic interactions with Lists vs. Arrays



Covariant Arrays vs. Invariant Generics
Generifying types and methods
Bounded wildcards

Relaxing the invariance of generics
619 Final Review
Enums and Annotations (Bloch
6)








Using enums instead of int constants
Using instance fields instead of ordinals
Use EnumSet instead of bit fields
Use EnumMap instead of ordinal indexing
Emulate extensible enums with interfaces
Prefer annotations to naming patterns
Consistently use Override annotation
Use marker interfaces to define types
619 Final Review
Methods (Bloch 7)







Parameter validity
Defensive copies
Method signature design
Being careful with overloading
Varargs
Empty arrays/collections vs. null returns
JavaDoc for exposed API
619 Final Review
General Programming (Bloch
8)







Variable Scope
For-each contructs
Library usage, primitives vs. boxed
Strings vs. appropriate types
Interface usage
Beware pointless optimization
Naming conventions
619 Final Review
Concurrency (Bloch 10)


Simple Thread Interactions
Shared Access to Mutable Data




Synchronized Methods
Possible Executions in the Absence of
Synchronization
Roles for wait() and notify()
Bloch’s Alien Method Examples
619 Final Review
Specification Checking


Specifications for Common Properties
Temporal Logic for Specification




Simple Specification Patterns
Kansas State University material


Computational Tree Logic (CTL)
Linear Temporal Logic (LTL)
Links on course schedule
Huth and Ryan is also a excellent source
619 Final Review
Secure Programming


Introduction to Secure Implementation
What is software NOT supposed to do?




Bugs
Misuse Cases
Vulnerabilities/Exploits
You need to think about the bad guy!


Most vulnerabilities are simple mistakes
YOUR software can be better
619 Final Review
Special Topics

JUnit





What is JUnit
How to use JUnit
How to write tests in JUnit
Contract model and JUnit Theories
How to extract basic tests from a contract


Cover each exceptional condition
Cover “normal” behavior

May require several tests
619 Final Review
Wrap Up

Final Exam



Closed Book/Closed Notes
But One (1) 8.5x11 sheet of paper, handwritten
Covered Material



Liskov: Chapters 1-9; 15
Bloch: Chapters 2-10
Plus special topics


Temporal Logic, Advanced JUnit, Security
Questions?
619 Final Review