theory

Question 1

The word design is

Answer 1

both a verb (the process of designing) and a noun (outcome of the process) (this creates ambiguity around the word design)

Question 2

Textbook definition of design:

Answer 2

the construction of abstractions of data and computation and the organization of these abstractions into a working software application.

Question 3

Design Space:

Answer 3

an n-dimensional geometric space where each dimension corresponds to a design quality attribute (understandability, reusability, ease of implementation)
Space of possible solutions
Space of acceptable solutions

Question 4

what kind of process is design?

Answer 4

highly heuristic process (iterative problem solving, guided by principles and design techniques)

Question 5

Ignorant surgery:

Answer 5

the problem of modifying code in a way that does not respect the original structure

Question 6

Design context:

Answer 6

a specific set of requirements and constraints within a domain in which a design solution must be formed and integrated.

Question 7

Sustainability:

Answer 7

the idea of having design decisions be self-evident in code

Question 8

Process model:

Answer 8

describes how the different steps required to create a system are organized.

Question 9

Waterfall software processing model

Answer 9

very planning heavy

Question 10

Agile development:

Answer 10

more organic approach

Question 11

Sustainability:

Answer 11

the idea of having design decisions be self-evident in code

Question 12

practice:

Answer 12

well understood way of doing something to achieve a certain benefit
Ex) version control (keep track of changes to software development artifacts)
Ex) pair programming

Question 13

Refactoring:

Answer 13

improving the design without changing the functionality

Question 14

Technical debt

Answer 14

when programmers implement quick and dirty solutions that don’t align properly with the existing design

Question 15

When decomposing a system into distinct, manageable abstractions,

Answer 15

the abstractions have to be isolated from teacher (not dependent on each other).

Question 16

Encapsulation:

Answer 16

enclose something as if it were in a capsule
Ex) a nut is encapsulated in its shell and the shell serves to protect the nut. The shell is synonymous with an interface. Encapsulation makes it easier to understand code in isolation and it’s easier to change one part of the code without breaking anything.
Ex)deck of cards where there are 52 cards and each card can be represented by its suit and rank

Question 17

Object state:

Answer 17

built in characteristics or properties of an object.

Question 18

State diagram:

Answer 18

models the behavior of a single object, specifying the sequence of events that an object goes through during its lifetime in response to events

Question 19

NULL OBJECT pattern:

Answer 19

encapsulate the absence of an object by providing a substitutable alternative
Consider declaring instance variables final whenever possible;

Question 20

singleton pattern

Answer 20

Consider using the SINGLETON pattern for classes that should yield only one instance of a stateful object, while providing a global access point to this instance.
ex) A country can have only one official government.
Remember that additional data can be attached to instances of inner classes, ei-ther in the form of a reference to an instance of an outer class, or as copies of local variables bundled in a closure.

Question 21

FLYWEIGHT pattern:

Answer 21

If objects are not designed to be unique, override the equals and hashCode

methods; if objects should be unique, consider using the FLYWEIGHT pattern to

enforce uniqueness
FLYWEIGHT pattern: lets you fit more objects into the available amount of RAM by sharing common parts of state between multiple objects instead of keeping all of the data in each object. Flyweight objects are immutable. This means that they cannot be modified once they have been constructed. We use a HashMap that stores reference to the object which have already been created, every object is associated with a key.
In browsers, we can use an image in multiple places in a webpage. Browsers will load the image only one time, and for other times browsers will reuse the image from cache.

Question 22

composite pattern

Answer 22

If a design problem requires structures that change at run-time or can be combined, consider building the structures by combining objects, as opposed to defining new classes for each possible structure.
Use the C O M P O S I T E when you need to manipulate collections of objects the same way as single (“leaf”) objects. It lets you compose objects into tree structures and then work with these structures as if they were individual objects.
ex) Armies of most countries are structured as hierarchies.

Question 23

decorator pattern

Answer 23

Use the DECORATOR when you need to add functionality to certain objects, while being able to use them in place of “regular” objects. It lets you attach new behaviors to objects by placing these objects inside special wrapper objects that contain the behaviors.
The COMPOSITE and DECORATOR can be combined easily, especially if they share the same component type.

Question 24

respect the Law of Demeter:

Answer 24

a module should not know about the inner details of the objects it manipulates

Question 25

Command pattern:

Answer 25

Command pattern: You need a command to have a life span independent of the original request, or if you want to queue, specify and execute requests at different times. paper order serves as a command. It remains in a queue until the chef is ready to serve it. The order contains all the relevant information required to cook the meal. It allows the chef to start cooking right away instead of running around clarifying the order details from you directly.

