619 Final Review Last updated Fall 2011 Paul Ammann

619 Final Review 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 Expect Significant Exam Coverage Specifications for: 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 Value of Abstraction Function in Specific Examples Role of Representation Invariant 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 Substitution Principle Uses of Type Hierarchy Extending Behavior vs. Multiple Implementations Mechanisms 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 Rules for Exceptions Methods Rule 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() Transitivity, Symmetry, Substitution for Subtypes hashcode() Consistency with equals() toString() clone() Why is Liskov’s clone() (page 97) wrong? Comparable

619 Final Review Classes and Interfaces (Bloch 4) Immutability Why it is Preferable How to Achieve Composition vs. Inheritance 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 Computational Tree Logic (CTL) Linear Temporal Logic (LTL) Simple Specification Patterns Kansas State University material Links on course schedule Huth and Ryan is also a excellent source Huth and Ryan

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, Parameterized Unit Test, Security Questions?