TEST 1

Question 1

What are the parts of software development?

Answer 1

Requirements, Design, Implementation, Testing and Debugging, Maintenance

Question 2

What two things shape what design needs to meet

Answer 2

functional requirements and software quality metrics

Question 3

What are design choices

Answer 3

ALGORITHM- what sequence operations is preformed DATA STRUCTURE- how information is represented COMPONENT DESIGN - how software is designed

Question 4

Application Software

Answer 4

Software designed to solve specific tasks for users, typically written in a high level language

Question 5

system software

Answer 5

software that interfaces between the application software and hardware (or lower layers of system software) ie runtime, operating, virtualization

Question 6

hardware

Answer 6

physical resources such as memory (RAM), processing power (CPU), storage (disk), and I/O devices

Question 7

What are the key components of programming languages

Answer 7

grammar, semantics, libraries

Question 8

interpreter

Answer 8

a program that executes programs written in a language

Question 9

complier

Answer 9

program that translates program language into another language (typically a binary)

Question 10

what are the primary programming paradigms

Answer 10

Imperative, object- oriented, functional, declarative

Question 11

imperative

Answer 11

series of statements that mutate programs state, these statements detail how to preform each operation – outputs can depend on combo of inputs and external states, side effects are allowed

Question 12

functional

Answer 12

immutability, all functions are pure (no side effects, output soley depends on inputs)

Question 13

cons of imperative

Answer 13

Behavior can be harder to understand
● Debugging can be more challenging
● Order is more crucial

Question 14

Pros of imperative:

Answer 14

Efficient
● Familiar
● Parallels how computers actually work

Question 15

Pros of functional

Answer 15

Proofs and analysis are easier
● Can be easier to test and debug
● Order of execution is less important
(easier to parallelize)

Question 16

Cons of functional

Answer 16

Can sometimes be less efficient
Can’t use familiar constructs such as
loops

Question 17

declarative

Answer 17

express logic of what without detailing its control flow how

Question 18

Pros of more declarative:

Answer 18

Abstracts away the low-level details
● Equivalent code is typically shorter
● Self-documenting (goal is explicit)

Question 19

Cons of more declarative:

Answer 19

Can sometimes be less efficient
● Gives the programmer less control

Question 20

Is OOP imperative or functional, in terms of mutation

Answer 20

Can be either! Imperative is more common

Question 21

Is OOP imperative or declarative, in terms of abstraction

Answer 21

Some argue declarative: once objects are defined, you can use
them abstractly without knowing how they work under the hood
I disagree; someone still has to define how they operate before
using them!

Question 22

pros of OOP

Answer 22

High level of abstraction & encapsulation
● High level of modularity
● High level of extensibility & reusability

Question 23

Static type system

Answer 23

type-checking happens at compile-time
○ Variables have types; type system checks that assigned values
match declared variable types

Question 24

Dynamic type system

Answer 24

type-checking happens at runtime
○ Values have types; variable types are inferred from their values

Question 25

Pros of static

Answer 25

Guarantees that type errors will not occur at runtime;
effectively free,
automatic testing by the compiler

Question 26

Cons of static

Answer 26

Code is a bit bulkier
can feel slow and onerous to write code that will pass static type checks

Question 27

Cons of dynamic

Answer 27

May encounter runtime type errors (potentially after code has been running for a long time)

Question 28

Pros of dynamic

Answer 28

● Code is sleeker
● Writing code is faster

Question 29

strong typed

Answer 29

Variables have a
shallow fixed type
Variables have a
deep fixed type

Question 30

weak typed

Answer 30

No notion of types
(e.g. assembly code,
machine code)
Values have
a fixed type
stronger typing leads to greater type safety(the extent to which type errors are disallowed)

Question 31

type safe

Answer 31

can be used to describe languages or programs
If a language is type safe, programs written in it are type safe

Question 32

examples of type safe languages

Answer 32

Java is a type-safe language
while JavaScript and C++ is not a type-safe language

Question 33

evolution of programming languages

Answer 33

machine-independent, higher-level abstractions (functions), support for OOP, programming languages created , built in libraries

Question 34

Java Compilation & Execution

Answer 34

source code, complier, bytecode, class loader, execution engine, result

Question 35

type system of java

