Week 3

Question 1

Procedural Abstraction

Answer 1

concept in cs where details are hidden within a procedure or function, allowing users to focus on high-level operations

Can be done within:
- An expressionm
- A statement

Question 2

How does Procedural Abstraction can be done ?

Answer 2

Can be done by means of methods that:
- Operate on parameter objects
- Return a primitive value, object, or void

Question 3

What is Modularisation for data

Answer 3

Combining variables of primitive types that frequently occur together into a single abstraction, instead of handling them separately

Question 4

How can Modularisation for data can be done?

Answer 4

Grouping can be accomplished by String, array, and class, but only class can introduce a new name for the type

Question 5

Top-down Design

Answer 5

• Given one big problem, split it into smaller subproblems
• Continue until reaching trivially solvable problems -> solutions

Question 6

Bottom-up Design

Answer 6

• Given many small solutions, combine them into bigger solutions
• Continue until reaching a solution of the main problem

Question 7

Enumerations

Answer 7

• Special data type that consists of a set of named constants (enumerators)
• Objects of an enumeration can take any of the values of the enumerators

Question 8

Operations for Enumeration T

Answer 8

• T.VALUE (where VALUE is possible value)
• T.values()
• v.name() (v is an object of type T)
• v.toString()
  -T.valueOf(s) - returns the enumeration constant for name s
• v.ordinal(s) - returns the position of an enumeration constant s within its enum declaration
  -v.compareTo(w) - negative return value - the first (v) comes before second (w)

Question 9

Records

Answer 9

Provide a concise way to declare unchangeable data-carrying classes by automatically generating standard methods such as constructors, getters, equals(), hashCode(), and toString() based on the class’s fields

Question 10

Featues of Records

Answer 10

• Cannot change the values in a record
• Can only read
• Comes with many predefined method getterMethod()

Question 11

Abstract Data Type

Answer 11

A high-level description of a set of operations that can be performed on a certain type of data, along with the constraints or properties that these operations must adhere to.

• It defines what the data type does, not how it does it
• ADTs hide the representation of data and implementation of operations
• They are usually abstract classes/interfaces that are implemented

Question 12

Abstract Data Classes

Answer 12

• A method can be declared abstract, and this means that it does not have an implementation
• Any class containing abstract methods must be declared abstract
• An abstract class cannot be instantiated
• A subclass can define additional instance variables and implementations for inherited abstract methods by overriding

Question 13

Public invariants in ADTs

Answer 13

The properties or conditions that must be true for the data type’s public methods to function correctly (kinda like robustness)

Question 14

Interfaces

Answer 14

Interfaces define a collection of method headers with contracts
Can define constants with public static final
Can have default method implementations but still no instance variables
Somewhat like a class with abstract methods but a class can implement one or more interfaces via implements by implementing each of the methods in the interface(s)
Interfaces can be viewed as a type; its values are the values of all classes that implement the interface

Question 15

Interfaces vs. Abstract Classes

Answer 15

• Abstract classes support single inheritance while interfaces support multiple
• Interfaces cannot have constructors while AC can
• All fields in interfaces are implicitly public, static, and final
• Interfaces cannot have instance variables

Question 16

ADTs as specification

Answer 16

abstract classes and interfaces can both be used to hold just the specification of a class, leaving the actual implementation to the classes that extend/implement them

Question 17

ADT implementation Components for values

Answer 17

• Data representation - defined in terms of instance variables that represent intended abstract values of the ADT
• Representation invariant - refers to the conditions to be satisfied by the instance variables in order to make sense as a representation of an abstract value
• Abstraction function - maps each representation that satisfies the rep invariant to the represented abstract value

Question 18

ADT implementation Components for Operations

Answer 18

• Involves providing a method implementation adhering to the contract for each operation
• The pre- and postconditions of each operation must be re-interpreted in terms of the data representation, using the abstraction function
• Also, the public invariant must be honoured

Question 19

Polymorphisms

Answer 19

The ability of objects of different classes to be treated as objects of a common base class

Question 20

Primitive vs. class type variables

Answer 20

• A variable of a primitive type always holds a value of that exact primitive type
• A variable of a class type T can hold a null reference or a reference to an instance of class T or of any class that is a subclass of T

Question 21

Liskov Substitution Principle (LSP)

Answer 21

Let U be a subclass of T.
Type U is called a subtype of type T when:
- In each place where an object of type T can be used, you can substitute an object of type U without affecting the correctness of the program

A subtype is not only syntactically a substitute (it compiles), but also semantically (it works).

Question 22

Strategy Design Pattern

Answer 22

Problem:
Accommodate multiple implementations of the same method by allowing selection at runtime.

Solution:
- Put specification of method in (abstract) class or interface
- Put implementations in subclasses of specification type
- Declare variable with specification type
Assign to variable an object of an implementation type

Question 23

Intent of the Singleton Design Pattern

Answer 23

• Ensures that not more than one instance of a class is ever created
• Provides a global point of access to this instance

Question 24

Solution of the Singleton Design Pattern:

Answer 24

• Make the constructor of the class private to prevent clients from creating instances directly
• Create a private instance of the class
• Add a public static synchronised method getInstance() that returns an instance of the class if one has not already been created
• If a class has already been created, getInstance() returns that instance

Question 25

Singleton vs. Global variable

Answer 25

Benefits - Both allow easy access - Singleton ensures at most one instance is created Drawbacks: - Global variables creates name space pollution - as singleton access statically - Global variables creates uncertain intialisation order - - Global variable no access control on variable - Both create weakened modularity - as all modules will have depend on only one instance - Testing is more difficult - because all test most work on the same variable - Code reuse is hindered - because you must reuse the global variable

