Java Programming Paradigms_在线真题试卷与模拟练习_Java Programming Paradigms

更新时间：试题数量：购买人数：提供作者：

有效期：个月

章节介绍：共有个章节

我的练习

我的错题
(0道)

我的收藏
(0道)

我的斩题
(0道)

我的笔记
(0道)

专项练习

顺序练习 0 / 0

随机练习 自定义设置练习量

题型乱序 按导入顺序练习

模拟考试 仿真模拟

题型练习 按题型分类练习

易错题 精选高频易错题

学习资料 考试学习相关信息

搜索

题库预览

Consider the following Java functional interface:

interface StringValidator { boolean test(String s); default boolean initialTest(String s) { return !s.isEmpty(); } }

Which of the following represents a change that will make StringValidator NOT be a functional interface anymore?

What is the main difference between intermediate and terminal Java Stream operations?

Consider the following code snippet: public static void main(String[] args) { String[] numbers = new String[]{"one", "two", "three"}; for (int i = 0; _________; i++) { System.out.println(numbers[i]); } }

Assuming you want to display all numbers, which of the following answers is the correct termination statement missing in the above for statement?

Given the following class:class User { private String name; private int age; // Constructor that takes the two above properties // Getter and setters for name and age }

And the following array:

User[] users = new User[] { new User("John", 20), new User("Mike", 18), new User("John", 30) };

Which option represents a comparator that will sort the array by name, and the values with the same name will sort them by age ascending?

If you create a class called MyClass and then create a local variable of type MyClass, what can this variable contain?

What is meant by a side-effect in the context of a method call with reference type arguments?

What does it mean that Java passes reference method arguments by value?

What is meant by the "fall through" scenario in the context of a Java switch statement?

Given the following Student class, exhibiting two missing keywords as described below:public class Student { private String name; _______ String getName() { return name; } _______ void setName(String name) { this.name = name; } }

What access level modifiers will you use for the getName and setName methods to hide the internal state of this object using encapsulation?

What will happen when you try to compile and execute the following code snippet?public class Main { public static void main(String[] args) { int computationResult = add(2, 3); System.out.println(computationResult); } public static void add(int a, int b) { return a + b; } }

You are converting an object-oriented multi-threaded Java application to the functional paradigm, using only fully-immutable objects. What is a threading-related advantage of this refactoring?

Given the following:public class Test { public static void main(String[] args) { Predicate<Integer> p1 = i -> i > 1; Stream.of(1, 2, 3, 4) .filter( p1.and(i -> i < 4) ) // 1 .forEach(System.out::print); } }

Assuming that the line marked with // 1 is changed by:

.filter( i -> i < 4 && i > 1 )

Which statement is true?

Given the following Stateful class, which doesn't define any setter methods that could be used to mutate its state:

import java.util.Set; public class Stateful { private Set<String> content; public Stateful(Set<String> content) { this.content = content; } public Set<String> getContent() { return content; } }

Assume you have access to an object of type Stateful, referenced by a variable stateful. Which of the following ways correctly represents a modification of the state of the object referenced by stateful?

You are a consultant working at a client's site. Your first meeting is all about understanding the client's business domain, as part of a larger project involving building a new application. Using your transcript of this meeting, together with the use-cases that were put together, how can you identify the main Java classes that will form the application?

Assume you declared a class with a FIELD of type 'int' and you haven't assigned a value to it. How does Java handle this situation?

Why is immutability so important in a multi-threaded Java application?

Assume a Student class exists and that it has a name field. Given the following code, what will it print out?public class Main { public static void main(String[] args) { Student myFirstStudent = new Student("Student1"); Student mySecondStudent = new Student("Student2"); myFirstStudent.name = "Student3"; myFirstStudent = mySecondStudent; System.out.println(myFirstStudent.name); } }

What is a good way to ensure that changes to shared objects do not negatively affect the other objects using them?

You are in the process of writing your first Java Stream. You have chosen your data source, added a few filters and are now ready to finish the stream pipeline. What type of operation is needed now?

Which option composes the following two predicates to represent a short-circuiting logical OR?

Predicate<Integer> p1 = (i) -> i > 10;
Predicate<Integer> p2 = (i) -> i < 5;

1 2 3 4 5