java design patterns_在线真题试卷与模拟练习_java design patterns

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

有效期：个月

章节介绍：共有个章节

我的练习

我的错题
(0道)

我的收藏
(0道)

我的斩题
(0道)

我的笔记
(0道)

专项练习

顺序练习 0 / 0

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

题型乱序 按导入顺序练习

模拟考试 仿真模拟

题型练习 按题型分类练习

易错题 精选高频易错题

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

搜索

题库预览

You are building the server-side of a stock trading application. The BUY and SELL orders are represented, and executed, using the Command Pattern. The system is dealing with brokers, which provide the system with orders (input). The system then sends these orders for execution to a multitude of stock exchanges (output). Considering strictly the details mentioned above, which of the following design patterns should you use, in conjunction with the Command Pattern, to improve this system?

n both the Proxy and the Adapter pattern, an object is being wrapped by a different object: the proxy or the adapter. What is the main difference between the Proxy pattern and the Adapter pattern?

The following code contains a common programming error when using the Chain of Responsibility pattern. What would you do to fix the bug?1 Processor fooHandler = new FooProcessor(); 2 Processor barHandler = new BarProcessor(); 3 Processor fooBarHandler = new FoobarProcessor(); 4 5 fooHandler.setNext(barHandler); 6 barHandler.setNext(fooBarHandler); 7 fooBarHandler.setNext(fooHandler);

You have a String which represents authentication credentials. The String could be a Base64 encoded username and password, an OAuth Token, or an API Token. Since you're not sure what credentials are represented by a given String, you need to try the String against each authentication scheme until one is successful. What design pattern could you use to solve this?

Incorrect -

Facade Patterns are typically created utilizing what design consideration?

Your choice: correct -

You've encountered the following problematic code during a code reviewDataWriter writer = new EncryptedDataWriterProxy(new FileDataWriter()); writer.writeData("The quick brown fox jumped over the lazy dog");

What comments would you suggest to fix it?

n the Composite pattern, all concrete classes declare an IS-A relationship to the interface. This feature, although not necessarily a problem in the context of this pattern, goes AGAINST which general design principle?

How would you classify the Template Method pattern?

How would you classify the Proxy pattern?

What is a key difference between the Singleton and Factory pattern?

The following class adapts the data type UsbTypeA to the interface UsbTypeC. How would you finish the implementation?public class UsbAdapterTypeC ________ UsbTypeC { public UsbAdapterTypeC( ________ usb) { // assume this is implemented } public void transferData() { // assume this is implemented } }

In which scenario would you use a Singleton?

What is one of the main reasons for choosing to implement a Builder?

In which of the following situations would it be appropriate to use the Facade design pattern?

What is a common pitfall when using the singleton pattern?

What would you need to change in order to make the below code a guaranteed Singleton?private static volatile DbSingleton instance = null; public DbSingleton() { } public static DbSingleton getInstance() { if (instance == null) { synchronized (DbSingleton.class) { if (instance == null) { instance = new DbSingleton(); } } } return instance; }

You are working on a document management system. One of the pages in your application has a performance problem, because each time a user opens that page, the system has to load a set of large documents. You want to implement a lazy loading mechanism, so that each document is loaded only when it's needed. What design pattern would be appropriate for this?

Consider the following stacktrace that makes use of the Proxy pattern:com.my.company.exception.PullEmployeeDataException: Error getting employee data at com.my.company.web.controller.admin.EmployeeController$$FastClassBySpringCGLIB$$15b35cb5.invoke() at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204) at org.springframework.aop.framework.CglibAopProxy$glibAopProxy.java:721)

What is the most likely explanation for finding this stacktrace difficult to debug?

n a Template Method pattern, what would you use to redefine steps of an algorithm without changing the algorithm structure?

What is a possible negative outcome when using the Chain of Responsibility pattern?

1 2 3 4 5 6