Final Review

Question 1

Test-Driven Development requires one to define contracts and interfaces before writing test cases. T/F ?

Answer 1

True

Question 2

Functional Decomposition

Answer 2

breaking down a complex system into smaller, functional parts.

Question 3

ADT

Answer 3

An abstract class or interface that contains a description of all possible operations it can do on a data type but not its implementation

Question 4

Abstraction function

Answer 4

An abstraction function

Question 5

Representation Invariant

Answer 5

A representation invariant is a condition or property that must always be true for the internal state of an object or data structure.

A condition inside a method that most hold. A condition about its implementation

Question 6

Difference between a public invariant and RI

Answer 6

A public invariant is a condition that must hold for a public method to function properly

Represention Invariant is a condition that must hold in a methods implemenation

Question 7

Dependency Injection

Answer 7

Its is like parameterising but for classes,
During the construction, inject info

Question 8

What to talk about in @post

Answer 8

• The result
• The variables that are modified

Question 9

Which array can have null values

Answer 9

Can have null values:
- String array

Can’t have null values:
- Integer array
- Set integers

Question 10

Dependency Inversion Principle

Answer 10

• high-level modules should not depend upon low-level modules, but that both should depend upon abstractions.
• abstractions should not depend upon details, but that details should depend upon abstractions

Question 11

Key words

Answer 11

Testability
Resusibility
Understandability
Maintainability
Modifibility

Coupling
Cohesion

Question 12

Describe the main steps (w.r.t. declaration and execution) for client code to use the SwingWorker class.

Answer 12

i. (Static aspect; declaration) By subclassing SwingWorker and overriding the doInBackground() and done() methods.

ii. (Dynamic aspect; execution) The resulting SwingWorker subclass must be in- stantiated for each run. The background thread is activated by calling execute().

Question 13

Which of the following design patterns are used for Java’s SwingWorker?

Answer 13

• Facade
• Template

Question 14

For ADTs, we distinguish between specification and implementation. Which of the following are part
of the specification of an ADT?

Answer 14

• Contracts for individual operations
• Zero or more public invariants

Question 15

For ADTs, we distinguish between specification and implementation. Which of the following are part
of the Implemenation of an ADT?

Answer 15

• An abstraction function
• A representation invariant.

Question 16

What are the advantages of throwing a Java exception instead of returning a special value to signal
a violated precondition?

Answer 16

• Exceptions can carry additional information
• Exceptions are typed and can have messages, allowing for specific exception handling and more clear
  information while debugging and reading stack traces
• The programmer might forget to check the return value; exceptions cannot be ignored so easily

Question 17

In the context of abstract data types, what is encapsulation, and why is it useful?

Answer 17

• ADT bundles and hides implementation details (data
  representation and operation implementations; using class mechanism), separate from specification in
  ADT (using interface or abstract class mechanism).
• Encapsulation in ADT makes it impossible for clients to directly depend
  on implementation details
• Encapsulation in ADT makes it possible to change the encapsulated
  details (i.e. implementation) without affecting client code

Question 18

What is functional decomposition?

Answer 18

This is a design technique that carries out Divide & Conquer (solely) with procedural
abstraction.

Decomposition is driven by considering the required functionality of the
program being designed. In requirements, functionality can often be discovered in the verbs.

Design guidelines:
- aim for single-purpose, general methods (SRP = Single Responsibility
Principle),
- low coupling
- high cohesion
- low complexity (no deeply nested control
structures)
- avoid code duplication (DRY = Don’t Repeat Yourself). Parameters, return
values, global versus local data, recursion.

Question 19

Explain one disadvantage of functional decomposition.

Answer 19

Disdvantages of Divide & Conquer
- Top-level divisions are hard to make: can have big consequences. Need experience and
need to experiment (try alternatives).

Question 20

Advantages of automated test cases on manual ones

Answer 20

• Manual testing is tedious, time consuming, and error prone.
• Automated test cases are more convenient, faster, and more reliable.
• They offer the ability to (re)run all test cases, and report on the results.
• It is easier to inspect the results of automated test cases.

Question 21

Name at least four reasons why it is not a good idea to include unnecessary test
cases.

Answer 21

• Costs extra test development time.
• Gives false impression of application code quality.
• Gives false impression of test quality.
• Costs extra test time when executing tests.

Question 22

What is the purpose of the SwingWorker class of Java?

Answer 22

It makes it easy to run some code in a background thread, and still interact with it in a
controlled way.

Question 23

Describe the two main steps for client code to use the SwingWorker class?

Answer 23

1. Some Swing component methods are labelled “thread safe” in the API specification: these
   can be safely invoked from any thread.
2. All other Swing component methods must be invoked from the event dispatch thread.

Question 24

Explain two design patterns which play a role in the SwingWorker, and what that
role is.

