Test 2

Question 1

What happens if I declare a specific type for a list interface

Answer 1

declare a specific type → need to define
many List interfaces, one for each specific type
creates a lot of duplicate code

Question 2

what happens if I declare a list with elements are simply Object

Answer 2

lose the safety of compile-time type checking (need to cast) cant do anything with the list because it needs to be casted to type

Question 3

type parameter

Answer 3

a variable that takes a type as its value and
is used to make a generic class or interface more specific

Question 4

what type is List<E></E>

Answer 4

generic type

Question 5

List<String></String>

Answer 5

parameterized type

Question 6

List

Answer 6

raw type

Question 7

what can you do with Parametrized types

Answer 7

Can declare variables of parameterized types
Can construct objects of parameterized types
Can invoke methods on objects of parameterized types
Can define methods that take or return parameterized types

Question 8

what can’t raw types do

Answer 8

never declare or instantiate!

Question 9

what can generics extend

Answer 9

Generic types can extend/implement other generic types
We could not define…
public class MyList<T> implements List<E>
Generic types can extend non-generic types</E></T>

Question 10

what can non generics extend

Answer 10

Non-generic types can also extend/implement generic types

Question 11

Invariance

Answer 11

must use the exact type specified

Question 12

Contravariance

Answer 12

can use a less specific type than declared

Question 13

Covariance

Answer 13

can use a more specific type than declared

Question 14

Pros of covariance

Answer 14

more flexible

Question 15

invariance

Answer 15

more safe (less prone to failing at runtime)

Question 16

boolean add(E elem) (.add)

Answer 16

adds elem to the end of the List and returns true, if its an element it return false

Question 17

add(int idx, E elem)

Answer 17

adds elem to the List at index idx

Question 18

E set(int idx, E elem) (.set)

Answer 18

places the element at index idx in the
List, replacing what was there previously

Question 19

E get(int idx)

Answer 19

returns the element at index idx in the List

Question 20

int indexOf(E elem)

Answer 20

returns the index of elem in the List

Question 21

boolean contains(Object obj)

Answer 21

returns true if obj is in the
List; false otherwise

Question 22

E remove(int idx)

Answer 22

removes element at index idx from the List

Question 23

boolean remove(Object obj)

Answer 23

removes obj from the List

Question 24

if remove could be boolean remove or normal remove what does java go with

Answer 24

removes number at that idx

Question 25

what do u do when u want to remove a certain value from a list but that number is also a valid index

Answer 25

.remove(Integer.valueOf());

Question 26

If we define a generic type (class or interface) by declaring one or more type parameters, what is the scope of those type parameter(s)?

Answer 26

The scope would be the entire class or a single method.

Question 27

There are only two circumstances under which it may be a good design to use a raw type. What are those circumstances?

Answer 27

a. When you want to access a static field or method of generic class because it enables you to quickly create non empty lists b. When you want to use instanceOf to perform type checking

Question 28

what are javas 3 primary ways of creating a constructor

Answer 28

1. Default constructors (zero args) – create an empty container: List myList = new ArrayList(); 2.Copy constructors – create a shallow copy of a given container 3.Static “factory” methods – quick means of building a new non-empty container List myList = List. of(1, 3, 5, 7, 9)

Question 29

difference between generic methods and types

Answer 29

Generic methods offer greater flexibility. Generic types offer better consistency & type safety generic types are a good fit for when you want a consistent type across multiple methods that share state

Question 30

If we define a generic method by declaring one or more type parameters, what is the scope of those type parameter(s)?

Answer 30

The scope of the type parameter is simply the single method for which it is defined

Question 31

describe one situation in which a generic method would be the better design

Answer 31

An example would be if we had a generic copier method this way we could use one copier object once to copy lists of different type inputs. If we used a generic class we would have to instantiate a different copier for each type of list we wanted to copy

Question 32

Describe one situation in which a generic class would be the better design

Answer 32

Generic classes are better for consistency and type safety. An example would be a Map class when the values for K and V are type parameters for the entire class, having Java’s static type checking guarantees the argument type will match the parameter type and the return value is assigned to the right type.

Question 33

pros and cons of LVT

Answer 33

Pros of explicit declaration: ● Code is more “self-documenting” ● Can be used in all cases ● Have full control over the choice of numeric type (e.g. int vs. short) Cons of LVTI: ● Code is less self-documenting ● Can only be used in select cases ● Can’t indicate that you want a byte or short (will always get an int)*

Question 34

pros and cons of explicit declaration

Answer 34

Pros of explicit declaration: ● Code is more “self-documenting” ● Can be used in all cases ● Have full control over the choice of numeric type (e.g. int vs. short) Cons of explicit declaration: ● Code might take slightly longer to write ● Less adaptable to interface changes

Question 35

Two kinds of type inference in modern Java:

Answer 35

1. Local variable type inference (LVTI), introduced in Java 10 2. Generic type inference (diamond operator), introduced in Java 7

Question 36

generic type inference

Answer 36

● Pros: ○ Code is faster to write ○ Code is more adaptable to changes, in interfaces and locally ○ Code is arguably more readable (shorter, but without any loss of information) if declaration & construction are in the same line ● Cons: ○ Code is less readable if declaration & construction statements are not located near each other Verdict: use whenever declaration & construction are near each other!

Question 37

what happens when LVTI and generic type is combined

Answer 37

var myList = new ArrayList<>(); ● Problem: ○ var infers the type from the righthand side; finds ArrayList, but no type parameter ○ <> infers the type from the lefthand side; no type is found ● Result: type is ArrayList