Question 26

How to avoid dependency on globals?

Answer 26

Parameterizing modules and supplying actual concrete globals as arguments Make other modules depend on an abstract interface, hence they do not depend on concrete globals Create an interface that holds the variable that would have otherwise been global and have any class that would make use of that variable implement the interface

Question 27

Template Method Pattern Motivation

Answer 27

- Some code fragments may resemble each other without being duplicates - Resemblance is in overall structure, and hence parameters are not a solution - Difference is in some steps

Question 28

Temple Method Pattern Intent

Answer 28

Create an abstract class with a final templateMethod() that calls some other methods in it. Make those methods abstract so that they can be edited by the classes that extend the superclass.

Question 29

Alternative to Template Method Patter

Answer 29

- Consider each step a Strategy and apply strategy design pattern - Introduce a template method class with constructor with parameter for each abstract step type and instance varaible for each abstract step - Client code passes concrete steps into the class

Question 30

Dependency Inversion Principle (DIP)

Answer 30

high-level modules should not depend on low-level modules, but both should depend on abstractions For high-level modules write abstract classes and extend the class and @overide the method

Question 31

Factory Method Design Pattern Motivation

Answer 31

Tackles the problem of new statements requiring constructors of a concrete class, which makes client code depend on the concrete class

Question 32

Factory Method Design Pattern Intent

Answer 32

- TO define an interface for creating n object, but subclasses decide which class to instantiate (creating an object)

Question 33

Factory Method Design Pattern how to construct

Answer 33

1. Create two different abstract classes, one called product and one called productCreator 2. Inside productCreator add two method one abstract, and one with an implementation. 3. Call the former (abstract) createProduct method and the latter clientCode 4. CreateProduct has no implementation as it is abstract and clientCode creates a new product object and assigns to it the ouptut of createProduct 5. For each of the types of products relevent create a class that extends the product abstract class and create a class that extends the product creator class. 6. For each of the classes extending the productCreator class overide the createProduct method, returning an object of the product subclass represented by the product creator subclass

Question 34

Encapsulate what varies

Answer 34

Identify the aspects of your application that vary, and separate them from what stays the same

Question 35

Generic Types Definitions

Answer 35

- A generic type is equivalent to a parameterized type E.g., List where E is a formal type parameter - Are used by substituting concrete class types for the formal type parameter E.g., List,List> Benefits are improved readability, reusability, and robustness

Question 36

Iteration can abstract:

Answer 36

- Type of collection - Type of its items - Implementation details of how to accomplish iteration

Question 37

Testing cases for Iterators

Answer 37

- Check that every element is returned exactly once (no misses, no duplicates) - Check that iterator works without and with multiple calls to hasNext()

Question 38

Some Iterator Anti-Patterns

Answer 38

- Giving access to internal data representation to let the client iterate - leaks representation and client can break rep invariant - Include operations for iteration in collection class itself, which leads to not being able to have multiple iterations active concurrently

Question 39

Dynamic Structure

Answer 39

- A stack of call methods, where a lower method calls are added on the stack when the highest method in the stack will call them

Question 40

Top-level class

Answer 40

class that is not defined as nested or inner class within another class, but is the primary, outermost class in a Java source file

Question 41

Nested class

Answer 41

A class that is defined within another class

Question 42

Types of nested classes

Answer 42

- Static member class - Non-Static member class - Named local class - Anonymous class

Question 43

Static member class

Answer 43

A class inside another class with static header or A class in the same file with another class but not inside it or A class in a different file --------------------------------------------------------------- - If it is in the same file, it cannot be public - Only has access to instance variables and methods of outclass if they are static - Can refer directly to all static members of outer class without qualifying there name

Question 44

Non-static member class

Answer 44

- Has to be in a class without static header - Each instance of nested class is associated with the instance of the top-level class inside which it was constructed - Creating and accessing objects of inner class is done statically - Can access all member of the out class - Inner class cannot contain static members or unless they are also final

Question 45

Named local class

Answer 45

- Define within a block of code, typically within a method - Can only access the variables of the enclosing block of code, if they are declared as final or effectively final (it is assigned once and never changed but does not have the final thing)

Question 46

Unanomouse class

Answer 46

- Special type of local class that does not have a named identifier - often used for one-time use - e.g. of definition, Class class = new Class() { ///inside of class } --- Limirations - Cannot define their own constructors

Question 47

Benefits of Nested Classes and Interfaces

Answer 47

- Logical Grouping (increased coherence) - Encapsulation (decreased coupling) - Improving readability and maintainability - Simpler code

Question 48

Sharing/aliasing def

Answer 48

which is when two distinct variables name the same object

Question 49

Immutably

Answer 49

When the state of a T object cannot change after construction

Question 50

Two Equal objects if

Answer 50

when they are behaviourally indistinguishable. That is, every sequence of operation (queries and commands), when applied to both objects, yields the same result.

Question 51

Two objects are said to be similar when ..

Answer 51

observationally indistinguishable. That is, every sequence of queries only (no commands), when applied to both objects, yields the same result.

Question 52

==

Answer 52

checks whether two object references point to the exact same memory location

Question 53

.equals

Answer 53

checks whether the actual contents or values of objects to determine if they are equivalent

Question 54

Mutable vs Immutable Objects

Answer 54

Mutable objects are equal when they are the same object (==), whilst immutable objects are equal when they are similar. Immutable objects are ALSO equal if they're similar