Answer 35

strong and statically typed- means you must declare things explicitly ot implicitly

Question 36

primitive types

Answer 36

numeric types, boolean, char

Question 37

strings

Answer 37

object type but behavior like primitive- cant be mutated and can be created without constructor- surrounded by double quotes

Question 38

literal

Answer 38

a symbolic representation of a value ie x = 5 assignment of literal 5 to variable x

Question 39

variable

Answer 39

a name associated with memory location ie int x a declaration that variable x is of type int

Question 40

Declaration

Answer 40

a statement associating a variable with a type

Question 41

Assignment or definition

Answer 41

a statement that places a value in
the memory location associated with a variable

Question 42

Rules of Assignment

Answer 42

The defined value of a variable must match the declared type
The defined value of a variable must match the declared type

Question 43

Primitive Type numeric definitions

Answer 43

long literals can optionally
include a trailing “L” float literals must include
a trailing “F”; without it java assumes its a double
double literals can optionally
include a trailing “D”

Question 44

Primitive Type boolean definitions

Answer 44

boolean literals must be lowercase

Question 45

Primitive type char definitions

Answer 45

char literals must be designated with
single quotes; String literals must be
designated with double quotes

Question 46

initial values

Answer 46

For numeric types: 0 (or 0.0, or 0.0F)
For booleans: false
For chars: the null character (‘\u0000’)
For Strings, arrays, and objects: null

Question 47

final keyword

Answer 47

final keyword tells the compiler that a variable will never
be re-defined ie final int x = 5

Question 48

operator

Answer 48

a symbol that is built into a programming
language and has a specific, well-defined behavior, takes arguments (amount of arguments it takes it fixed)

Question 49

Arithmetic operators:

Answer 49

take numeric expressions yield 1 numeric values
addition (can preform a cantaonation between string and int) plus operaters automatically takes care of any conversions
subtraction
multiplication
divison (overloaded 3/2 = 1 but 3/2.0 = 1.5)
modulus

Question 50

logical

Answer 50

yeild a boolean value

Question 51

relational operators

Answer 51

used for comparison used for any types

Question 52

ternary

Answer 52

<boolean> ? <expr> : <expr> --> if <boolean> is true, yield <expr>;
otherwise, yield <expr>
String a = (b > c) ? “b is greater” : “c is greater or eq”
</expr></expr></boolean></expr></expr></boolean>

Question 53

augmented assignment operations

Answer 53

with exceptions of += a and b need to be numeric a = b
a += b a = a + b
a -= b a = a - b
a *= b a = a * b
a /= b a = a / b
a %= b a = a % b

Question 54

Control flow

Answer 54

the sequence of statements executed in a program

Question 55

“straight-line”

Answer 55

sequences of statements excuted one after the next

Question 56

“branches” to the control flow

Answer 56

conditionals and loops, multiple paths, ○ Which path is taken depends on the current program state

Question 57

Blocks

Answer 57

group together a series of statements to be executed
In Java, blocks are generally denoted using curly braces { }

Question 58

Scope

Answer 58

the set of blocks in which a variable is valid/usable– , a variable’s scope is the block in which it was declared
+ any blocks nested inside that block

Question 59

two rules of scope

Answer 59

Can’t reference a variable outside of its scope
Can’t re-declare a variable within its scope

Question 60

Conditionals

Answer 60

Control flow depends on the value of a boolean expression
if (<boolean>) {
// do something
...
} else if (<boolean>) {
// do something else
...
} else {
// do something different entirely
}
Exactly one if block per conditional,
followed by zero or more else if blocks
only first if block whos condition is true gets executed even if others are true
At most one else block per conditional - only executed if everything else was false</boolean></boolean>

Question 61

Switch Statements

Answer 61

Control flow depends on the value of a single variable

switch (<variable>) {
case <value>:
// do thing 1
break;
case <value>:
// do thing 2
break;
default:
// do thing 3
}</value></value></variable>

these values must be constant, cannot be arrtibuary involving variables

Question 62

default case

Answer 62

executes everything from the match case to the default statement if there is no break statement or if it does not meet any of the cases

Question 63

pure function in java

Answer 63

“procedure” or “subroutine” = a
sequence of statements packaged together into a callable unit

Question 64