Question 26

Prototype pattern:

Answer 26

lets you copy existing objects without making your code dependent on their classes.

Question 27

polymorphic copying (cloning)

Answer 27

Use polymorphic copying (cloning) to make copies of objects whose concrete type is not known at compile time. If the type is known at compile time, favor the simpler technique of copy constructors; Polymorphic copying can also be used as a way to create fresh instances of objects whose type is not known at compile time, a technique called the PROTOTYPE pattern.

Question 28

Inheritance:

Answer 28

one object acquires all the properties and behaviors of a parent object. Solution to code reuse and extensibility. Whereas inheritance derives one class from another, composition defines a class as the sum of its parts.

Question 29

downcasting or type refinement

Answer 29

is the act of casting a reference of a base class to one of its derived classes. (when sub class type is converted into super class type). We want to avoid downcasting and use polymorphism instead.

Question 30

Template method pattern:

Answer 30

defines the skeleton of an algorithm in the superclass but lets subclasses override specific steps of the algorithm without changing its structure.

Question 31

final method

Answer 31

If there is no obvious scenario for overriding a method, consider declaring it final. Similarly, if there is no specific reason for a class to be extensible using inheritance, consider declaring it final.

Question 32

Liskov Substitution Principle:

Answer 32

Liskov Substitution Principle: objects of a superclass shall be replaceable with objects of its subclasses without breaking the application.

Question 33

@Override annotation:

Answer 33

indicates that the child class method is over-writing its base class method.

Question 34

Overloading

Answer 34

occurs when two or more methods in one class have the same method name but different parameters.

Question 35

Lambda expressions:

Answer 35

an anonymous function (a function with no name)

Question 36

To emphasize flexibility and extensibility in your design,

Answer 36

use library functional interfaces to define function types; to emphasize design constraints and intent, use application-defined functional interfaces

Question 37

A collection

Answer 37

A collection is an object that can hold references to other objects. Can use a collector object to accumulate the result of stream operations.

Question 38

Supplier

Answer 38

functional interface which does not take any argument and produces result of type T

Question 39

first-class functions:

Answer 39

first-class functions: functions are treated as variables.

Question 40

Map abstraction

Answer 40

refers to the process of explicitly defining and representing real-world features on a map

Question 41

Inversion of control:

Answer 41

``` invert different kinds of controls (additional responsibilities a class has, other than its main responsibility) in object-oriented design to achieve loose coupling. Inversion of control is the principle behind the OBSERVER pattern suppose you drive a car to your work place. This means you control the car. The IoC principle suggests to invert the control, meaning that instead of driving the car yourself, you hire a cab, where another person will drive the car. Thus, this is called inversion of the control - from you to the cab driver. You don't have to drive a car yourself and you can let the driver do the driving so that you can focus on your main work. ```

Question 42

Loose coupling

Answer 42

is an approach to interconnecting the components in a system or network so that those components, also called elements, depend on each other to the least extent practicable.

Question 43

Dependency inversion: stream

Answer 43

High-level modules, which provide complex logic, should be easily reusable and unaffected by changes in low-level modules is a sequence of objects that supports various methods which can be pipelined to produce the desired result.

Question 44

Single responsibility principle:

Answer 44

A class should have one, and only one, reason to change.

Question 45

open/closed principle:

Answer 45

Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification.

Question 46

Interface segregation principle:

Answer 46

Clients should not be forced to depend upon interfaces that they do not use.

Question 47

Adapter pattern:

Answer 47

allows objects with incompatible interfaces to collaborate.

Question 48

Visitor pattern:

Answer 48

lets you separate algorithms from the objects on which they operate.

Question 49

Handlers

Answer 49

observers of objects

Question 50

There are two strategies for exchanging data between a model and its observers:

Answer 50

push or pull;

Question 51

Callback method:

Answer 51

callback is something that you pass to a function, which tells it what it should call at some point in its operation.

Question 52

event- based programming:

Answer 52

the flow of the program is determined by events such as user actions (mouse clicks, key presses)

Question 53

OBSERVER pattern:

Answer 53

lets you define a subscription mechanism to notify multiple objects about any events that happen to the object they’re observing.

Question 54

Avoid PAIRWISE DEPENDENCIES

Answer 54

(whenever the user changes the number in a panel, this panel directly contacts all other panels and up- dates their view of the number) because they create high coupling and low extensibility.

Question 55

Model–View–Controller decomposition:

Answer 55

an application consist of a data model, presentation information, and control information. The pattern requires that each of these be separated into different objects.