Answer 24

1. SwingWorker acts as a Facade for the Java Thread facilities.
2. It uses the Template Method pattern to let clients define steps:
   - Which computation to do in background: doInBackground()
   - How to handle intermediate results: process()
   - What to do with the final result: done()

Question 25

What are the benefits of implementing test cases before, rather than after, implementing a software product?

Answer 25

* It encourages analysis of interfaces and contracts before implementing them. * It helps stabilize interfaces and contracts before implementing them. * It allows you to focus on implementing the module and getting it to work, without being interrupted by test case development.

Question 26

Describe the structure of a test case for robustness using the Java try statement and how it works.

Answer 26

i. Call the method under test in a try block such that its precondition is violated. ii. If the next statement is reached (no exception was thrown), the test case fails. iii. Catch the thrown exception in a catch block.

Question 27

What does it mean for a concrete class C to depend on another concrete class D?

Answer 27

That class C cannot be compiled without having class D as well.

Question 28

What are two concrete disadvantages of such a dependence? Class c depends on class D

Answer 28

Applying the Dependency Inversion Principle (DIP): Don’t make a class (C) dependent on concrete code (D), rather make both depend on an abstraction. * Introduce an interface for class D. * Let class D implement that interface. * Make class C dependent on that interface. * Let client code of class C configure it at runtime to use class D (Dependency Injection).

Question 29

What is an ADT

Answer 29

An abstract data type makes available, for use in programs, a set of abstract values together with operations on those values. Its implementation is encapsulated and not directly accessible by client code, so that client code does not depend on the implementation.

Question 30

Why are ADTs useful? Explain your answer.

Answer 30

Implementation code of an ADT can be changed without affecting (correctness of) client code. This is useful, because it limits the consequences of making changes to implementations. It also makes it easier to have multiple implementations of the same ADT.

Question 31

What kinds of code and documentation must be delivered to implement an ADT?

Answer 31

(c) * Code: – A data representation (in terms of concrete types or other ADTs) – Implementations of all operations * Documentation: – representation invariant, stating the condition under which the data representation is valid; that is, when it represents an abstract value. – abstraction function, mapping a valid data representation to the corresponding abstract value.

Question 32

Design Patterns

Answer 32

T emplate I teration F acade F actory S ingleton S tate S trategy A daptor D ecorator O bserver C ommand C ompound command C omposite 13

Question 33

Factory Method: Relation with different design patterns

Answer 33

You can use Factory Method along with Iterator to let collection subclasses return different types of iterators that are compatible with the collections. Factory Method is a specialization of Template Method. At the same time, a Factory Method may serve as a step in a large Template Method.

Question 34

Factory: Pros and Cons

Answer 34

Pros - You avoid tight coupling between the creator and the concrete products. - Single Responsibility Principle. You can move the product creation code into one place in the program, making the code easier to support. - Open/Closed Principle. You can introduce new types of products into the program without breaking existing client code. Cons - The code may become more complicated since you need to introduce a lot of new subclasses to implement the pattern. The best case scenario is when you’re introducing the pattern into an existing hierarchy of creator classes.

Question 35

Adapter: Relations with other Design Patterns

Answer 35

Adapter provides a completely different interface for accessing an existing object. On the other hand, with the Decorator pattern the interface either stays the same or gets extended. In addition, Decorator supports recursive composition, which isn’t possible when you use Adapter. Facade defines a new interface for existing objects, whereas Adapter tries to make the existing interface usable. Adapter usually wraps just one object, while Facade works with an entire subsystem of objects. Bridge, State, Strategy (and to some degree Adapter) have very similar structures. Indeed, all of these patterns are based on composition, which is delegating work to other objects. However, they all solve different problems. A pattern isn’t just a recipe for structuring your code in a specific way. It can also communicate to other developers the problem the pattern solves.

Question 36

Adapter: Pros and Cons

Answer 36

Pros: - Single Responsibility Principle. You can separate the interface or data conversion code from the primary business logic of the program. - Open/Closed Principle. You can introduce new types of adapters into the program without breaking the existing client code, as long as they work with the adapters through the client interface. Cons: - The overall complexity of the code increases because you need to introduce a set of new interfaces and classes. Sometimes it’s simpler just to change the service class so that it matches the rest of your code.

Question 37

a.has(i)

Answer 37

Means that wether or not a contains this value

Question 38

Finding the max value in an list

Answer 38

\max i; a.has(i); a[i]

Question 39

Contract don't forget

Answer 39

Don't forget to write the header of the method, with also its exceptions void multiplyArraysWithFactor(double[] a, double factor, double[] b) throws NullPointerException, IllegalArgumentException

Question 40

What to do when talking about prinicples

Answer 40

Write its definition

Question 41

inherits == extend

Question 42

interface == implement