parameters

Answer 64

variables that are defined in the function
header and can be referenced within the function

Question 65

function header

Answer 65

public void addTwoInts(int num1, int num2) structure is privacy, return type (void if nothing is returned), name of function in camel case, the parameter list a list of <type> <name> pairs</name></type>

Question 66

arguments

Answer 66

the specific values that get “bound” (assigned)
to the parameters (variables) when the function is called

Question 67

local variables

Answer 67

Their scope is the function in which they’re declared

Question 68

If you want your compiled program to be a standalone executable, you
must define a function with this exact header to serve as the “entry point

Answer 68

public class Main {
public static void main (String[] args) {
System.out.println(“hello world!”);
}
}

Question 69

What are array limitation?

Answer 69

An array is declared with a type; all elements must be of that type
An array is defined with a size and cannot exceed that size

Question 70

Why cant array sizes change?

Answer 70

ordered sequence of fixed-size storage locations
○ Each slot typically fits one byte (8 bits)
○ At runtime, all of the data that your program creates is stored in memory
If we fix an array’s size, we can place it in a contiguous chunk of memory,
making it easy to find the ith element

Question 71

how to declare an array in java?

Answer 71

int[] myArray; int myArray[];

Question 72

primitive types

Answer 72

values associated with variables stored directly in the chunk of memory associated with variable name (no arrows or pointers)

Question 73

what does new keyword do

Answer 73

demonstrates a constructor for arrays and objects because java doesn’t allocate memory till after construction

Question 74

null

Answer 74

java reverses a special value, one that isn’t a valid memory address for data to represent null X doesnt point to null it is null

Question 75

accessing arrays

Answer 75

don’t reference each individual object elements directly embed within an array

Question 76

how to populate arrays

Answer 76

Use curly braces { } to explicitly
define the elements; this must be done
at the same time as construction
int[] myArray = new int[]{7, 5, 8};

Use square brackets [ ] to set
individual values in the array;
int[] myArray = new int[3];
myArray[2] = 8;
myArray[1] = 5;
myArray[0] = 7;

Question 77

how to print contents of string

Answer 77

int[] myArray = new int[]{1, 2, 3};
System.out.println(Arrays.toString(myArray));

Question 78

Fields

Answer 78

characteristics of an object (“has” relationship) object has
class variables, scope is entire class