Question 56

An interface to a class consists of

Answer 56

the methods of that class that are accessible (or visible) to another class. By extension, the interface to an object is the set of methods that can be called on the object.

Question 57

Factory Method:

Answer 57

provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created. Factory Method is about having different ways of creating something.

Question 58

Strategy design pattern:

Answer 58

``` use if part of your design requires supporting an interchangeable family of algorithms. The Strategy pattern suggests that you take a class that does something specific in a lot of different ways and extract all of these algorithms into separate classes called strategies. Strategy pattern is about having different ways of doing something. Imagine that you have to get to the airport. You can catch a bus, order a cab, or get on your bicycle. These are your transportation strategies. You can pick one of the strategies depending on factors such as budget or time constraints. ```

Question 59

ITERATOR design pattern:

Answer 59

Use iterators to expose a collection of objects encapsulated within another with- out violating the encapsulation and information hiding properties of this object. It’s, basically, something or someone who you can ask for the next available item in a set of items, and who can give you access to all those items in the set. ex) A waitress in the restaurant will be iterating through your meal choices as you are having a five course meal, for example.

Question 60

Lambda expressions are a form of

Answer 60

anonymous functions.

Question 61

Class diagrams represent

Answer 61

a static, or compile-time, view of a software system.

Question 62

Composition -

Answer 62

I own an object and I am responsible for its lifetime. If department is canceled, then the class program is also canceled

Question 63

Association -

Answer 63

I have a relationship with an object

Question 64

Aggregation -

Answer 64

``` object is standalone and can exist even if the object of owning class is dead If department is canceled, teachers still exist ```

Question 65

function objects:

Answer 65

any object that can be called as if it is a function

Question 66

Abstract methods:

Answer 66

methods that don’t have an implementation

Question 67

Use interface types to

Answer 67

decouple a specification from its implementation if you plan to have different implementations of that specification as part of your design;

Question 68

Define interfaces so that

Answer 68

each interface groups a cohesive set of methods that are likely to be used together; Organize interfaces as subtypes of each other to create flexible groupings of behavior; Use library interfaces, such as Comparable, to implement commonly expected behavior;

Question 69

Decoupling:

Answer 69

two or more systems somehow work or are connected without being directly connected. interfaces provide a specification of the methods that it should be possible to invoke on the objects of a class. interface method declarations are a specification and not an implementation.

Question 70

To tie a class with an interface, use the

Answer 70

implements keyword (creates a subtype relationship between the implementing class and the interface type) . This subtyping lets us use polymorphism.

Question 71

Polymorphism:

Answer 71

ability to have different shapes.

Question 72

Benefits of polymorphism are

Answer 72

loose coupling(code using a set of methods is not tied to a specific implementation of these methods) and extensibility(can easily add new implementations of an interface)

Question 73

Comparable interface

Answer 73

defines a piece of behavior related specifically to the comparison of objects, in the form of a single int compareTo(T) method. It should return 0 if the implicit argument is the same as the explicit argument, a negative integer if it should come before, and a positive integer if it should come after. It's possible to assign a value to a variable if the value is of the same type or a subtype of the type of the variable.

Question 74

Enumeration:

Answer 74

a class that represents constants (unchangeable). They are globally available constants (static fields). The constants have a unique reference to an object of the class that corresponds to the enumerated value.

Question 75

Primitive obsession antipattern:

Answer 75

the tendency to use primitive types to represent other abstractions. Can avoid falling into this antipattern by using enumerated types.

Question 76

Object:

Answer 76

a mechanism to group variables together and access their values through the process of dereferencing

Question 77

Access modifiers:

Answer 77

Java keywords that control what parts of the code can access program elements. Helps us control the visibility. They express the intent of the developer about how certain structures are meant to be used and support automatic enforcement of the stated intent through compilation. Public members are visible anywhere Private members are only visible within the scope of the class

Question 78

To achieve encapsulation

Answer 78

use the narrowest possible scope for class members. Instance variables should be private.

Question 79

Scope:

Answer 79

lexical region that acts as a boundary for variables. Define scope with a curly brace

Question 80

primitive vs. reference variables

Answer 80

primitive variables store the actual values, whereas reference variables store the addresses of the objects they refer to.

Question 81

3 ways reference to a private structure can escape the scope of its class

Answer 81

1. Return a reference to an internal object Inappropriate intimacy antipattern: when classes spend too much time delving into each others’ private parts. 2. Store an external reference internally. This reference would become shared by the client code. 3. Leak references through shared structures . However, leaking a reference to an internal object is harmless if the object is immutable.