OOP Final

Question 1

polymorphic

Answer 1

one name and many different meanings

Question 2

Overloading
ad hoc polymorphism

Answer 2

one name that refers to two or more different implementations. Must share the same method name.

i.e. occurs within the context of the parent class/child class relationship

Question 3

Overriding
inclusion polymorphism

Answer 3

A child class redefining a method inherited from a parent class. Must maintain the same method signature

i.e. single function name (or method name) has several alternative implementations

Question 4

Overloaded method binding

Answer 4

distinguished at compile time based on their type signatures

Question 5

Polymorphic variable

Answer 5

variable that can hold different types of values during the course of execution

Question 6

Pure polymorphism

Answer 6

when a polymorphic variable is used as a parameter

Question 7

Generics (Templates)

Answer 7

A way of creating general tools or classes by parameterizing on types

i.e. leaves types of methods & classes unspecified to be used in wider range of situations

Question 8

Inheritance & composition

Answer 8

Types of software reuse

Question 9

Goal of polymorphism

Answer 9

Facilitates reuse of standard software components that leads to:

rapid development
reliability
ease of use

Question 10

inheritance

Answer 10

is-a relationship

Question 11

composition

Answer 11

has-a relationship

Question 12

Using Composition

Answer 12

Everything must be redefined while leveraging an existing software component in the creation of a new application

i.e. Set and List are unique data structures but Set can be reimplemented completed using List class

Question 13

Composition class hierarchy

Answer 13

no explicit or implicit claims about substitution.

i.e. Set and List are distinct and neither can be substituted in situations where the other is required

Question 14

Using Inheritance

Answer 14

Declare a new class as a child of an existing class. Thus, all data areas and functions associated with the original class are automatically associated with the new data abstraction.

Question 15

Composition Advantages

Answer 15

• simpler, and clearly indicates what operations are provided
• Easier to change underlying details (change data representation)

Question 16

Inheritance Advantages

Answer 16

• shorter code from code reuse
• possibly increased functionality
• slight advantage in execution time

Question 17

Inheritance Disadvantages

Answer 17

• Can be difficult to understand what behavior is provided
• May introduce unintended usage of behavior

i.e. programmer must understand a class constructed using inheritance and the parent class (yo-yo problem - flipping back and forth between two or more classes)

Question 18

Polymorphism Mechanisms

Answer 18

Overloading
Overriding
Polymorphic Variable
Generics

Question 19

Static Polymorphism
Compile time polymorphism

Answer 19

compiler identifies which method is being called at the compile time

Question 20

Dynamic Polymorphism
Run-time Polymorphism

Answer 20

method being called is determined at runtime and not at compile time

Question 21

Implementing Static Polymorphism

Answer 21

Method & operator overloading

Question 22

Implementing Dynamic Polymorphism

Answer 22

Method overriding

Question 23

virtual
override

Answer 23

if the same method is present in both superclass and subclass then the subclass method must use keywords in its method signature to be called during run-time

Question 24

Static Polymorphism advantages

Answer 24

• more flexibility in

Question 25

Dynamic Polymorphism advantages

Answer 25

- Flexibility & Extensibility - Late Binding - Support for Inheritance - Easier maintenance and updates

Question 26

late binding

Answer 26

The decision about which method to call is deferred until runtime. This allows for more dynamic behavior, where the appropriate method to invoke is determined based on the actual type of the object during runtime.

Question 27

Static Polymorphism advantages

Answer 27

- Better performance since compilers knows at compile time which method to call - Early error detection - Simplicity - No runtime overhead

Question 28

Choosing between runtime and compile time polymorphism

Answer 28

The choice between runtime and compile-time polymorphism depends on the specific requirements of the program. In many cases, a combination of both types of polymorphism is used to leverage their respective benefits in different parts of the code. i.e. a system might use runtime polymorphism for managing a polymorphic collection of objects, while using compile-time polymorphism for efficiency in certain performance-critical sections.

Question 29

Design Pattern Goal

Answer 29

- Reduce information flow that must pass over this boundary - Make process of connecting simple

Question 30

Pattern description

Answer 30

name synopsis forces solution counterforces related patterns

Question 31

synopsis

Answer 31

A short description of the problem the pattern design to solve ex. Used to connect a client who needs a service described using once interface with a provider who implements the desired functionality but uses a different interface

Question 31

name

Answer 31

used to describe a pattern. ex. The adapter pattern

Question 32

forces

Answer 32

a description of the requirements for a pattern or the considerations that must be taken into account in the use of the solution

Question 33

Counterforces

Answer 33

A description of reasons that might need to be considered in deciding to not use a pattern

Question 34

Related Patterns

Answer 34

this section describes related patterns that user might want to consider in the solution to their problem

Question 34

solution

Answer 34

the resolution ex. the adapter implements the interface as specified by the client and passes the work on to the service provider

Question 35

Iterator design pattern

Answer 35

Problem: provide client access to elements in a collection without exposing the structure of the collection solution: allow client to manipulate that returns the current value and move to the next element in the collection Description: Iterator is used to traverse a container of data to access the container's elements without the need to know the underlying structure

Question 36

Creational Pattern

Answer 36

These type of pattern support the creation of objects. Because in certain situations there are more elegant ways than using the new operator.

Question 37

Software Factory design pattern

Answer 37

Problem: simplify the creation of many different types of classes which share a similar parent class Solution: Hide creation within a method, have the method declare a return type that is more general than its actual return type Description: Abstract Factory provides an interface for creating families of related or dependent object without to specify concrete classes

Question 38

Singleton design pattern

Answer 38

Problem: You want to ensure there is never more than one instance of a given class Solution: Make the constructor private, have a method that returns just one instance which is held inside the class itself Description: This pattern ensures that only one instance of an object is created and that this instance is globally accessible

Question 39

Singleton Examples

Answer 39

Logger class Configuration Management Database Connection Pool Print Spoolers

Question 40

Decorator design pattern

Answer 40

Problem: Allow functionality to be layered around abstraction, but still dynamically changeable Solution: Combine inheritance and composition by making an object that both subclasses from another class and holds an instance of the class Description: The decorator pattern allows to add functionality to an object at run time without altering its structure

Question 41

Adapter design pattern

Answer 41

Used to connect a client (Object that needs a service) with a server (object that provides a service) ex. Client requires a certain interface while the server provides necessary functionality it does not support the interface

Question 42

Runtime vs Compile time (4 each)

Answer 42

Runtime - flexibility and extensibility - late binding - support for inheritance - easier maintenance and updates Compile time - performance - early error detection - simplicity - no runtime overhead