ie
Student object
fields: college(string), gpa (int), hobbies (array

Question 79

Methods

Answer 79

actions that an object can perform (“can” relationship)
can be invoked on objects of those class types

ie
Student object
methods: eat(), sleep(), test()

Question 80

A class

Answer 80

a template for a specific type of object

Question 81

how to define a class

Answer 81

public class <classname> {
// field declarations
...
// method declarations
}</classname>

Question 82

this

Answer 82

Method calls & field
accesses within the
class should be
prefaced by this

Question 83

public

Answer 83

accessible outside of the class in which it was defined

Question 84

protected

Answer 84

only accessible in the class + any sub-classes

Question 85

private

Answer 85

only accessible in the class in which it was defined

Question 86

package-protected

Answer 86

only accessible in the package in which the
class is defined

Question 87

Constructor

Answer 87

a special method used to create new objects
Defined as a method with the same name as the class
no return type;
returns an instance of
the Bunny class
constructors often set up
initial values for the fields
public Bunny(String color, float weight) {
this.color = color;
this.weight = weight;
}

Question 88

objects constructed

Answer 88

use new keyword <classname> <varname> = new <classname>(<args>);
ie Bunny fluffy = new Bunny(“black”, 7.1F);</args></classname></varname></classname>

instance of the Bunny class

Question 89

Define Method

Answer 89

public void eatCarrots(int numCarrots) {
this.numCarrotsEatten += numCarrots;
}

Question 90

primative types

Answer 90

A variable of primitive type directly stores its value

Question 91

reference type

Answer 91

Objects are reference types, which means that a variable of
“object type” actually contains a memory address

Question 92

within a class method how do you refer to object operated on

Answer 92

you refer to object being operated on as this
When you invoke a method on an object, within the context of that
method call this becomes another reference to that object

Question 93

why do we use static

Answer 93

every function must be defined inside of a class
static fields & methods can be accessed without an instance,
e.g. Math.E, Math.PI, Math.pow(double a, double b)

Question 94

when can static fields be accessed

Answer 94

can be accessed without an instance
static methods cannot access non-static fields & methods
static fields & methods can be accessed by both static &
non-static methods
static fields’ values are shared by all instances of the class
static methods are invoked
using <class>.<method> rather
than <object>.<method></method></object></method></class>

Question 95

“wrapper”

Answer 95

this allows primitives to be treated as objects
These typically have the exact same names, but capitalized
○ e.g. long → Long, float → Float,
○ Two exceptions: int → Integer, char → Character
allow creators of java to define key methods for primitive types which otherwise wouldn’t be possible since primitive types cant have methods

Question 96

Value of

Answer 96

while you can construct a new
Integer in the “normal” way (new
Integer(5)), the recommended
approach is to use the static
valueOf() method, like so:
Integer x = Integer.valueOf(5);
public class Integer {
private int value;
public static Integer valueOf(int value) {
// Create a new Integer object wrapped
// around the given int value
}

Question 97

implicit type conversions

Answer 97

happen between primitive types and their corresponding wrapper classes

Question 98

Autoboxing & unboxing

Answer 98

automatic conversion from primitive
types to corresponding wrapper classes and vice versa
int a = 5;
Integer b = a;
Although a is technically the wrong type (int
vs. Integer), the compiler autoboxes a’s value

Question 99

explicit type conversations

Answer 99

Casting = a “true” conversion for primitive types; a reassurance
to the compiler for object types
double a = 5.0;
int b = (int) a;

Question 100

type conversions

Answer 100

Java will
automatically
perform a
widening cast
You must
explicitly cast
to convert to a
“narrower” type

Question 101

casting between real numbers to integer types

Answer 101

java rounds down when casting real number type to integer type

Question 102

object type casting

Answer 102

wont perform conversion bc it doesnt know how

Object o = …;
Bunny b = (Bunny) o;
not safe only checked at run time

Question 103

Conversion Functions

Answer 103

functions that are designed to
convert between types
○ Generally the preferred approach; checked at compile-time
○ You can define conversion functions for your classes if need be
○ The wrapper classes provide some conversion functions
String to numeric: Integer.parseInt(“5”),
Double.parseDouble(“5.0”)

Numeric to numeric: Number.intValue(5.0),
Number.doubleValue(5), etc

Question 104

continue

Answer 104

skip the remainder of the current iteration of the
(innermost) loop and proceeds to the next iteration

Question 105

for loops

Answer 105

for (<init>; <condition>; <update>) {
// do something
}
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
Typically all three statements (<init>, <condition>, <update>) are
included, but they’re actually all optional
but if you skip a statement a semi colon must take its place for (; i < 10; i++)</update></condition></init></update></condition></init>

good to use when number of iterations is known or iterating with indices

Question 106

for each loop

Answer 106

for (<vartype> <varname> : <iterable>) {
// do something
}
declaration of a variable that will be used to
refer to each successive element in <iterable>
int[] numbers = new int[]{0, 1, 2}
for (int num : numbers) {
System.out.println(num);</iterable></iterable></varname></vartype>

good when iterating over an iterable and only the values of elements are desired

Question 107

while loop

Answer 107

while (<condition>
int i = 0;
while (i < 10) {
System.out.println(i);
i++;
}</condition>

good when number of iterations is unknown
want to iterate while/until a condition is true

Question 108

when is a while loop better

Answer 108

event driven programming

Question 109

Do-While Loops

Answer 109

do {
// something
} while (<condition>);
first iteration happens regardless of wheter or not that condition is true</condition>

Sometimes <condition> needs to check a variable that you want
to define in the body; a while loop might require duplicate code</condition>

String line = reader.readline();
while (line != null) {
line = reader.readline();
}

String line;
do {
line = reader.readline();
} while (line != null);

goof when want first iterations to occur regardless of condition

Question 110

time efficiency

Answer 110

performance = how quick software runs = algo high, data , str low

Question 111

space efficiency

Answer 111

memory uti/complexity = how much space = data strc

Question 112

scalability

Answer 112

how software responds to increased work (impacted by all)

Question 113

extensibility

Answer 113

how easy it is to add a functionality = components

Question 114

reusability

Answer 114

software used for diff purposes = component

Question 115

modularity

Answer 115

how distinct software components are separated increases both above

Question 116

algorithm design

Answer 116

what sequence of operation is performed

Question 117

data structure

Answer 117

how information is represented

Question 118

component design

Answer 118

how software is structured

Question 119

out sub-directories

Answer 119

files that the compiler generates (.class files)

Question 120

namespace

Answer 120

All classes in the same package live in the same namespace
○ Classes defined in the same namespace can refer to each other
without requiring imports

Question 121

imports

Answer 121

import <package>.<class> = import the single specified class
○ import <package>.* = import the entire package (all classes
defined within it)
○ import <package>.<class>.<staticMethod> = import the single
specified static method</staticMethod></class></package></package></class></package>

import main.rice.subpackage1.*;
import main.rice.subpackage1.ClassA;

Question 122

Testing

Answer 122

the process of executing your software
with sample inputs in order to discover bugs

Question 123

Debugging

Answer 123

the process of scrutinizing your software
(and its behavior) in order to fix bugs found during testing

Question 124

Testing serves two purposes

Answer 124

1. Discover bugs: are there situations in which the software does
   not behave as expected?
2. Clarify the specification: are there situations in which we’re not actually sure what we expect the software to do?

Question 125

test case

Answer 125

(-2, 8) → -16,
you should include inputs and expected outputs!
A good test suite should include tests that cover:
○ Typical cases
○ Edge cases or boundary cases = inputs that are on the edge of
where the program’s control flow or behavior changes
○ (sometimes) Invalid inputs
○ (sometimes) Checks for unexpected side effects

Question 126

White-box testing

Answer 126

implementation is known

Question 127

Black-box testing

Answer 127

implementation is unknown

Question 128

Pros of white-box

Answer 128

● Can achieve “coverage” of every code
path

Question 129

Cons of white-box

Answer 129

May miss classes of inputs that the
implementation does not account for

Question 130

Cons of black-box

Answer 130

May miss code paths if implementation
has unanticipated special cases

Question 131

Pros of black-box

Answer 131

Forces you to systematically
brainstorm “classes” of like inputs

Question 132

test junit

Answer 132

@Test
void testMiniumNegative () {
int [] input = new int [] {3,4,5,2,1}
int expcted = 1;
int actual = SampleClass.minimum(input);
assertEquals(expected,actual);
}
}

Question 133

Code coverage

Answer 133

lines of code exercised by test suite /
lines of code in the program

Question 134

Pros of OOP

Answer 134

High level of abstraction & encapsulation
High level of modularity
High level of extensibility & reusability

Question 135

Cons of OOP

Answer 135

Not always a good fit
Can add a slight time overhead

Question 136

Principles of OOP (Abstraction via Encapsulation + Privacy)

Answer 136

never make fields public
○ Methods should only be public when necessary

Question 137

Principles of OOP (Single Responsibility + Delegation)

Answer 137

each class should have a purposes that is clear, bounded,
and fully contained within that class
Break the problem you’re solving into logical sub-problems
○ Encapsulate the logic for each sub-problem into its own class
○ Have the main class delegate tasks to the other classes

Question 138

Principles of OOP (Loose coupling + Decoupling)

Answer 138

Goal: keep the dependencies between classes low
● In practice:
○ Within your program, aim for loose coupling: classes interact
through interfaces (collections of public methods) that make
minimal assumptions about the underlying implementation
○ When interacting with other programs, aim for decoupling:
use common protocols & formats such as HTTP, JSON, URL

Question 139

loose coupling

Answer 139

when classes interact with each other through interfaces within your own program

Question 140

decoupling

Answer 140

interacting with other programs using common protocols and formats such as HTTP, JSON, and URL

Question 141

Principles of OOP Avoid Duplication

Answer 141

● Goal: don’t duplicate logic or functionality
In practice:
○ Use composition to define an object of one class as being a
composite of other objects
○ Use inheritance to define one class as being a more specific
version of another class

Question 142

Inheritance

Answer 142

declaring that one class “inherits” features
(fields) and/or functionalities (methods) from another class

Question 143

class hierarchy

Answer 143

A class can only directly extend one other class
○ However, there can be arbitrarily many “levels” in the hierarchy
A subclass can only have one direct superclass
○ A superclass can have multiple direct subclasses; this is called
hierarchical inheritance

Question 144

What is inherited

Answer 144

protected and public fields and methods
○ Package-protected fields and methods, if the subclass is defined
in the same package as the superclass
What is not inherited?
○ private fields and methods
○ Constructors*

Question 145

shadow

Answer 145

Define a new field with the same name but a different type (does
not have to be a subclass of the original)
Access the new version with this.<name>
○ Access the original version with super.<name></name></name>

Question 146

override

Answer 146

Define a new implementation, optionally with a more specific
return type (must be a subclass of the original type)
Access the new version with this.<name>
○ Access the original version with super.<name></name></name>

Question 147

concrete class

Answer 147

Fields: can be declared and defined
○ Methods: must not only be declared, but implemented
○ Constructors: can define a constructor and be instantiated
Concrete classes can inherit from other concrete classes, but
will often instead inherit from an abstract class

Question 148

Abstract Classes

Answer 148

○ Fields: can be declared and defined
○ Methods: can be declared and implemented or just declared
○ Constructors: can define a constructor; cannot be instantiated

Question 149

declare abstract

Answer 149

an abstract method cannot be private
abstract keyword can be used on classes & methods, like so:
○ public abstract <className> { ... }
○ public abstract <returnType> <methodName>(<args>);
end with semi color bc no definition</args></methodName></returnType></className>

Question 150

When should the superclass be abstract?

Answer 150

Pretty much any time that you don’t want to instantiate it!
○ It’s bad form to implement a method in the superclass if that
implementation won’t be shared by 2+ (ideally most) subclasses

when the super class will never be used on its own ie a farm represented using Aanimal would care about the specific animals

If a method’s implementation will vary, you can leave it abstract
○ But if a method’s implementation will be shared by most/all
subclasses, you can still implement it in the abstract class!

Question 151

abstract class style guide

Answer 151

the COMP 215 style guide requires that you begin the
name of an abstract class with an A for improved clarity

Question 152

Polymorphism

Answer 152

the ability for one method to take on different forms

Question 153

covariance

Answer 153

the ability to use
a more specific type than declared

Question 154

difference between abstract and interfaces

Answer 154

Fields: non-static fields cannot be declared or defined
○ Constructors: cannot define a constructor or be instantiated

Question 155

methods in interfaces classes

Answer 155

● All methods must be public
● public and abstract designators are optional (assumed if not
present); methods can be declared like so:

<returnType> <methodName>(<parameters>);
no non-static fields or constructors
concrete classes that implement an interface must define all unimplemented methods
</parameters></methodName></returnType>

Question 156

class using an interface methods

Answer 156

public class Bunny implements ICanEat { (implements not extends)

Question 157

When should you use an abstract vs. an interface class?

Answer 157

You want to define fields (and/or implement methods that
need to access fields)
You want to override any methods of the Object class

Question 158

why cant you use interfaces if u want to override any methods of the Object class

Answer 158

For any method, the version that’s inherited from the superclass
hierarchy (including from Object itself) will always take precedence

Question 159

Interface Inheritance

Answer 159

An interface can also extend another interface
○ In this case, we use the keyword extends rather than implements
● An interface cannot extend a class!

Question 160

do two equivalent objects have the same hashcode?

Answer 160

they must have the same hash code

Question 161

do two inequivalent objects have same hashcode

Answer 161

likey have different ones but noy guaranteed

Question 162

object class

Answer 162

automatically top class hierachy– all methods defined in object class can be overriden or invoked on all objects

Question 163

checking equality

Answer 163

The == operator:
● For primitive types, compares by value
● For arrays and objects, compares by reference → will evaluate to
false on two distinct objects with identical values

The equals(Object o) method:
public boolean equals(Object o)
Compares by value → will evaluate to true on two distinct objects
with equivalent values (if defined properly!)

Question 164

how to check types

Answer 164

○ Usage: <object> instanceof <class>
Boolean isBunny = fluffy instanceof Bunny;</class></object>

Question 165

Pattern matching:

Answer 165

equivalent to a type check
+ a cast, but without an
explicit cast
used ti check the type of an object and assign it to a new variable of that type if its type matches

Question 166

Hashing

Answer 166

Hashing is a technique used to store data that relies on
computing an integer “hash code” for each piece of data

Question 167

hash collisions

Answer 167

two objects that arent equal have the same hash code

Question 168

toString()

Answer 168

combines the name of the class with the
hash code of the instance, e.g.: “main.rice.Bunny@a9cd3b1”

you’ll typically want to override toString()
More informative: include the value of one or more key fields
● You can delegate to a field’s toString()
● You can combine multiple strings using concatenation (+) or
Java’s built-in StringBuilder class

Question 169

string builder

Answer 169

the StringBuilder class defines two constructors:
● a zero arg constructor representing the empty string
● a constructor that takes the first segment of the
String being built

Question 170

Every user-defined class must either

Answer 170

Define one or more constructors, or
Inherit a zero-argument (“default”) constructor from its superclass
hierarchy
Java will only search the superclass hierarchy for
a default constructor as long as it has not yet
found a constructor with > 1 arguments

Question 171

Every constructor must call its superclass’ constructor either

Answer 171

Explicitly: super(<args>); in the first line of the constructor
Implicitly: if no call to super() is found, the compiler tries to
automatically insert it (with zero arguments)</args>

Question 172

When a class Sub does not explicitly extend another class

Answer 172

○ Sub’s direct superclass is Object
○ Object defines a zero-argument constructor
○ Therefore Sub doesn’t need to define any constructors
○ If Sub does define constructors, they do not need to call super()
explicitly

Question 173

When a class Sub does explicitly extend another class Supr:

Answer 173

1. If Supr defines a zero-argument constructor:
   ○ Sub does not need to define any constructors
   ○ If it does, these constructor(s) do not need to call super()
   explicitly (compiler will insert appropriate call)
2. If Supr does not define any constructors:
   ○ Assuming Supr compiles… same as case 1!
3. If Supr defines one or more constructors, but they all take one or
   more arguments:
   ○ Sub must define at least one constructor
   ○ These constructor(s) can have any number of arguments
   ○ Must explicitly call super(<args>) with appropriate arguments
   in the first line of the constructor</args>

Question 174

constructor takeaways

Answer 174

even if you define a constructor in the subclass,
the superclass(es)’ default constructor(s) will get called

if the
superclass has a
default constructor,
the subclass doesn’t
need a constructor

if at any point in
the hierarchy a class X has
no constructor, subclasses
of X will find X’s parent class’
default constructor if it exists

: if a class X has a constructor with
parameters but no default constructor, its child
classes cannot call super() without args (even
if there’s a default constructor higher up)

you can explicitly call the superclass’ non-default constructor

Question 175

obj instance class Other

Answer 175

checks if obj is instance of Class, if it is creates a new object (other) that is of class Class
returns a boolean

Question 176

what is privacy of abstract methods

Answer 176

public

Question 177

What are the two rules of assignment in Java?

Answer 177

values cannot be defined before variable type is declared

value of variable must be same type its declared as

Question 178

What privacy level should be used for fields? What privacy level should be used for methods?

Answer 178

For fields they should be protected or private and for methods it should also be protected or private.

Question 179

What is JVM, what are its two key components

Answer 179

Write once run anywhere, JVM defines platform-independent behavior. It is basically a run time system that includes an interceptor.
JVM takes the burden of resource management off the programmer’s shoulders. Serves as an extra layer of system software running beneath java programs. The 2 key components are a class loader which is responsible for loading classes and making them available for execution. The second is the execution engine which is key for executing and communicating with the operations system in order to manage resources.

Question 180

What is JIT compilation? Give an example of how JIT compilation could be used to optimize program performance.

Answer 180

During execution the compiler executes hot code (code run frequently) and compiles it; the idea is that it incurs a one-time overhead but will speed up all subsequent executions of the compiled piece of code which makes the trade off worthwhile for code that is run frequently.

Question 181

If you want your compiled program to be a stand alone executable ,you must define a function with what signature?

Answer 181

Public static void main (String[] args);

Question 182

define the 2 primary patterns of reusability in OO design

Answer 182

a. Composition: where a defined object of one class is a composite of other objects
b. Inheritance : where one class is defined as a more specific version of a different class