619 Final Review
Download
Report
Transcript 619 Final Review
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