Software Construction: Object-Oriented Design

Question 1

A call-stack is formed when

Answer 1

one method calls another.

Question 2

Exception mechanisms in a programming language let us

Answer 2

write code to recover from errors, and resume normal execution of the code.

Question 3

Throwing the exception object causes

Answer 3

an alternate return path to be taken: once an exception is thrown, none of the subsequent code in that method is executed. Instead, the exception object can be thought of as falling back down the return path to the calling method

Question 4

Normal execution through the normal return path does not

Answer 4

resume until the exception is caught. If the exception is not caught it keeps falling down the alternate exceptional path until the program effectively crashes.

Question 5

A method should only catch an exception if it can actually

Answer 5

do the work to recover from (handle) that exception.

Question 6

unchecked exceptions and checked exceptions

Answer 6

unchecked doesnt check by java, checked - checked

Question 7

To Extract a class hierarchy

Answer 7

we look at all the “extends” and “implements” relationships between classes and interfaces in our system.

Question 8

To Extract associations

Answer 8

we look at the fields within the classes.

Question 9

If a class contains a field of another type, then...
We would draw the association on the diagram, and indicate...

Answer 9

...we say that the class is associated with that other type.
...what the arity of the association i

Question 10

An Aggregation relationship can be thought of as

Answer 10

a whole-part relationship. If one object is part of another object, then we use a diamond at the start of the arrow (next to the containing object), and a normal arrow at the end.

Question 11

A sequence diagram depicts

Answer 11

the calls between objects while the system is running. It’s essentially a vertical timeline of calls, that flows from top to bottom.

Question 12

A sequence diagram starts

Answer 12

with a particular method call – so effectively, we are drawing the sequence of calls triggered by one method.

Question 13

At the top of the diagram,

Answer 13

all the objects that are “alive” through the execution of the method are depicted. They then have lifelines (timelines) extending down from them.

Question 14

To show a method’s execution on the timeline, we draw

Answer 14

a box that overlays the timeline. The box extends for as long as that method runs.

Question 15

Calls to a method are depicted as

Answer 15

arrows with the name of the method sitting as the label. Parameters are listed in parentheses. The destination object for a call is the object in which that method is implemented. The call arrow extends from the calling object’s method to the called method.

Question 16

Loops are shown in sequence diagram by

Answer 16

placing a box around all the looped behaviour, and putting the condition of the loop in the corner.

Question 17

Conditional behaviour in sequence diagram is shown as

Answer 17

a box around all the conditional behaviour, with the condition indicated in the corner.

Question 18

To Implement Fields we look at

Answer 18

associations between classes.

Question 19

The type of the field is determined by

Answer 19

the destination type of the association arrow.

Question 20

There are three kinds of Bi-Directional Relationships

Answer 20

one-one relationships, one-many relationships, and many-many relationships.

Question 21

When Implementing Sequence Diagrams begin by looking at

Answer 21

the method coming in from the side – this tells us the name of the method being implemented.

Question 22

SOLID

Answer 22

Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation and Dependency Inversion. Of those we will look at Single Responsibility and Liskov Substitution

Question 23

The Single Responsibility Principle indicates that

Answer 23

each class should be centered around one cohesive concept

Question 24

If, over time, a class seems like it has more than one responsibility, it can be

Answer 24

split into two separate classes

Question 25

A symptom of having two responsibilities is

Answer 25

having multiple clusters of methods, with each cluster referring to their own data within the class. Each cluster may represent its own responsibility, and may be best separated into its own class.

Question 26

Coupling between two classes indicates that

Answer 26

two classes collaborate in some way.

Question 27

Inter-class coupling can be through

Answer 27

method calls, dependencies, or by holding functionality in common that accomplishes a goal without explicitly declaring as such.

Question 28

Low coupling

Answer 28

a change in one place requires no change in a collaborating class

Question 29

Medium coupling

Answer 29

a change in one class does require a remote change, but the compiler warns the developer that the change is needed. An example of this is when a checked exception is declared to be thrown, the compiler will alert the developer that it must be caught at the calling location. Method signature changes are also checked by the compiler, as are Type changes.

Question 30

High coupling

Answer 30

a change in one class does require a remote change, but the collaboration will only be detected at runtime – meaning you have to run the code to see that the change has affected other classes.

Question 31

One way to refactor semantic coupling is to

Answer 31

introduce a new type of object to reduce duplication.

Question 32

The Liskov Substitution Principle states that

Answer 32

for a subclass to be substitutable for its superclass, the subclass cannot break the expectations that a user of the superclass would have. Thus, it cannot reduce the service it provides, and cannot produce effects not produced in the superclass.

It formally states that

the preconditions of a subclass’s behaviour (methods) cannot be strengthened, meaning (among other things) that a sub-method cannot accept a narrower range of inputs than the original method.

The post conditions of a sub-method cannot be weakened, meaning that the sub-method cannot have a broader range of effect than the original method.

Question 33

Тип тестов для LSP

Answer 33

- substitution test
Student s = new StudentRegSys();
Bird b = new Eagle();
- concatenation test
StudentRegSys Student
Eagle Bird
-IS-A test
StudentRegSys IS-A Student
Eagle IS-A Bird

Question 34

The Composite Pattern provides

Answer 34

a design for a hierarchy, in which nodes with children differ in their behaviour from nodes with no children. An example might be the display of a hierarchy, like a file system, where folders contain files. Folders would be displayed differently from files, and would have contents (the files).

Question 35

The composite pattern consists of

Answer 35

three classes: the Composite (the node that can have children), the Leaf (no children), and the Component, which is a superclass extended by both the Composite and Leaf

Question 36

The Composite has a collection

Answer 36

of Components, so that the Composite class can loop through those Components without keeping track of whether the Component is actually a Composite or a Leaf.

Question 37

The Composite also has an method

Answer 37

addComponent method so that Components can be added to its contents.

Question 38

Without the Component super class abstraction,

Answer 38

the Composite would have to maintain different lists for each kind of element in its contents, and would need to provide individual methods for adding contents, and displaying contents for each kind of content.

Question 39

The Observer Pattern is a design that lets

Answer 39

one or more objects watch the state of one or more other objects.

Question 40

The Observer Pattern design centers around two phases

Answer 40

Registration: The Observer registers with the Subject, by calling a registration method on the subject (named something like register, or addObservers). In that method, the Subject adds the Observer to its list of Observers.

Notification: Whenever the Subject’s state changes, it notifies the observers by calling its own notify (or similarly named) method. The notify method then iterates through the list of observers, calling update (or a similarly named method) on each one. The Subject may send an argument with this method to indicate the change (the push model), or may send a reference to itself so that the Observer can call back to find out what changed for itself (the pull model).

Question 41

The Iterator Pattern allows us to

Answer 41

separate out all the logic for iterating over a collection.