619 Final Review by K2Tytb9

VIEWS: 20 PAGES: 24

									619 Final Review

     Last updated Fall 2011



             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
       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
                                         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?                                            619 Final Review

								
To top