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

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

有效期：个月

章节介绍：共有个章节

我的练习

我的错题
(0道)

我的收藏
(0道)

我的斩题
(0道)

我的笔记
(0道)

专项练习

顺序练习 0 / 0

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

题型乱序 按导入顺序练习

模拟考试 仿真模拟

题型练习 按题型分类练习

易错题 精选高频易错题

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

搜索

题库预览

Why is it important to design the classes of an application based on a solid understanding of the business use cases?

When dealing with overridden methods, the Java platform is able to decide which method should be called at run-time. What is the name of this process?

You are converting a pre-Java 8 application to a style that is heavily centered around the functional paradigm. In addition to using the Java 8 functional updates, you are making most of the objects immutable. You are not adding any new external libraries to the dependency graph. You're now finished with this large refactoring and have been running tests for a few weeks. You notice that the memory usage data is a lot worse than it was before the refactoring. Using strictly the information given above, what is a possible cause of this negative implication?

Given the following Student class:public class Student { public String name; public Student(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } }

Now assume that a List<Student> exists. How would you write a stream pipeline that filters the students having names that start with 'J' and puts the result in a list?

Assume two classes exists, Dog and Animal, where Dog extends Animal. In addition, the following factories exist and a return type in DogFactory's make()method is missing:public interface AnimalFactory { abstract Animal make(); } public class DogFactory implements AnimalFactory { @Override public ______ make() { return new Dog(); } }

Which return type for make() in DogFactory will allow the code to compile?

What is the output of the following program?public class Test { public static void main(String[] args) { Stream<Function<String, String>> stream = Stream.of(String::toLowerCase, String::toUpperCase); String s = stream.map(f -> f.apply("Hello")) .reduce("Hey", (s1, s2) -> s1 + s2); System.out.println(s); } }

Which of the following represents a benefit of using the enhanced for, also called for each, instead of the general form?

Which statement successfully declares a field variable within a class named isValid with a false value?

Why are Java Streams described as lazy?

Assume that you are using Java 8 and you are tasked with converting the following code to make it immutable. Which of the following options will make it fully immutable?import java.util.Date; final public class SomewhatImmutable { private final Date creationTimestamp; public SomewhatImmutable(Date creationTimestamp) { this.creationTimestamp = creationTimestamp; } public Date getCreationTimestamp() { return creationTimestamp; } }

In the following Stream pipeline you can assume that the SomeObject class exists and that it has an id instance variable that is visible:final List<SomeObject> result = someObjects .stream() .filter(element -> element.id.startsWith("404")) .map(element -> element.id) .collect(Collectors.toList());

What is wrong with it?

You are writing a computationally-intensive Java Stream pipeline, which is to be run on a large multi-core machine. The source collection contains a very large number of objects. You will then keep the results that were computed ok in a list. The stream pipeline looks like the following: final List<SomeObject> result = someObjects .stream() .filter(element -> element.doIntenseComputation().startsWith("OK")) .collect(Collectors.toList());

When running it, you notice that it takes a very long time. When examining CPU core load and usage, you notice that most of them are underutilized. What is wrong with your code?

What is the role of accessors in the context of encapsulation?

A lambda expression is an anonymous method that:

In the context of Java, what is the reasoning behind the generally accepted design principle "Favor composition over inheritance"?

What will the following code print out when executed?public static void main(String[] args) { int aPrimitiveVar = 3; System.out.println(aPrimitiveVar); updater(aPrimitiveVar); System.out.println(aPrimitiveVar); } public static void updater(int varToBeUpdated) { varToBeUpdated = 20; }

If you override a method that returns a type T, what return type can this method have?

When a child class extends a parent class, how can the child access the instance methods defined at the parent level?

What is one concrete benefit of functional code that only uses immutable types?

Given the following expression:Paths.get("src/resources/application.properties")

What code would you write, using Java 10's new local variable type inference, to use a local variable and assign it the result of the above expression?

1 2 3 4 5