Section 1: Declarations and Access Control
|
|
|
|
Write code that declares, constructs and initializes arrays of any base type using any of the permitted forms both for declaration and for initialization.
Declare classes, nested classes, methods, instance variables, static variables and automatic (method local) variables making appropriate use of all permitted modifiers (such as public, final, static, abstract, etc.). State the significance of each of these modifiers both singly and in combination and state the effect of package relationships on declared items qualified by these modifiers.
For a given class, determine if a default constructor will be created and if so state the prototype of that constructor.
Identify legal return types for any method given the declarations of all related methods in this or parent classes. |
|
Section 2: Flow control, Assertions, and Exception Handling
|
|
|
|
Write code using if and switch statements and identify legal argument types for these statements.
Write code using all forms of loops including labeled and unlabeled, use of break and continue, and state the values taken by loop counter variables during and after loop execution.
Write code that makes proper use of exceptions and exception handling clauses (try, catch, finally) and declares methods and overriding methods that throw exceptions.
Recognize the effect of an exception arising at a specified point in a code fragment. Note: The exception may be a runtime exception, a checked exception, or an error (the code may include try, catch, or finally clauses in any legitimate combination).
Write code that makes proper use of assertions, and distinguish appropriate from inappropriate uses of assertions.
Identify correct statements about the assertion mechanism. |
|
Section 3: Garbage Collection
|
|
|
|
State the behavior that is guaranteed by the garbage collection system.
Write code that explicitly makes objects eligible for garbage collection.
Recognize the point in a piece of source code at which an object becomes eligible for garbage collection. |
|
Section 4: Language Fundamentals
|
|
|
|
Identify correctly constructed package declarations, import statements, class declarations (of all forms including inner classes) interface declarations, method declarations (including the main method that is used to start execution of a class), variable declarations, and identifiers.
Identify classes that correctly implement an interface where that interface is either java.lang.Runnable or a fully specified interface in the question.
State the correspondence between index values in the argument array passed to a main method and command line arguments.
Identify all Java programming language keywords. Note: There will not be any questions regarding esoteric distinctions between keywords and manifest constants.
State the effect of using a variable or array element of any kind when no explicit assignment has been made to it.
State the range of all primitive formats, data types and declare literal values for String and all primitive types using all permitted formats bases and representations. |
|
Section 5: Operators and Assignments
|
|
|
|
Determine the result of applying any operator (including assignment operators and instance of) to operands of any type class scope or accessibility or any combination of these.
Determine the result of applying the boolean equals (Object) method to objects of any combination of the classes java.lang.String, java.lang.Boolean and java.lang.Object.
In an expression involving the operators &, |, &&, || and variables of known values state which operands are evaluated and the value of the expression.
Determine the effect upon objects and primitive values of passing variables into methods and performing assignments or other modifying operations in that method. |
|
Section 6: Overloading, Overriding, Runtime Type and Object Orientation
|
|
|
|
State the benefits of encapsulation in object oriented design and write code that implements tightly encapsulated classes and the relationships "is a" and "has a".
Write code to invoke overridden or overloaded methods and parental or overloaded constructors; and describe the effect of invoking these methods.
Write code to construct instances of any concrete class including normal top level classes and nested classes. |
|
Section 7: Threads
|
|
|
|
Write code to define, instantiate and start new threads using both java.lang.Thread and java.lang.Runnable.
Recognize conditions that might prevent a thread from executing.
Write code using synchronized wait, notify and notifyAll to protect against concurrent access problems and to communicate between threads.
Define the interaction among threads and object locks when executing synchronized wait, notify or notifyAll. |
|
Section 8: Fundamental Classes in the java.lang Package
|
|
|
|
Write code using the following methods of the java.lang.Math class: abs, ceil, floor, max, min, random, round, sin, cos, tan, sqrt.
Describe the significance of the immutability of String objects.
Describe the significance of wrapper classes, including making appropriate selections in the wrapper classes to suit specified behavior requirements, stating the result of executing a fragment of code that includes an instance of one of the wrapper classes, and writing code using the following methods of the wrapper classes (e.g., Integer, Double, etc.):
o doubleValue
o floatValue
o intValue
o longValue
o parseXxx
o getXxx
o toString
o toHexString |
|
Section 9: The Collections Framework
|
|
|
|
Make appropriate selection of collection classes/interfaces to suit specified behavior requirements.
Distinguish between correct and incorrect implementations of hashcode methods. |
Section 1: The Servlet Technology Model
|
|
|
|
For each of the HTTP Methods (such as GET, POST, HEAD, and so on) describe the purpose of the method and the technical characteristics of the HTTP Method protocol, list triggers that might cause a Client (usually a Web browser) to use the method; and identify the HttpServlet method that corresponds to the HTTP Method.
Using the HttpServletRequest interface, write code to retrieve HTML form parameters from the request, retrieve HTTP request header information, or retrieve cookies from the request.
Using the HttpServletResponse interface, write code to set an HTTP response header, set the content type of the response, acquire a text stream for the response, acquire a binary stream for the response, redirect an HTTP request to another URL, or add cookies to the response.
Describe the purpose and event sequence of the servlet life cycle: (1) servlet class loading, (2) servlet instantiation, (3) call the init method, (4) call the service method, and (5) call destroy method. |
|
Section 2: The Structure and Deployment of Web Applications
|
|
|
|
Construct the file and directory structure of a Web Application that may contain (a) static content, (b) JSP pages, (c) servlet classes, (d) the deployment descriptor, (e) tag libraries, (d) JAR files, and (e) Java class files; and describe how to protect resource files from HTTP access.
Describe the purpose and semantics for each of the following deployment descriptor elements: error-page, init-param, mime-mapping, servlet, servlet-class, servlet-mapping, servlet-name, and welcome-file.
Construct the correct structure for each of the following deployment descriptor elements: error-page, init-param, mime-mapping, servlet, servlet-class, servlet-mapping, servlet-name, and welcome-file.
Explain the purpose of a WAR file and describe the contents of a WAR file, how one may be constructed. |
|
Section 3: The Web Container Model
|
|
|
|
For the ServletContext initialization parameters: write servlet code to access initialization parameters; and create the deployment descriptor elements for declaring initialization parameters.
For the fundamental servlet attribute scopes (request, session, and context): write servlet code to add, retrieve, and remove attributes; given a usage scenario, identify the proper scope for an attribute; and identify multi-threading issues associated with each scope.
Describe the Web container request processing model; write and configure a filter; create a request or response wrapper; and given a design problem, describe how to apply a filter or a wrapper.
Describe the Web container life cycle event model for requests, sessions, and web applications;create and configure listener classes for each scope life cycle; create and configure scope attribute listener classes; and given a scenario, identify the proper attribute listener to use.
Describe the RequestDispatcher mechanism; write servlet code to create a request dispatcher; write servlet code to forward or include the target resource; and identify and describe the additional request-scoped attributes provided by the container to the target resource. |
|
Section 4: Session Management
|
|
|
|
Write servlet code to store objects into a session object and retrieve objects from a session object.
Given a scenario describe the APIs used to access the session object, explain when the session object was created, and describe the mechanisms used to destroy the session object, and when it was destroyed.
Using session listeners, write code to respond to an event when an object is added to a session, and write code to respond to an event when a session object migrates from one VM to another.
Given a scenario, describe which session management mechanism the Web container could employ, how cookies might be used to manage sessions, how URL rewriting might be used to manage sessions, and write servlet code to perform URL rewriting. |
|
Section 5: Web Application Security
|
|
|
|
Based on the servlet specification, compare and contrast the following security mechanisms: (a) authentication, (b) authorization, (c) data integrity, and (d) confidentiality.
In the deployment descriptor, declare a security constraint, a Web resource, the transport guarantee, the login configuration, and a security role.
Compare and contrast the authentication types (BASIC, DIGEST, FORM, and CLIENT-CERT); describe how the type works; and given a scenario, select an appropriate type. |
|
Section 6: The JavaServer Pages (JSP) Technology Model
|
|
|
|
Identify, describe, or write the JSP code for the following elements: (a) template text, (b) scripting elements (comments, directives, declarations, scriptlets, and expressions), (c) standard and custom actions, and (d) expression language elements.
Write JSP code that uses the directives: (a) 'page' (with attributes 'import', 'session', 'contentType', and 'isELIgnored'), (b) 'include', and (c) 'taglib'.
Write a JSP Document (XML-based document) that uses the correct syntax.
Describe the purpose and event sequence of the JSP page life cycle: (1) JSP page translation, (2) JSP page compilation, (3) load class, (4) create instance, (5) call the jspInit method, (6) call the _jspService method, and (7) call the jspDestroy method.
Given a design goal, write JSP code using the appropriate implicit objects: (a) request, (b) response, (c) out, (d) session, (e) config, (f) application, (g) page, (h) pageContext, and (i) exception.
Configure the deployment descriptor to declare one or more tag libraries, deactivate the evaluation language, and deactivate the scripting language. 6.7Given a specific design goal for including a JSP segment in another page, write the JSP code that uses the most appropriate inclusion mechanism (the include directive or the jsp:include standard action). |
|
Section 7: Building JSP Pages Using the Expression Language (EL)
|
|
|
|
Given a scenario, write EL code that accesses the following implicit variables including pageScope, requestScope, sessionScope, and applicationScope, param and paramValues, header and headerValues, cookie, initParam and pageContext.
Given a scenario, write EL code that uses the following operators: property access (the . operator), collection access (the [] operator).
Given a scenario, write EL code that uses the following operators: aritmetic operators, relational operators, and logical operators.
Given a scenario, write EL code that uses a function; write code for an EL function; and configure the EL function in a tag library descriptor. |
|
Section 8: Building JSP Pages Using Standard Actions
|
|
|
|
Given a design goal, create a code snippet using the following standard actions: jsp:useBean (with attributes: 'id', 'scope', 'type', and 'class'), jsp:getProperty, and jsp:setProperty (with all attribute combinations).
Given a design goal, create a code snippet using the following standard actions: jsp:include, jsp:forward, and jsp:param. |
|
Section 9: Building JSP Pages Using Tag Libraries
|
|
|
|
For a custom tag library or a library of Tag Files, create the 'taglib' directive for a JSP page.
Given a design goal, create the custom tag structure in a JSP page to support that goal.
Given a design goal, use an appropriate JSP Standard Tag Library (JSTL v1.1) tag from the "core" tag library. |
|
Section 10: Building a Custom Tag Library
|
|
|
|
Describe the semantics of the "Classic" custom tag event model when each event method (doStartTag, doAfterBody, and doEndTag) is executed, and explain what the return value for each event method means; and write a tag handler class.
Using the PageContext API, write tag handler code to access the JSP implicit variables and access web application attributes.
Given a scenario, write tag handler code to access the parent tag and an arbitrary tag ancestor.
Describe the semantics of the "Simple" custom tag event model when the event method (doTag) is executed; write a tag handler class; and explain the constraints on the JSP content within the tag.
Describe the semantics of the Tag File model; describe the web application structure for tag files; write a tag file; and explain the constraints on the JSP content in the body of the tag. |
|
Section 11: J2EE Patterns
|
|
|
|
Given a scenario description with a list of issues, select a pattern that would solve the issues. The list of patterns you must know are: Intercepting Filter, Model-View-Controller, Front Controller, Service Locator, Business Delegate, and Transfer Object.
Match design patterns with statements describing potential benefits that accrue from the use of the pattern, for any of the following patterns: Intercepting Filter, Model-View-Controller, Front Controller, Service Locator, Business Delegate, and Transfer Object. |
EJB Overview
|
|
|
|
Identify the use, benefits, and characteristics of Enterprise JavaBeans technology, for version 2.0 of the EJB specification.
Identify EJB 2.0 container requirements.
Identify correct and incorrect statements or examples about EJB programming restrictions.
Match EJB roles with the corresponding description of the role's responsibilities, where the description may include deployment descriptor information.
Given a list, identify which are requirements for an EJB-jar file. |
|
Client View of a Session Bean
|
|
|
|
Identify correct and incorrect statements or examples about the client view of a session bean's local and remote home interfaces, including the code used by a client to locate a session bean's home interface.
Identify correct and incorrect statements or examples about the client view of a session bean's local and remote component interfaces. |
|
Session Bean Component Contract
|
|
|
|
Identify correct and incorrect statements or examples about session beans, including conversational state, the SessionBean interface, and create methods.
Identify the use of, and the behavior of, the ejbPassivate method in a session bean, including the responsibilities of both the container and the bean provider.
Identify the interface and method for each of the following: Retrieve the session bean's remote home interface, Retrieve the session bean's local component interface, Determine if the session bean's caller has a particular role, Allow the instance to mark the current transaction as a roleback, Retrieve the UserTransaction interface, Prepare the instance for re-use following passivation, Release resources prior to removal, Identify the invoker of the bean instance's component interface, Be notified that a new transaction has begun, be notified that the current transaction has completed.
Match correct descriptions about purpose and function with which session bean type they apply t stateless, stateful, or both.
Given a list of responsibilities related to session beans, identify those which are the responsibility of the session bean provider, and those which are the responsibility of the EJB container provider.
Given a list of requirements, identify those which are the requirements for a session bean class, remote component interface, remote home interface, create methods, business methods, local component interface, local home interface. |
|
Session Bean Lifecycle
|
|
|
|
Identify correct and incorrect statements or examples about the lifecycle of a stateful or stateless session bean instance.
Given a list of methods of a stateful or stateless session bean class, define which of the following operations can be performed from each of those methods: SessionContext interface methods, UserTransaction methods, JNDI access to java:comp/env environment naming context, resource manager access and other enterprise bean access.
Given a list of scenarios, identify which will result in an ejbRemove method not being being called on a bean instance. |
|
Client view of an Entity
|
|
|
|
Identify correct and incorrect statements or examples about the client of an entity bean's local and remote home interface, including view the code used to locate an entity bean's home interface, and the home interface methods provided to the client.
Identify correct and incorrect statements or examples about the client view of an entity bean's local component interface (EJBLocalObject).
Identify correct and incorrect statements or examples about the client view of a entity bean's remote component interface (EJBObject).
Identify the use, syntax, and behavior of, the following entity bean home method types, for CMP: finder methods, create methods, remove methods, and home methods. |
|
Component Contract for Container-Managed Persistence (CMP)
|
|
|
|
Identify correct and incorrect statements or examples about the entity bean provider's view and programming contract for CMP, including the requirements for a CMP entity bean.
Identify correct and incorrect statements or examples about persistent relationships, remove protocols, and about the abstract schema type, of a CMP entity bean.
Identify correct and incorrect statements or examples about the rules and semantics for relationship assignment, and relationship updating, in a CMP bean.
Match the name with a description of purpose or functionality, for each of the following deployment descriptor elements: ejb-name, abstract-schema-name, ejb-relation, ejb-relationship-role, cmr-field, cmr-field-type, and relationship-role-source.
Identify correctly-implemented deployment descriptor elements for a CMP bean (including container-managed relationships).
Identify the interface(s) and methods a CMP entity bean must and must not implement. |
|
CMP Entity Bean Lifecycle
|
|
|
|
Identify correct and incorrect statements or examples about the lifecycle of a CMP entity bean.
From a list, identify the purpose, behavior, and responsibilities of the bean provider for a CMP entity bean, including but not limited t setEntityContext, unsetEntityContext, ejbCreate, ejbPostCreate, ejbActivate, ejbPassivat, ejbRemove, ejbLoad, ejbStore, ejbFind, ejbHome, and ejbSelect.
From a list, identify the responsibility of the container for a CMP entity bean, including but not limited t setEntityContext, unsetEntityContext, ejbCreate, ejbPostCreate, ejbActivate, ejbPassivate, ejbRemove, ejbLoad, ejbStore, ejbFind, ejbHome, and ejbSelect. |
|
Entity Beans
|
|
|
|
From a list of behaviors, match them with the appropriate EntityContext method responsible for that behavior.
Identify correct and incorrect statements or examples about an entity bean's primary key and object identity. |
|
EJB-QL
|
|
|
|
Identify correct and incorrect syntax for an EJB QL query including the SELECT, FROM, and WHERE clause.
Identify correct and incorrect statements or examples about the purpose and use of EJB QL.
Identify correct and incorrect conditional expressions, between expression, in expressions, like expressions, and comparison expressions. |
|
Message-Driven Bean Component Contract
|
|
|
|
Identify correct and incorrect statements or examples about the client view of a message-driven bean, and the lifecycle of a message-driven bean.
Identify the interface(s) and methods a JMS Messaged-Driven bean must implement.
Identify the use and behavior of the MessageDrivenContext interface methods.
From a list, identify the responsibility of the bean provider, and the responsibility of the container provider for a message-driven bean. |
|
Transactions
|
|
|
|
Identify correct and incorrect statements or examples about EJB transactions, including bean-managed transaction demarcation, and container-managed transaction demarcation.
Identify correct and incorrect statements about the Application Assembler's responsibilities, including the use of deployment descriptor elements related to transactions, and the identification of the methods of a particular bean type for which a transaction attribute must be specified.
Given a list of transaction behaviors, match them with the appropriate transaction attribute.
Given a list of responsibilities, identify whose which are the container's with respect to transactions, including the handling of getRollbackOnly, setRollbackOnly, getUserTransaction, SessionSynchronzation callbacks, for both container and bean-managed transactions. |
|
Exceptions
|
|
|
|
Identify correct and incorrect statements or examples about exception handling in EJB.
Given a list of responsibilities related to exceptions, identify those which are the bean provider's, and those which are the responsibility of the container provider. Be prepared to recognize responsibilities for which neither the bean or container provider are responsible.
Identify correct and incorrect statements or examples about application exceptions and system exceptions in entity beans, session beans, and message-driven beans.
Given a particular method condition, identify the following: whether an exception will be thrown, the type of exception thrown, the container's action, and the client's view.
Identify correct and incorrect statements or examples about the client's view of exceptions received from an enterprise bean invocation. |
|
Enterprise Bean Environment
|
|
|
|
Identify correct and incorrect statements or examples about an enterprise bean's environment JNDI naming.
Identify correct and incorrect statements about the purpose and/or use of the deployment descriptor elements for environment entrys, ejb references, and resource manager connection factory references, including whether a given code listing is appropriate and correct with respect to a particular deployment descriptor element.
Given a list of responsibilities, identify which belong to the deployer, bean provider, application assembler, container provider, system administrator, or any combination. |
|
Security Management
|
|
|
|
Identify correct and incorrect statements about the EJB support for security management including security roles, security role references, and method permissions.
From a list of responsibilities, identify which belong to the application assembler, bean provider, deployer, container provider, or system administrator.
Given a code listing, determine whether it is a legal and/or appropriate way to programmatically access a caller's security context.
Given a security-related deployment descriptor tag, identify correct and incorrect statements and/or code related to that tag. |
Section 1: Concepts
|
|
|
|
Draw UML Diagrams
Interpret UML diagrams.
State the effect of encapsulation, inheritance, and use of interfaces on architectural characteristics. |
|
Section 2: Common Architectures
|
|
|
|
Recognize the effect on each of the following characteristics of two tier, three tier and multi-tier architectures: scalability maintainability, reliability, availability, extensibility, performance, manageability, and security.
Recognize the effect of each of the following characteristics on J2EE technology: scalability maintainability, reliability, availability, extensibility, performance, manageability, and security.
Given an architecture described in terms of network layout, list benefits and potential weaknesses associated with it. |
|
Section 3: Legacy Connectivity
|
|
|
|
Distinguish appropriate from inappropriate techniques for providing access to a legacy system from Java code given an outline description of that legacy system |
|
Section 4: Enterprise JavaBeans Technology
|
|
|
|
List the required classes/interfaces that must be provided for an EJB technology.
Distinguish stateful and stateless Session beans.
Distinguish Session and Entity beans.
Recognize appropriate uses for Entity, Stateful Session, and Stateless Session beans.
State benefits and costs of Container Managed Persistence.
State the transactional behavior in a given scenario for an enterprise bean method with a specified transactional deployment descriptor.
Given a requirement specification detailing security and flexibility needs, identify architectures that would fulfill those requirements.
Identify costs and benefits of using an intermediate data-access object between an entity bean and the data resource. |
|
Section 5: Enterprise JavaBeans Container Model
|
|
|
|
State the benefits of bean pooling in an EJB container.
State the benefits of Passivation in an EJB container.
State the benefit of monitoring of resources in an EJB container.
Explain how the EJB container does lifecycle management and has the capability to increase scalability. |
|
Section 6: Protocols
|
|
|
|
Given a scenario description, distinguish appropriate from inappropriate protocols to implement that scenario.
Identify a protocol, given a list of some of its features, where the protocol is one of the following: HTTP, HTTPS, IIOP, JRMP.
Select from a list, common firewall features that might interfere with the normal operation of a given protocol. |
|
Section 7: Applicability of J2EE Technology
|
|
|
|
Select from a list those application aspects that are suited to implementation using J2EE.
Select from a list those application aspects that are suited to implementation using EJB.
Identify suitable J2EE technologies for the implementation of specified application aspects. |
|
Section 8: Design Patterns
|
|
|
|
From a list, select the most appropriate design pattern for a given scenario. Patterns will be limited to those documented in Gamma et al. and named using the names given in that book.
State the benefits of using design patterns.
State the name of a design pattern (for example, Gamma) given the UML diagram and/or a brief description of the pattern's functionality.
Select from a list benefits of a specified design pattern (for example, Gamma).
Identify the design pattern associated with a specified J2EE feature |
|
Section 9: Messaging
|
|
|
|
Identify scenarios that are appropriate to implementation using messaging, EJB, or both.
List benefits of synchronous and asynchronous messaging.
Select scenarios from a list that are appropriate to implementation using synchronous and asynchronous messaging. |
|
Section 10: Internationalization
|
|
|
|
State three aspects of any application that might need to be varied or customized in different deployment locales.
Match the following features of the Java 2 platform with descriptions of their functionality, purpose or typical uses: Properties, Locale, ResourceBundle, Unicode, java.text package, InputStreamReader and OutputStreamWriter. |
|
Section 11: Security
|
|
|
|
Select from a list security restrictions that Java 2 environments normally impose on applets running in a browser.
Given an architectural system specification, identify appropriate locations for implementation of specified security features, and select suitable technologies for implementation of those features. |
Section 1: Concepts
|
|
|
|
Draw UML Diagrams
Interpret UML diagrams.
State the effect of encapsulation, inheritance, and use of interfaces on architectural characteristics. |
|
Section 2: Common Architectures
|
|
|
|
Recognize the effect on each of the following characteristics of two tier, three tier and multi-tier architectures: scalability maintainability, reliability, availability, extensibility, performance, manageability, and security.
Recognize the effect of each of the following characteristics on J2EE technology: scalability maintainability, reliability, availability, extensibility, performance, manageability, and security.
Given an architecture described in terms of network layout, list benefits and potential weaknesses associated with it. |
|
Section 3: Legacy Connectivity
|
|
|
|
Distinguish appropriate from inappropriate techniques for providing access to a legacy system from Java code given an outline description of that legacy system |
|
Section 4: Enterprise JavaBeans (EJB)
|
|
|
|
List the required classes/interfaces that must be provided for an EJB.
Distinguish stateful and stateless Session beans.
Distinguish Session and Entity beans.
Recognize appropriate uses for Entity, Stateful Session, and Stateless Session beans.
State benefits and costs of Container Managed Persistence.
State the transactional behavior in a given scenario for an enterprise bean method with a specified transactional deployment descriptor.
Given a requirement specification detailing security and flexibility needs, identify architectures that would fulfill those requirements.
Identify costs and benefits of using an intermediate data-access object between an entity bean and the data resource. |
|
Section 5: Enterprise JavaBeans Container Model
|
|
|
|
State the benefits of bean pooling in an EJB container.
State the benefits of Passivation in an EJB container.
State the benefit of monitoring of resources in an EJB container.
Explain how the EJB container does lifecycle management and has the capability to increase scalability. |
|
Section 6: Protocols
|
|
|
|
Given a scenario description, distinguish appropriate from inappropriate protocols to implement that scenario.
Identify a protocol, given a list of some of its features, where the protocol is one of the following: HTTP, HTTPS, IIOP, JRMP.
Select from a list, common firewall features that might interfere with the normal operation of a given protocol. |
|
Section 7: Applicability of J2EE Technology
|
|
|
|
Select from a list those application aspects that are suited to implementation using J2EE.
Select from a list those application aspects that are suited to implementation using EJB.
Identify suitable J2EE technologies for the implementation of specified application aspects. |
|
Section 8: Design Patterns
|
|
|
|
From a list, select the most appropriate design pattern for a given scenario. Patterns will be limited to those documented in Gamma et al. and named using the names given in that book.
State the benefits of using design patterns.
State the name of a Gamma et al. design pattern given the UML diagram and/or a brief description of the pattern's functionality.
Select from a list benefits of a specified design pattern (for example, Gamma).
Identify the design pattern associated with a specified J2EE feature |
|
Section 9: Messaging
|
|
|
|
Identify scenarios that are appropriate to implementation using messaging, EJB, or both.
List benefits of synchronous and asynchronous messaging.
Select scenarios from a list that are appropriate to implementation using synchronous and asynchronous messaging. |
|
Section 10: Internationalization
|
|
|
|
State three aspects of any application that might need to be varied or customized in different deployment locales.
Match the following features of the Java 2 platform with descriptions of their functionality, purpose or typical uses: Properties, Locale, ResourceBundle, Unicode, java.text package, InputStreamReader and OutputStreamWriter. |
|
Section 11: Security
|
|
|
|
Select from a list security restrictions that Java 2 environments normally impose on applets running in a browser.
Given an architectural system specification, identify appropriate locations for implementation of specified security features, and select suitable technologies for implementation of those features. |
好的,本人正在学java.需要基本资料.