Chapter 8: Lambdas and Funcional Interfaces

Question 1

Functional programming focuses more on expressions than loops.

Answer 1

True

Question 2

Lambda expressions work with interfaces that have exactly one abstract method.

Answer 2

True

Question 3

Parentheses around lambda parameters can be omitted if there is only one parameter and its type is not explicitly stated.

Answer 3

True

Question 4

The lambda expression () -> true is valid and takes zero parameters.

Answer 4

True

Question 5

A lambda expression must always have an explicit return statement.

Answer 5

(False, it can be omitted for single-expression lambdas.)

Question 6

Lambda expressions must always declare parameter types explicitly.

Answer 6

(False, type inference is allowed.)

Question 7

A lambda expression can have multiple abstract methods in its functional interface.

Answer 7

(False, only one abstract method is allowed.)

Question 8

Lambdas are a feature introduced in Java 14.

Answer 8

(False, they were introduced in Java 8.)

Question 9

The arrow operator (->) is optional in lambda expressions.

Answer 9

(False, it is mandatory.)

Question 10

A lambda expression must always have at least one parameter.

Answer 10

(False, it can have zero parameters, e.g., () -> true.)

Question 11

The lambda (String x) -> X.startsWith(“test”) is correct.

Answer 11

(False, X should be lowercase as x.)

Question 12

The lambda is valid.

(String x, String y) --> x.startsWith("test")

Answer 12

It’s valid as long as it matches a functional interface with:
* Two String arguments
* A boolean return type

Question 13

The lambda x, y -> x.startsWith(“fish”) is valid.

Answer 13

(False, parentheses are required for multiple parameters: (x, y) -> x.startsWith(“fish”).)

Question 14

The lambda x -> { x.startsWith(“camel”); } is valid.

Answer 14

(False, missing return statement inside {}.)

Question 15

The lambda x -> { return x.startsWith(“giraffe”) } is valid.

Answer 15

(False, missing semicolon inside {}.)

Question 16

The lambda String x -> x.endsWith(“eagle”) is valid.

Answer 16

(False, missing parentheses around x.)

Question 17

The lambda expression s -> {}; is invalid.

Answer 17

(False, it is valid as an empty lambda body.)

Question 18

var invalid = (Animal a) -> a.canHop(); compiles successfully.

Answer 18

(False, var cannot infer the functional interface type.)

Question 19

Lambdas must be enclosed within a class or method.

Answer 19

“Partially false. While lambdas can be assigned to a variable or passed directly as arguments, they must still be enclosed within a class or method. They cannot exist at the top level outside of a class.”

Question 20

A lambda with multiple lines of code does not require braces {}.

Answer 20

(False, braces are required for multiple statements.)

Question 21

What is an unbounded generic type in Java?

Answer 21

An unbounded generic type ‘<’T’>’ can accept any type, with Object as the implicit upper bound.

Question 22

What is a bounded generic type in Java?

Answer 22

A bounded generic type

(<T extends SomeClass>)

restricts T to be a subtype of SomeClass.

Question 23

What does <’T extends Number’> mean?

Answer 23

T can be any subclass of Number (e.g., Integer, Double, Float), but not String or other non-numeric types.

Question 24

What does <’T’> mean in Java generics?

Answer 24

It means T can be any type, effectively making it equivalent to <’T extends Object’>.

Question 25

What does it enforce? ``` > ```

Answer 25

```It ensures T implements the Comparable interface, allowing objects of T to be compared.```

Question 26

What is '<'T super Integer'>' used for?

Answer 26

It means T can be Integer, Number, or Object—any superclass of Integer.

Question 27

Can an unbounded generic type `````` call methods of Number?

Answer 27

No, because `````` could be any type, not necessarily a Number subclass.

Question 28

What is the benefit of using bounded generics?

Answer 28

It allows type-specific operations (e.g., T extends Number allows T.doubleValue()).

Question 29

What is the difference between <'T'> and <'T' extends 'Object'>?

Answer 29

They are functionally identical, since Object is the default bound for unbounded generics.

Question 30

Which generic declaration allows working with only numeric types?

Answer 30

'<'T' extends Number'>' ensures T is a number type like Integer or Double.

Question 31

Why can a .java file contain a public class?

Answer 31

✔ A .java file can have a public class to make it accessible from anywhere in the project. ✔ The filename must match the public class name.

Question 32

What happens if a .java file has a public class with a different name?

Answer 32

❌ Compilation error! ✔ The filename must match the public class name.

Question 33

What if a .java file has no public class?

Answer 33

✔ The main class has default (package-private) access. ✔ The class is accessible only within the same package. This file can be named anything (e.g., AnyName.java).

Question 34

Can a .java file have multiple classes?

Answer 34

✔ Yes, but only one class can be public. ✔ Other classes must have default (package-private) access. The file must be named MainClass.java.

Question 35

When should a class be public vs. default?

Answer 35

✔ Use public when the class needs to be accessed from other packages. ✔ Use default access when the class is only for internal use within the package. ✅ Helps in encapsulation and better package organization.

Question 36

What makes a lambda expression syntactically incorrect when specifying variable types?

Answer 36

A lambda is incorrect if it specifies variable types without enclosing the parameter list in parentheses. For example, s -> s.length() is correct, but String s -> s.length() is invalid; it should be (String s) -> s.length().

Question 37

How do you correctly declare a type in a lambda expression parameter?

Answer 37

You must wrap the parameter in parentheses, like this: (String s) -> s.length(). Omitting the parentheses when specifying types causes a syntax error.

Question 38

When can you omit parentheses in a lambda expression?

Answer 38

You can omit parentheses only when there's a single untyped parameter, e.g., s -> s.length(). If the parameter has a declared type, parentheses are mandatory: (String s) -> s.length().