Chapter 3: Object-orientated programming

Question 1

Object

Answer 1

An entity that can take on a data-type value.

An instance of a data type.

Question 2

Data abstraction

Answer 2

The ability to define new data types and to manipulate objects holding data-type values.

Question 3

8 Primitive data types

Answer 3

• boolean
• byte
• char
• double
• float
• int
• long
• short

Question 4

Data type

Answer 4

A set of values and a set of operations defined on those values.

Question 5

API

Answer 5

Application programming interface

A document whose purpose is to provide the information needed to write programs using the data type.

Question 6

Constructor

Answer 6

Creates an object and returns to the client a reference to the object, not the object itself.

Question 7

Identity

Answer 7

The memory space associated with the object.

Question 8

Pointer

Answer 8

An object whose value refers directly to another value stored elsewhere in the computer memory using its address.

Question 9

Uninitialized variable

Answer 9

A variable that has been declared of a reference type but has not been assigned a value.

Question 10

3 Essential properties of objects:

Answer 10

• state
• behavior
• identity

Question 11

State of an object

Answer 11

A value from its data type.

Question 12

Behavior of an object

Answer 12

Defined by the data type’s operations.

Question 13

Identity of an object

Answer 13

The place where the object is stored in memory.

Question 14

What is used to create objects in OOP?

Answer 14

constructors are invoked

Question 15

How are object states modified in OOP?

Answer 15

instance methods are invoked

Question 16

Assignment statement

Answer 16

A statement that creates a second copy of a reference.

It does not create a new object, just another reference to an existing object.

Question 17

Aliasing

Answer 17

The situation where assignment statements don’t create a new object, but rather another reference to an existing object.

Both variables refer to the same object.

Question 18

Immutable

Answer 18

A data type that has no methods that can change an objects’ value.

Question 19

public entity

Answer 19

An entity that is accessible by clients

Question 20

private entity

Answer 20

An entity that is not accessible by clients

Question 21

final modifier

Answer 21

A modifier that indicates that the value of the variable will not change once it is initialized.

Question 22

Convention to using public and private

Answer 22

public - Used for all methods and constructors in the API

private - everything else

Question 23

Typical private methods

Answer 23

Helper methods, used to simplify code in other methods in the class.

Question 24

Local variables

Answer 24

Variables to which there is just one value corresponding to each one at a given time

Question 25

Instance variable

Answer 25

Variables to which to which there are numerous values corresponding to each one at a given time (one for each object that is an instance of the data type).

Question 26

The process behind invocation of a constructor:

Answer 26

Java automatically: - Allocates memory space for the object - Invokes the constructor code to initialize the instance variables - Returns a reference to the object

Question 27

3 Types of variables

Answer 27

- Argument variables - Local variables - Instance variables

Question 28

Encapsulation

Answer 28

The process of separating clients from implementations by hiding information.

Question 29

3 Reasons for encapsulation

Answer 29

- Enables modular programming - Facilitates debugging - Clarifies program code

Question 30

Wide interface

Answer 30

An interface with an excessive number of methods.

Question 31

Techniques to reduce the effective width of an interface

Answer 31

- Use overloading to provide implementations of basic methods for all types of data - Include methods that are orthogonal in functionality

Question 32

Basic mantra for data types

Answer 32

Whenever possible, clearly separate data and associated operations within a program.

Question 33

Primary value of API

Answer 33

They allow client code to ignore a substantial amount of detail found in the standard representations of these abstractions.

Question 34

Java support for enforcing encapsulation

Answer 34

The private visibility modifier

Question 35

Value of encapsulation enabling modular programming

Answer 35

Allows us to: - Independently develop of client and implementation code - Substitute improved implementations without affecting clients. - Support programs not yet written

Question 36

Value of encapsulation isolating data-type operations:

Answer 36

Leads to the possibility of: - Adding consistency checks and other debugging tools in implementations - Clarifying client code

Question 37

Immutable data type

Answer 37

The property that the value of the object never changes once constructed.

Question 38

Mutable data type

Answer 38

Manipulates object values that are intended to change.

Question 39

Purpose of immutable types

Answer 39

To encapsulate values that do not change so they behave in the same way as primitive types. We can use them without having to worry about their values changing.

Question 40

Purpose of mutable types

Answer 40

To encapsulate values as they change.

Question 41

Advantages of immutability

Answer 41

- Easier to use | - Less misuse (smaller scope of code to change their values)

Question 42

Cost of immutability

Answer 42

A new object must be created for every type.

Question 43

Java support for enforcing immutability

Answer 43

The final modifier

Question 44

Final modifier

Answer 44

The object can only be assigned a value once, either in an initializer or in the constructor.

Question 45

Inheritance

Answer 45

Support for defining relationships among objects.

Question 46

Interfaces

Answer 46

Provide a mechanism for specifying a relationship between otherwise unrelated classes, by specifying a set of common methods that each implementing class must contain.

Question 47

Subtyping

Answer 47

``` A powerful technique that enables a programmer to change the behavior of a class and add functionality without rewriting the entire class. This is done by defining a subclass. ```

Question 48

Subclass

Answer 48

``` A Class that inherits instance variables and instance methods from another class - its superclass. The subclass contains more methods than its superclass. ```

Question 49

Two reasons subtyping makes modular programming difficult:

Answer 49

- Any change in the superclass affects all subclasses - the fragile base class problem - Subclass code - having access to instance variables - can subvert the intention of the superclass code.

Question 50

Fragile base class problem

Answer 50

A state where the subclass cannot be developed independently of the superclass as it is completely dependent on its superclass.

Question 51

Data mingin

Answer 51

The process of searching through the massive amounts of information now accessible to every user on the web.

Question 52

Assertion

Answer 52

A boolean expression that you are affirming is true at that point in the program. If the expression is false, the program will terminate and report an error message.

Question 53

Purpose of assertions

Answer 53

They are widely used to detect bugs and gain confidence in the correctness of programs. They also serve to document the programmer's intent.

Question 54

Design-by-contract programming model

Answer 54

``` The designer expresses a: - precondition - postcondition - invariats - side effects During development, these conditions can be tested with assertions (which can be used to aid in debugging). ```

Question 55

Precondition

Answer 55

The condition that the client promises to satisfy when calling a method.

Question 56

Postcondition

Answer 56

The condition that the implementation promises to achieve when returning from a method.

Question 57

Invariants

Answer 57

Any condition that the implementation promises to satisfy while the method is executing

Question 58

Side effects

Answer 58

Any other change in state that the method could cause.