Java Certification Roadmap

Hand-picked collection of Java certification resources

Every master was once a beginner. Every professional started as an amateur. Every icon began as an unknown. So dream big and start now.
- Robin Sharma
Oracle Java Certification Roadmap
FAQ Oracle Java Certifications

Oracle Certified Java SE 8 Programmer I (1Z0-808)

Exam Number : 1Z0-808
Associated Certifications: Oracle Certified Associate, Java SE 8 Programmer , Oracle Certified Java Programmer, Silver SE 8 - Available only in Japan (Oracle Certified Associate, Java SE 8 Programmer)
Exam Product Version: Java SE
Exam Price: $150 (approximate)
Duration: 150 minutes
Number of Questions: 77
Passing Score: 65%
format: Multiple Choice
Exam Topics

Assume the following:

  • Missing package and import statements: If sample code do not include package or import statements, and the question does not explicitly refer to these missing statements, then assume that all sample code is in the same package, and import statements exist to support them.
  • No file or directory path names for classes: If a question does not state the file names or directory locations of classes, then assume one of the following, whichever will enable the code to compile and run:
  • All classes are in one file
  • Each class is contained in a separate file, and all files are in one directory
  • Unintended line breaks: Sample code might have unintended line breaks. If you see a line of code that looks like it has wrapped, and this creates a situation where the wrapping is significant (for example, a quoted String literal has wrapped), assume that the wrapping is an extension of the same line, and the line does not contain a hard carriage return that would cause a compilation failure.
  • Code fragments: A code fragment is a small section of source code that is presented without its context. Assume that all necessary supporting code exists is present and that the supporting environment fully supports the correct compilation and execution of the code shown and its omitted environment.
  • Descriptive comments: Take descriptive comments, such as "setter and getters go here," at face value. Assume that correct code exists, compiles, and runs successfully to create the described effect.

TOPICS
 
Java Basics
 
  • Define the scope of variables
  • Define the structure of a Java class
  • Create executable Java applications with a main method; run a Java program from the command line; including console output.
  • Import other Java packages to make them accessible in your code Compare and contrast the features and components of Java such as: platform independence, object orientation, encapsulation, etc.
Working With Java Data Types
 
  • Declare and initialize variables (including casting of primitive data types)
  • Differentiate between object reference variables and primitive variables
  • Know how to read or write to object fields
  • Explain an Object's Lifecycle (creation, "dereference by reassignment" and garbage collection)
  • Develop code that uses wrapper classes such as Boolean, Double, and Integer.
Using Operators and Decision Constructs
 
  • Use Java operators; including parentheses to override operator precedence
  • Test equality between Strings and other objects using == and equals ()
  • Create if and if/else and ternary constructs
  • Use a switch statement
Creating and Using Arrays
 
  • Declare, instantiate, initialize and use a one-dimensional array
  • Declare, instantiate, initialize and use multi-dimensional array
Using Loop Constructs
 
  • Create and use while loops
  • Create and use for loops including the enhanced for loop
  • Create and use do/while loops
  • Compare loop constructs
  • Use break and continue
Working with Methods and Encapsulation
 
  • Create methods with arguments and return values; including overloaded methods
  • Apply the static keyword to methods and fields
  • Create and overload constructors; including impact on default constructors
  • Apply access modifiers
  • Apply encapsulation principles to a class
  • Determine the effect upon object references and primitive values when they are passed into methods that change the values
Working with Inheritance
 
  • Describe inheritance and its benefits
  • Develop code that demonstrates the use of polymorphism; including overriding and object type versus reference type
  • Determine when casting is necessary
  • Use super and this to access objects and constructors
  • Use abstract classes and interfaces
Handling Exceptions
 
  • Differentiate among checked exceptions, unchecked exceptions, and Errors
  • Create a try-catch block and determine how exceptions alter normal program flow
  • Describe the advantages of Exception handling
  • Create and invoke a method that throws an exception
  • "Recognize common exception classes (such as NullPointerException, ArithmeticExcpetion, ArrayIndexOutOfBoundsException, ClassCastException)"
Working with Selected classes from the Java API
 
  • Manipulate data using the StringBuilder class and its methods
  • Creating and manipulating Strings
  • Create and manipulate calendar data using classes from java.time.LocalDateTime, java.time.LocalDate, java.time.LocalTime, java.time.format.DateTimeFormatter, java.time.Period
  • Declare and use an ArrayList of a given type
  • Write a simple Lambda expression that consumes a Lambda Predicate expression
Recommended Books
 

JCR: Oracle Certification Roadmap OCA: JCR - Oracle Certification Roadmap ebook
 
Author : Raul Rios
 
Get Your Java Certification the Smart Way. The Java Certification Roadmap book is the ultimate and most time-saving guide to help you get your valuable Oracle Java SE 8 Programmer certification + FREE BONUS! The perfect complement to get an even better certification preparation.
 

 

OCA: Oracle Certified Associate Java SE 8 Programmer I Study Guide: Exam 1Z0-808 1st Edition OCA: Oracle Certified Associate Java SE 8 Programmer I Study Guide: Exam 1Z0-808 1st Edition
 
Authors : Jeanne Boyarsky and Scott Selikoff
 
Full coverage of functional programming and all OCA Java Programmer exam objectives. OCA, Oracle Certified Associate Java SE 8 Programmer I Study Guide, Exam 1Z1–808 is a comprehensive study guide for those taking the Oracle Certified Associate Java SE 8 Programmer I exam (1Z1–808). With complete coverage of 100% of the exam objectives, this book provides everything you need to know to confidently take the exam. The release of Java 8 brought the language′s biggest changes to date, and for the first time, candidates are required to learn functional programming to pass the exam. This study guide has you covered, with thorough functional programming explanation and information on all key topic areas Java programmers need to know. You′ll cover Java inside and out, and learn how to apply it efficiently and effectively to create solutions applicable to real–world scenarios. Work confidently with operators, conditionals, and loops Understand object-oriented design principles and patterns Master functional programming fundamentals.

OCA Java SE 8 Programmer Study Guide (Exam 1Z0-808) OCA Java SE 8 Programmer Study Guide (Exam 1Z0-808)
 
Author : Budi Kurniawan
 
This book is designed for people who want to pass the Oracle Certified Associate, Java SE 8 Programmer exam (Exam 1Z0-808). It includes an extensive Java refresher written as a tutorial and two full mock exams. The Java refresher includes all the materials and exam objectives you need to master to pass the exam. It explains the concepts very clearly and in detail and provides examples that are easy to follow even to those with no programming experience. Each of the ten chapters in the Java refresher comes with ten questions to test your knowledge on the subjects discussed in the chapter. These questions are similar to what you would expect in a real exam and the answers and explanations to the questions follow.

OCAJP Oracle Certified Associate Java SE 8 Programmer Practice Exams Kindle Edition OCAJP Oracle Certified Associate Java SE 8 Programmer Practice Exams Kindle Edition
 
Author : Mitchell Glenn
 
OCAJP Oracle Certified Associate Java SE 8 Programmer Practice Exams contains more than 600 realistic practice questions to prepare you for this certification exam. Each question contains detailed explanation so that you can understand the concepts involved in the question. Questions are organized as 7 Standard Tests and also as Objective wise sets for easy navigability.


 

OCA Java SE 8 Programmer I Study Guide (Exam 1Z0-808) (Oracle Press) 3rd Edition OCA Java SE 8 Programmer I Study Guide (Exam 1Z0-808) (Oracle Press) 3rd Edition
 
Authors : Edward Finegan and Robert Liguori
 
The official study guide for the entry-level Oracle Certified Associate exam for Java Programmers―fully updated for Java SE 8. Confidently prepare for the OCA Java SE 8 Programmer I exam with this thoroughly revised, up-to-date guide from Oracle Press. Featuring step-by-step exercises, comprehensive chapter self-tests, and a CD-ROM containing two complete practice exams, this volume provides an integrated, easy-to-follow study system based on a proven methodology. OCA Java SE 8 Programmer I Study Guide (Exam 1Z0-808) offers the most complete and in-depth coverage of all of the exam objectives, and also serves as an essential on-the-job reference for Java developers. You’ll have access to a total of more than 250 challenging practice questions that precisely mirror the content of the live exam―no other guide on the market provides the same level of accuracy and detail.


 

A Programmer's Guide to Java SE 8 Oracle Certified Associate (OCA) 1st Edition A Programmer's Guide to Java SE 8 Oracle Certified Associate (OCA) 1st Edition
 
Authors : Khalid A Mughal and Rolf W Rasmussen
 
Unique among Java tutorials, A Programmer’s Guide to Java® SE 8 Oracle Certified Associate (OCA): A Comprehensive Primer combines an integrated, expert introduction to Java SE 8 with comprehensive coverage of Oracle’s new Java SE 8 OCA exam 1Z0-808. Based on Mughal and Rasmussen’s highly regarded guide to the original SCJP Certification, this streamlined volume has been thoroughly revised to reflect major changes in the new Java SE 8 OCA exam. It features an increased focus on analyzing code scenarios and not just individual language constructs, and each exam objective is thoroughly addressed, reflecting the latest Java SE 8 features, API classes, and best practices for effective programming.

A Programmer's Guide to Java SE 8 Oracle Certified Associate (OCA) 1st Edition A Programmer's Guide to Java SE 8 Oracle Certified Associate (OCA) 1st Edition
 
Author : Mala Gupta
 
To earn the OCA Java SE 8 Programmer I Certification, you have to know your Java inside and out, and to pass the exam you need to understand the test itself. This book cracks open the questions, exercises, and expectations you'll face on the OCA exam so you'll be ready and confident on test day. OCA Java SE 8 Programmer I Certification Guide prepares Java developers for the 1Z0-808 with thorough coverage of Java topics typically found on the exam. Each chapter starts with a list of exam objectives mapped to section numbers, followed by sample questions and exercises that reinforce key concepts. You'll learn techniques and concepts in multiple ways, including memorable analogies, diagrams, flowcharts, and lots of well-commented code. You'll also get the scoop on common exam mistakes and ways to avoid traps and pitfalls.

Oracle Certified Java SE 8 Programmer II (1Z0-809)

Step 1 - Prior Certification Requirements
Oracle Certified Associate, Java SE 8 Programmer

Step 2 - Pass Exam
Java SE 8 Programmer II 1Z0-809

Exam Number : 1Z0-809
Associated Certifications: Oracle Certified Professional, Java SE 8 Programmer , Oracle Certified Java Programmer, Gold SE 8 - Available only in Japan (Oracle Certified Professional, Java SE 8 Programmer)
Exam Product Version: Java SE
Exam Price: $150 (approximate)
Duration: 150 minutes
Number of Questions: 85
Passing Score 65%
format: Multiple Choice
Exam Topics

Assume the following:

  • Missing package and import statements: If sample code do not include package or import statements, and the question does not explicitly refer to these missing statements, then assume that all sample code is in the same package, and import statements exist to support them.
  • No file or directory path names for classes: If a question does not state the file names or directory locations of classes, then assume one of the following, whichever will enable the code to compile and run:
  • All classes are in one file
  • Each class is contained in a separate file, and all files are in one directory
  • Unintended line breaks: Sample code might have unintended line breaks. If you see a line of code that looks like it has wrapped, and this creates a situation where the wrapping is significant (for example, a quoted String literal has wrapped), assume that the wrapping is an extension of the same line, and the line does not contain a hard carriage return that would cause a compilation failure.
  • Code fragments: A code fragment is a small section of source code that is presented without its context. Assume that all necessary supporting code exists is present and that the supporting environment fully supports the correct compilation and execution of the code shown and its omitted environment.
  • Descriptive comments: Take descriptive comments, such as "setter and getters go here," at face value. Assume that correct code exists, compiles, and runs successfully to create the described effect.

TOPICS
 
Java Class Design
 
  • Implement encapsulation
  • Implement inheritance including visibility modifiers and composition
  • Implement polymorphism
  • Override hashCode, equals, and toString methods from Object class
  • Create and use singleton classes and immutable classes
  • Develop code that uses static keyword on initialize blocks, variables, methods, and classes
Advanced Java Class Design
 
  • Develop code that uses abstract classes and methods
  • Develop code that uses final keyword
  • Create inner classes including static inner class, local class, nested class, and anonymous inner class
  • Use enumerated types including methods, and constructors in an enum type
  • Develop code that declares, implements and/or extends interfaces and use the atOverride annotation. Create and use Lambda expressions
Generics and Collections
 
  • Create and use a generic class
  • Create and use ArrayList, TreeSet, TreeMap, and ArrayDeque objects
  • Use java.util.Comparator and java.lang.Comparable interfaces
  • Collections Streams and Filters
  • Iterate using forEach methods of Streams and List
  • Describe Stream interface and Stream pipeline
  • Filter a collection by using lambda expressions
  • Use method references with Streams
Lambda Built-in Functional Interfaces
 
  • Use the built-in interfaces included in the java.util.function package such as Predicate, Consumer, Function, and Supplier
  • Develop code that uses primitive versions of functional interfaces
  • Develop code that uses binary versions of functional interfaces
  • Develop code that uses the UnaryOperator interface
Java Stream API
 
  • Develop code to extract data from an object using peek() and map() methods including primitive versions of the map() method
  • Search for data by using search methods of the Stream classes including findFirst, findAny, anyMatch, allMatch, noneMatch
  • Develop code that uses the Optional class
  • Develop code that uses Stream data methods and calculation methods
  • Sort a collection using Stream API
  • Save results to a collection using the collect method and group/partition data using the Collectors class
  • Use flatMap() methods in the Stream API
Exceptions and Assertions
 
  • Use try-catch and throw statements
  • Use catch, multi-catch, and finally clauses
  • Use Autoclose resources with a try-with-resources statement
  • Create custom exceptions and Auto-closeable resources
  • Test invariants by using assertions
Use Java SE 8 Date/Time API
 
  • Create and manage date-based and time-based events including a combination of date and time into a single object using LocalDate, LocalTime, LocalDateTime, Instant, Period, and Duration
  • Work with dates and times across timezones and manage changes resulting from daylight savings including Format date and times values
  • Define and create and manage date-based and time-based events using Instant, Period, Duration, and TemporalUnit
Java I/O Fundamentals
 
  • Read and write data from the console
  • Use BufferedReader, BufferedWriter, File, FileReader, FileWriter, FileInputStream, FileOutputStream, ObjectOutputStream, ObjectInputStream, and PrintWriter in the java.iopackage.
Java File I/O (NIO.2)
 
  • Use Path interface to operate on file and directory paths
  • Use Files class to check, read, delete, copy, move, manage metadata of a file or directory Use Stream API with NIO.2
Java Concurrency
 
  • Create worker threads using Runnable, Callable and use an ExecutorService to concurrently execute tasks
  • Identify potential threading problems among deadlock, starvation, livelock, and race conditions
  • Use synchronized keyword and java.util.concurrent.atomic package to control the order of thread execution
  • Use java.util.concurrent collections and classes including CyclicBarrier and CopyOnWriteArrayList Use parallel Fork/Join Framework
  • Use parallel Streams including reduction, decomposition, merging processes, pipelines and performance.
Building Database Applications with JDBC
 
  • Describe the interfaces that make up the core of the JDBC API including the Driver, Connection, Statement, and ResultSet interfaces and their relationship to provider implementations
  • Identify the components required to connect to a database using the DriverManager class including the JDBC URL
  • Submit queries and read results from the database including creating statements, returning result sets, iterating through the results, and properly closing result sets, statements, and connections
Localization
 
  • Read and set the locale by using the Locale object
  • Create and read a Properties file
  • Build a resource bundle for each locale and load a resource bundle in an application
Recommended Books
 


                    OCP: Oracle Certified Professional Java SE 8 Programmer II Study Guide: Exam 1Z0-809 1st Edition OCP: Oracle Certified Professional Java SE 8 Programmer II Study Guide: Exam 1Z0-809 1st Edition
 
Authors : Jeanne Boyarsky and Scott Selikoff
 
Complete, trusted preparation for the Java Programmer II exam. OCP: Oracle Certified Professional Java SE 8 Programmer II Study Guide" is your comprehensive companion for preparing for Exam 1Z0-809 as well as upgrade Exam 1Z0-810 and Exam 1Z0-813. With full coverage of 100% of exam objectives, this invaluable guide reinforces what you know, teaches you what you don't know, and gives you the hands-on practice you need to boost your skills. Written by expert Java developers, this book goes beyond mere exam prep with the insight, explanations and perspectives that come from years of experience. You'll review the basics of object-oriented programming, understand functional programming, apply your knowledge to database work, and much more. From the basic to the advanced, this guide walks you through everything you need to know to confidently take the OCP 1Z0-809 Exam and upgrade exams 1Z0-810 and 1Z0-813.


 

Oracle Certified Professional Java SE 8 Programmer Exam 1Z0-809: A Comprehensive OCPJP 8 Certification Guide Oracle Certified Professional Java SE 8 Programmer Exam 1Z0-809: A Comprehensive OCPJP 8 Certification Guide 2nd ed. 2016 Edition
 
Authors : S.G. Ganesh and Hari Kiran Kumar and Tushar Sharma
 
This book is a comprehensive, step-by-step and one-stop guide for the Java SE 8 Programmer II exam (IZ0-809). Salient features of this book include: 100% coverage of the exam topics, a full-length mock exam, practice exam questions, exam notes and tips. Oracle Certified Professional Java SE 8 Programmer II Guide (Exam IZ0-809) is a comprehensive guide for the OCPJP 8 exam. The book starts by answering frequently asked questions about the OCPJP 8 exam (Chapter 1). The book maps each exam topic into a chapter and covers 100% of the exam topics (next 12 Chapters). Exam topics are discussed using numerous programming and real-world examples. Each chapter ends with practice exam questions and a quick summary that revises key concepts covered in the chapter from exam perspective.

Upgrade to Java SE 8 OCP ( Java SE 6 and all prior versions) - (1Z0-813)

Step 1 - Prior Certification Requirements

Candidate must have one of the following certifications
  • Java SE 6 OR any prior versions
Step 2 - Pass Exam
Upgrade to Java SE 8 OCP ( Java SE 6 and all prior versions) 1Z0-813

Exam Number : 1Z0-813
Oracle Certified Professional, Java SE 8 Programmer , Oracle Certified Java Programmer, Gold SE 8 - Available only in Japan (Oracle Certified Professional, Java SE 8 Programmer)
Exam Product Version: Java SE
Exam Price: $150 (approximate)
Duration: 130 minutes
Number of Questions: 60
Passing Score 63%
format: Multiple Choice
Exam Topics

Assume the following:

  • Missing package and import statements: If sample code do not include package or import statements, and the question does not explicitly refer to these missing statements, then assume that all sample code is in the same package, and import statements exist to support them.
  • No file or directory path names for classes: If a question does not state the file names or directory locations of classes, then assume one of the following, whichever will enable the code to compile and run:
  • All classes are in one file
  • Each class is contained in a separate file, and all files are in one directory
  • Unintended line breaks: Sample code might have unintended line breaks. If you see a line of code that looks like it has wrapped, and this creates a situation where the wrapping is significant (for example, a quoted String literal has wrapped), assume that the wrapping is an extension of the same line, and the line does not contain a hard carriage return that would cause a compilation failure.
  • Code fragments: A code fragment is a small section of source code that is presented without its context. Assume that all necessary supporting code exists is present and that the supporting environment fully supports the correct compilation and execution of the code shown and its omitted environment.
  • Descriptive comments: Take descriptive comments, such as "setter and getters go here," at face value. Assume that correct code exists, compiles, and runs successfully to create the described effect.

TOPICS
 
Language Enhancements
 
  • Develop code that uses String objects in the switch statement, binary literals, and numeric literals, including underscores in literals
  • Develop code that uses try-with-resources statements, including using classes that implement the AutoCloseable interface
  • Develop code that handles multiple Exception types in a single catch block
  • Use static and default methods of an interface including inheritance rules for a default method
Concurrency
 
  • Use classes from the java.util.concurrent package including CyclicBarrier and CopyOnWriteArrayList with a focus on the advantages over and differences from the traditional java.util collections
  • Use Lock, ReadWriteLock, and ReentrantLock classes in the java.util.concurrent.locks and java.util.concurrent.atomic packages to support lock-free thread-safe programming on single variables
  • Use Executor, ExecutorService, Executors, Callable, and Future to execute tasks using thread pools Use the parallel Fork/Join Framework
Localization
 
  • Describe the advantages of localizing an application and developing code that defines, reads, and sets the locale with a Locale object
  • Build a resource bundle for a locale and call a resource bundle from an application
  • Create and manage date- and time-based events by using LocalDate, LocalTime, LocalDateTime, Instant, Period, and Duration, including a combination of date and time in a single object
  • Format dates, numbers, and currency values for localization with the NumberFormat and DateFormat classes, including number and date format patterns
  • Work with dates and times across time zones and manage changes resulting from daylight savings
Java File I/O (NIO.2)
 
  • Operate on file and directory paths by using the Paths class
  • Check, delete, copy, or move a file or directory by using the Files class
  • Recursively access a directory tree by using the DirectoryStream and FileVisitor interfaces
  • Find a file by using the PathMatcher interface, and use Java SE 8 I/O improvements, including Files.find(), Files.walk(), and lines() methods
  • Observe the changes in a directory by using the WatchService interface
Lambda
 
  • Define and write functional interfaces and describe the interfaces of the java.util.function package
  • Describe a lambda expression; refactor the code that uses an anonymous inner class to use a lambda expression; describe type inference and target typing
  • Develop code that uses the built-in interfaces included in the java.util.function package, such as Function, Consumer, Supplier, UnaryOperator, Predicate, and Optional APIs, including the primitive and binary variations of the interfaces
  • Develop code that uses a method reference, including refactoring a lambda expression to a method reference
Java Collections
 
  • Develop code that uses diamond with generic declarations
  • Develop code that iterates a collection, filters a collection, and sorts a collection by using lambda expressions
  • Search for data by using methods, such as findFirst(), findAny(), anyMatch(), allMatch(), and noneMatch()
  • Perform calculations on Java Streams by using count, max, min, average, and sum methods and save results to a collection by using the collect method and Collector class, including the averagingDouble, groupingBy, joining, partitioningBy methods
  • Develop code that uses Java SE 8 collection improvements, including the Collection.removeIf(), List.replaceAll(), Map.computeIfAbsent(), and Map.computeIfPresent() methods
  • Develop code that uses the merge(), flatMap(), and map() methods on Java Streams
Java Streams
 
  • Describe the Stream interface and pipelines; create a stream by using the Arrays.stream() and IntStream.range() methods; identify the lambda operations that are lazy
  • Develop code that uses parallel streams, including decomposition operation and reduction operation in streams

Upgrade Java SE 7 to Java SE 8 OCP Programmer (1Z0-810)

Step 1 - Prior Certification Requirements

Oracle Certified Professional, Java SE 7 Programmer

Step 2 - Pass Exam
Upgrade Java SE 7 to Java SE 8 OCP Programmer 1Z0-810 (Formerly Titled: Upgrade to Java SE 8 Programmer)

Exam Number : 1Z0-810
Oracle Certified Java Programmer, Gold SE 8 - Available only in Japan (Oracle Certified Professional, Java SE 8 Programmer) , Oracle Certified Professional, Java SE 8 Programmer (upgrade)
Exam Product Version: Java SE
Exam Price: $150 (approximate)
Duration: 150 minutes
Number of Questions: 81
Passing Score 65%
format: Multiple Choice
Exam Topics

Assume the following:

  • Missing package and import statements: If sample code do not include package or import statements, and the question does not explicitly refer to these missing statements, then assume that all sample code is in the same package, and import statements exist to support them.
  • No file or directory path names for classes: If a question does not state the file names or directory locations of classes, then assume one of the following, whichever will enable the code to compile and run:
  • All classes are in one file
  • Each class is contained in a separate file, and all files are in one directory
  • Unintended line breaks: Sample code might have unintended line breaks. If you see a line of code that looks like it has wrapped, and this creates a situation where the wrapping is significant (for example, a quoted String literal has wrapped), assume that the wrapping is an extension of the same line, and the line does not contain a hard carriage return that would cause a compilation failure.
  • Code fragments: A code fragment is a small section of source code that is presented without its context. Assume that all necessary supporting code exists is present and that the supporting environment fully supports the correct compilation and execution of the code shown and its omitted environment.
  • Descriptive comments: Take descriptive comments, such as "setter and getters go here," at face value. Assume that correct code exists, compiles, and runs successfully to create the described effect.

TOPICS
 
Lambda Expressions
  • Describe and develop code that uses Java inner classes, including nested class, static class, local class, and anonymous classes
  • Describe and write functional interfaces
  • Describe a lambda expression; refactor the code that uses an anonymous inner class to use a lambda expression; describe type inference and target typing
Using Built-in Lambda Types
 
  • Describe the interfaces of the java.util.function package
  • Develop code that uses the Function interface
  • Develop code that uses the Consumer interface
  • Develop code that uses the Supplier interface
  • Develop code that uses the UnaryOperator interface
  • Develop code that uses the Predicate interface
  • Develop code that uses the primitive and binary variations of the base interfaces of the java.util.function package
  • Develop code that uses a method reference, including refactoring a lambda expression to a method reference
Java Collections and Streams with Lambdas
 
  • Develop code that iterates a collection by using the forEach() method and method chaining Describe the Stream interface and pipelines
  • Filter a collection by using lambda expressions
  • Identify the operations, on stream, that are lazy
Collection Operations with Lambda
 
  • Develop code to extract data from an object by using the map() method
  • Search for data by using methods such as findFirst(), findAny(), anyMatch(), allMatch(), and noneMatch()
  • Describe the unique characteristics of the Optional class
  • Perform calculations by using Java Stream methods, such as count(), max(), min(), average(), and sum()
  • Sort a collection by using lambda expressions
  • Develop code that uses the Stream.collect() method and Collectors class methods, such as averagingDouble(), groupingBy(), joining(), and partitioningBy()
Parallel Streams
 
  • Develop code that uses parallel streams
  • Implement decomposition and reduction in streams
Lambda Cookbook
 
  • Develop code that uses Java SE 8 collection improvements, including Collection.removeIf(), List.replaceAll(), Map.computeIfAbsent(), and Map.computeIfPresent() methods
  • Develop code that uses Java SE 8 I/O improvements, including Files.find(), Files.walk(), and lines() methods
  • Use flatMap() methods in the Stream API
  • Develop code that creates a stream by using the Arrays.stream() and IntStream.range() methods
Method Enhancements
 
  • Add static methods to interfaces
  • Define and use a default method of an interface and describe the inheritance rules for the default method
Use Java SE 8 Date/Time API
 
  • Create and manage date- and time-based events, including a combination of date and time in a single object, by using LocalDate, LocalTime, LocalDateTime, Instant, Period, and Duration
  • Work with dates and times across time zones and manage changes resulting from daylight savings, including Format date and times values
  • Define, create, and manage date- and time-based events using Instant, Period, Duration, and TemporalUnit

Java SE 6 Developer Certified Master Assignment (1Z0-855) and Master Essay (1Z0-856)

Step 1 - Complete this prior certification.

Candidate must have one of the following certifications

  • Oracle Certified Professional, Java (SE 5, SE 6, SE 7 or SE 8) Programmer or Sun Certified Java Programmer (any edition)
Step 2 - Complete one of these courses.

Candidates must complete one of the courses below

  • Developing Applications with Java EE 6 on WebLogic Server 12c
  • Java SE 7 New Features
  • Java SE 7 Programming
  • Java SE 7 Fundamentals
  • Object-Oriented Analysis and Design Using UML
  • Java SE 7: Develop Rich Client Applications
  • Java Performance Tuning with Mission Control & Flight Recorder
  • Java SE 8 Fundamentals
  • Java SE 8: Programming
  • Java SE 8 New Features

Courses can be instructor-led in-class (ILT), a live virtual class (LVC), training on demand (TOD), or Unlimited Learning Subscription. Self-study CD and online courses are great preparation tools, but do not fulfill the training requirement.

Step 3 - Or submit one of these archived courses that you have already completed.
These courses also count toward certification, but are not currently being scheduled. Candidates may choose a course from this list or from the list above.

  • Developing Applications With the Java SE 6 Platform
  • Java SE Performance Tuning
  • Developing Architectures for Enterprise Java Applications
  • Java Programming Language, Java SE 6 (Please Note: While this course is still being offered as a self-study course, self-study courses do not fulfill the training requirement for certification.)
  • Fundamentals of the Java Programming Language, Java SE 6 (Please Note: While this course is still being offered as a self-study course, self-study courses do not fulfill the training requirement for certification.)
  • Java Performance Tuning and Optimization
Step 4 - Pass Exam
  • Java SE 6 Developer Certified Master Assignment 1Z0-855
Exam Number : 1Z0-855
Associated Certifications : Oracle Certified Master, Java SE 6 Developer
Exam Product Version: Java SE
Exam Price: $150 (approximate)
Duration: 6 months from assignment purchase**
Number of Questions: NA
Passing Score : Subject to validation of assignment% You will receive your assignment results within 6-8 weeks of submission of your essay.
Validated Against: This assignment has been validated against SE 6.
format: Performance Based
Registration:

  • Purchase exam voucher from Oracle University
  • Register for exam at PearsonVue or locate a test center near you
  • Register for Exam at an Oracle Testing Center
NOTE:

  • BOTH assignment and essay must be submitted within 6 months of assignment purchase date. No exceptions. If you do not submit assignment and essay before the deadline, you will be required to purchase a new assignment.
  • Assignment must be submitted before you can register for the essay.
Certification Value Packages: Save up to 20% on training and exams with this all-inclusive package.
 
Programming Assignment Objectives:
 
Write an application program using Java technology. The application requires the following:
 
  • A graphical user interface demonstrating good principles of design
  • A network connection, using a specified protocol, to connect to an information server
  • A network server, which connects to a previously specified Java technology database
  • A database, created by extending the functionality of a previously written piece of code, for which only limited documentation is available
Step 5 - Resubmit the assignment (if necessary).
 
This option is for candidates who failed 1Z0-855 and need to resubmit the assignment.
 
Step 6 - Pass Exam
 
  • Java SE 6 Developer Certified Master Essay 1Z0-856
Exam Number : 1Z0-856
Associated Certifications : Oracle Certified Master, Java SE 6 Developer
Exam Product Version: Java SE
Exam Price: $150 (approximate)
Duration: 120 minutes
Number of Questions: NA
Passing Score : Subject to evaluation assignment.% You will receive your assignment results within 6-8 weeks of submission of your essay.
Validated Against: This exam is validated against SE 6
format: Essay
NOTE:

  • BOTH assignment and essay must be submitted within 6 months of assignment purchase date. No exceptions. If you do not submit assignment and essay before the deadline, you will be required to purchase a new assignment.
  • Assignment must be submitted before you can register for the essay.
Exam Topics
 
  • List some of the major choices you must make during the implementation of the above.
  • List some of the main advantages and disadvantages of each of your choices.
  • Briefly justify your choices in terms of the comparison of design and implementation objectives with the advantages and disadvantages of each.
Step 7 - Complete this form.
 
  • Complete the course submission form

Java EE 6 Java Persistence API Developer Certified Expert (1Z0-898)

Step 1 - Prior Certification Requirements
Oracle or Sun Certified Java Programmer (Professional) any version

Step 2 - Pass Exam
Java EE 6 Java Persistence API Developer Certified Expert 1Z0-898

Exam Number : 1Z0-898
Associated Certifications: Oracle Certified Expert, EE 6 Java Persistence API Developer
Exam Product Version: Java EE
Exam Price: $150 (approximate)
Duration: 135 minutes
Number of Questions: 64
Passing Score 61%
format: Multiple Choice
Exam Topics

Assume the following:

  • Missing package and import statements: If sample code do not include package or import statements, and the question does not explicitly refer to these missing statements, then assume that all sample code is in the same package, and import statements exist to support them.
  • No file or directory path names for classes: If a question does not state the file names or directory locations of classes, then assume one of the following, whichever will enable the code to compile and run:
  • All classes are in one file
  • Each class is contained in a separate file, and all files are in one directory
  • Unintended line breaks: Sample code might have unintended line breaks. If you see a line of code that looks like it has wrapped, and this creates a situation where the wrapping is significant (for example, a quoted String literal has wrapped), assume that the wrapping is an extension of the same line, and the line does not contain a hard carriage return that would cause a compilation failure.
  • Code fragments: A code fragment is a small section of source code that is presented without its context. Assume that all necessary supporting code exists is present and that the supporting environment fully supports the correct compilation and execution of the code shown and its omitted environment.
  • Descriptive comments: Take descriptive comments, such as "setter and getters go here," at face value. Assume that correct code exists, compiles, and runs successfully to create the described effect.

TOPICS
 
Overview of the Java Persistence API
 
  • Describe the basics of Object Relational Mapping (ORM)
  • Define the key concepts of the Java Persistence API (entity, entity manager, and persistence unit)
Introducing the Auction Application
 
  • Describe the auction application
  • Define the domain objects of the auction application
  • Describe the implementation model for the auction system
Java Persistence API Entities
 
  • Describe the difference between objects and entities
  • Describe the difference between persistent fields and properties
  • Identify and use common Java Persistence API annotations, such as @Entity, @Id, @Table, and @Column
Understanding the Entity Manager
 
  • Describe the relationship between an entity manager, a persistence context, and a persistence unit
  • Describe the difference between a container-managed entity manager and an application-managed entity manager
  • Describe the entity life cycle
Modeling Entity Relationships
 
  • Examine association relationships in the data and object models
  • Use relationship properties to define associations
  • Implement one-to-one unidirectional associations
  • Implement one-to-one bidirectional associations
  • Implement many-to-one/one-to-many bidirectional associations
  • Implement many-to-many bidirectional associations
  • Implement many-to-many unidirectional associations
  • Examine fetch and cascade mode settings
Entity Inheritance and Object-Relational Mapping
 
  • Examine entity inheritance
  • Examining object/relational inheritance hierarchy mapping strategies
  • Inherit from an entity class
  • Inherit using a mapped superclass
  • Inherit from a non-entity class
  • Examine inheritance mapping strategies
  • Use an embeddable class
Persisting Enums and Collections
 
  • Persist entities that contain enums with @Enumerated
  • Persist entities that contain lists with @ElementCollection
  • Persist entities that contain maps with @ElementCollection
Introduction to Querying
 
  • Find an Entity by its primary key
  • Understand basic Java Persistence API query language queries
  • Understand native SQL queries
  • Understand basic Criteria API queries
Using the Java Persistence API Query Language
 
  • Examine the Java Persistence API query language
  • Create and use the SELECT statement
  • Create and use the UPDATE statement
  • Create and use the DELETE statement
Using the Java Persistence API Criteria API
 
  • Contrast queries that use the Criteria API with queries that use the Java Persistence query language
  • Describe the metamodel object approach to querying
  • Create Criteria API queries
Using the Java Persistence API in a Container
 
  • Use the Java Persistence API from a servlet
  • Use the Java Persistence API from a stateless session bean
Implementing Transactions and Locking
 
  • Describe the transaction demarcation management
  • Implement container-managed transactions (CMT)
  • Interact programmatically with an ongoing CMT transaction
  • Implement bean-managed transactions (BMT)
  • Apply transactions to the Java Persistence API
Advanced Java Persistence API Concepts
 
  • Specify composite primary keys
  • Override mappings with the @AttributeOverride and @AssociationOverride annotations
  • Understand entity listeners and callback methods

Java EE 6 Enterprise JavaBeans Developer Certified Expert (1Z0-895)

Step 1 - Prior Certification Requirements
Oracle or Sun Certified Java Programmer (Professional) any version

Step 2 - Pass Exam
Java EE 6 Enterprise JavaBeans Developer Certified Expert 1Z0-895

Exam Number: 1Z0-895
Associated Certifications: Oracle Certified Expert, Java EE 6 Enterprise JavaBeans Developer
Exam Product Version: Java EE
Exam Price: $150 (approximate)
Duration: 110 minutes
Number of Questions: 60
Passing Score: 73%
Validated Against: This exam has been validated against EE 6.
format: Multiple Choice
Exam Topics

Assume the following:

  • Missing package and import statements: If sample code do not include package or import statements, and the question does not explicitly refer to these missing statements, then assume that all sample code is in the same package, and import statements exist to support them.
  • No file or directory path names for classes: If a question does not state the file names or directory locations of classes, then assume one of the following, whichever will enable the code to compile and run:
  • All classes are in one file
  • Each class is contained in a separate file, and all files are in one directory
  • Unintended line breaks: Sample code might have unintended line breaks. If you see a line of code that looks like it has wrapped, and this creates a situation where the wrapping is significant (for example, a quoted String literal has wrapped), assume that the wrapping is an extension of the same line, and the line does not contain a hard carriage return that would cause a compilation failure.
  • Code fragments: A code fragment is a small section of source code that is presented without its context. Assume that all necessary supporting code exists is present and that the supporting environment fully supports the correct compilation and execution of the code shown and its omitted environment.
  • Descriptive comments: Take descriptive comments, such as "setter and getters go here," at face value. Assume that correct code exists, compiles, and runs successfully to create the described effect.

TOPICS
 
Introduction to Java EE
 
  • Gain an understanding of the Java Platform, Enterprise Edition (Java EE)
  • Examine the Java EE application architecture
  • Examine Java EE container services
  • Examine the EJB component types
  • Evaluate the EJB Lite Container
  • Compare Java EE application development with traditional enterprise application development
Implementing Session Beans
 
  • Examine session beans
  • Identify the three types of session beans
  • Choose the correct session bean type given a business constraint
  • Create session beans Package and deploy session beans
Accessing Session Beans
 
  • Understand the purpose and role of JNDI in relation to EJB components
  • Configure JNDI environment properties
  • Use JNDI to look up a resource
  • Write code that receives a resource reference through injection
  • Create a session bean client
  • Create a session facade
  • Use dependency injection to locate an EJB
Advanced Session Bean Concepts
 
  • Understand the relationship between the EJB container and an EJB component
  • Describe the life cycle for stateless and stateful session beans
  • Implement session bean life cycle methods
  • Use a session bean to perform asynchronous communication
  • Have fine-grained control over packaging and deployment
Singleton Session Bean
 
  • Understand the advantages and disadvantages of using a singleton session bean
  • Create a singleton session bean
  • Describe the life cycle of a singleton session bean
  • Implement singleton session bean life cycle methods
  • Describe singleton concurrency access
  • Implement a concurrency management strategy
Developing Java EE Applications Using Messaging
 
  • Review JMS technology
  • Describe the roles of the participants in the JMS API messaging system
  • Create a queue message producer
  • Create a synchronous message consumer
Developing Message-Driven Beans
 
  • Understand the short-comings of using session beans as messaging consumers
  • Describe the properties and life cycle of message-driven beans
  • Create a JMS message-driven bean
  • Create life cycle event handlers for a JMS message-driven bean
  • Configure a JMS message-driven bean
Using Timer ServicesObjectives
 
  • Describe timer services
  • Create a timer notification callback
  • Process a timer notification callback Manage timer objects
Implementing Interceptor Classes and Methods
 
  • Describe interceptors and interceptor classes
  • Create a business interceptor method in the enterprise bean class
  • Create an interceptor class
  • Associate multiple business interceptor methods with an enterprise bean
  • Include life cycle callback interceptor methods in an interceptor class
Implementing Transactions
 
  • Describe transaction demarcation management
  • Implement CMT
  • Interact programmatically with an ongoing CMT transaction
  • Implement BMT Apply transactions to messaging
Implementing Security
 
  • Understand the Java EE security architecture
  • Authenticate the caller Examine Java EE authorization strategies
  • Use declarative authorization
  • Use programmatic authorization Examine the responsibilities of the deployer
Using EJB Technology Best Practices
 
  • Define best practices and state the benefits of using EJB technology best practices
  • Select and apply known patterns to Java EE application design
  • Incorporate effective exception handling into your Java EE application design
  • Package and Deploy EJB applications
  • Perform EJB Exception Handling

Java EE 6 JavaServer Faces Developer Certified Expert (1Z0-896)

Step 1 - Prior Certification Requirements
Oracle or Sun Certified Java Programmer (Professional) any version

Step 2 - Pass Exam
Java EE 6 JavaServer Faces Developer Certified Expert 1Z0-896

Exam Number : 1Z0-896
Associated Certifications: Oracle Certified Expert, Java EE 6 JavaServer Faces Developer
Exam Product Version: Java EE
Exam Price: $150 (approximate exam pricing)
Duration: 150 minutes
Number of Questions: 87
Passing Score 70%
Validated Against: This exam has been validated against EE 6.
format: Multiple Choice
Exam Topics

Assume the following:

  • Missing package and import statements: If sample code do not include package or import statements, and the question does not explicitly refer to these missing statements, then assume that all sample code is in the same package, and import statements exist to support them.
  • No file or directory path names for classes: If a question does not state the file names or directory locations of classes, then assume one of the following, whichever will enable the code to compile and run:
  • All classes are in one file
  • Each class is contained in a separate file, and all files are in one directory
  • Unintended line breaks: Sample code might have unintended line breaks. If you see a line of code that looks like it has wrapped, and this creates a situation where the wrapping is significant (for example, a quoted String literal has wrapped), assume that the wrapping is an extension of the same line, and the line does not contain a hard carriage return that would cause a compilation failure.
  • Code fragments: A code fragment is a small section of source code that is presented without its context. Assume that all necessary supporting code exists is present and that the supporting environment fully supports the correct compilation and execution of the code shown and its omitted environment.
  • Descriptive comments: Take descriptive comments, such as "setter and getters go here," at face value. Assume that correct code exists, compiles, and runs successfully to create the described effect.

TOPICS
 
Section 1: Essentials of JSF2.0
 
  • Identify the features of JSF such as Facelets, BookMarkable View, AJAX support and the benefits they bring in
  • Identify the life cycle stages of JSF, flow of request processing, and purpose of FacesContext
  • Design XHTML pages using JSF HTML tag library and demonstrate usage of JSF implicit objects
  • Develop and associate model components with views using CDI Named beans and identify the advantages of CDI Named beans over Managed Bean
  • Manage user and application state using various scopes like flash, conversation, application, request, and session
  • Implement internationalization/Localization using resource bundle and Locale class
Section 2: JSF Navigation Model
 
  • Design JSF pages with static and dynamic implicit navigation
  • Configure faces-config.xml to implement navigation rules including conditional and redirection
  • Design bookmarkable views
Section 3: Data Conversion and Validation model
 
  • Implement data conversion model using JSF standard converters
  • Create, configure, and use custom converters
  • Identify the best suited standard validator and implement it in a given JSF application
  • Create, configure, and use custom validators
  • Describe the usage of bean validation
Section 4: Event Handling
 
  • Use CDI Named bean in a JSF application to handle action and valuechange events
  • Create and implement listeners to handle events
  • Develop JSF application that handle life cycle events
  • Implement asynchronous events using AJAX
Section 5: Data table and Composite Components
 
  • Design a DataTable with header and footer to populate and manipulate data from various components like Array, List, ResultSet, DataModel and describe the differences between <f:dataTable> and <ui:repeat/>
  • Implement composite components in JSF application and enhance it using AJAX
  • Implement templates in a JSF application and describe the differences between <ui:composition/> and <ui:decorate/>
Section 6: Custom Components
 
  • Identify when and how to use custom components and custom renderers.
  • Enhance JSF application using HTML5 components
Section 7: Security
 
  • Configure security for JSF application using authorization and authentication techniques
Section 8: Test, Package, and Deploy a web application
 
  • Implement efficient error handling and debugging techniques in a JSF application
  • Configure and deploy a JSF application

Java EE 6 Web Component Developer Certified Expert (1Z0-899)

Step 1 - Prior Certification Requirements
Oracle or Sun Certified Java Programmer (Professional) any version

Step 2 - Pass Exam
Java EE 6 Web Component Developer Certified Expert 1Z0-899

Exam Number : 1Z0-899
Associated Certifications: Oracle Certified Expert, Java EE 6 Web Component Developer
Exam Product Version: Java EE
Exam Price: Rs 9604 More on exam pricing
Duration: 140 minutes
Number of Questions: 57
Passing Score 64%
Validated Against: This exam has been validated against EE 6.
format: Multiple Choice
Exam Topics

Assume the following:

  • Missing package and import statements: If sample code do not include package or import statements, and the question does not explicitly refer to these missing statements, then assume that all sample code is in the same package, and import statements exist to support them.
  • No file or directory path names for classes: If a question does not state the file names or directory locations of classes, then assume one of the following, whichever will enable the code to compile and run:
  • All classes are in one file
  • Each class is contained in a separate file, and all files are in one directory
  • Unintended line breaks: Sample code might have unintended line breaks. If you see a line of code that looks like it has wrapped, and this creates a situation where the wrapping is significant (for example, a quoted String literal has wrapped), assume that the wrapping is an extension of the same line, and the line does not contain a hard carriage return that would cause a compilation failure.
  • Code fragments: A code fragment is a small section of source code that is presented without its context. Assume that all necessary supporting code exists is present and that the supporting environment fully supports the correct compilation and execution of the code shown and its omitted environment.
  • Descriptive comments: Take descriptive comments, such as "setter and getters go here," at face value. Assume that correct code exists, compiles, and runs successfully to create the described effect.

TOPICS
 
Introduction to Java Servlets
 
  • Describe web applications, CGI, and the role of Java
  • Describe benefits of Java servlet technology
  • Create a simple Java Servlet
  • Define three-tier architecture
  • Define Model-View-Controller (MVC) architecture
Introduction to Java Server Pages
 
  • Describe why Servlets are not the whole solution
  • Describe essentials of JSPs
  • Understand the fundamentals and reasons for MVC architecture
Implementing an MVC Design
 
  • Code a controller using a servlet
  • Code a view using a JSP
  • Forward control from a servlet to a JSP
  • Understand fundamentals of EL
  • Implement a simple MVC system
The servlet's environment
 
  • Understand more details of the HTTP protocol
  • Understand fundamentals of HTML forms
  • Understand fundamentals of the HttpServlet and related APIs
  • Write code that manages client sessions and cookies
Container facilities for servlets and JSPs
 
  • Understand the purpose and structure of deployment descriptors
  • Control context root and servlet mapping
  • Create and use context and init parameters
  • Use annotations to configure servlets
More view facilities
 
  • Understand the four data scopes
  • Understand and use EL dot and array access operators with Java Beans, arrays, and collections
  • Understand and use EL implicit objects
  • Create and use arithmetic expressions in EL
  • Identify the need for iteration and selection in the view, and use JSTL tags to address those needs
Developing JSP pages
 
  • Understand the origins, benefits, and weaknesses of JSPs
  • Describe JSP technology, the conversion of JSPs to servlets, and the lifecycle of JSPs
  • Understand JSP scripting elements, declarations and directives
  • Use JSP implicit variables
  • Understand and use jsp: tags
Developing JSP pages using custom tags
 
  • Relate the JSTL to common job roles in web application development and understand the use of tags in JSP development
  • Recognize correct syntax for tags
  • Configure a JSP to use tags from the JSTL
  • Write JSP code using several standard tags
  • List capabilities of JSTL tags
More Controller facilities
 
  • Understand the servlet lifecycle
  • Describe and use more advanced elements of the servlet APIs
  • Create filters and use them in web applications
More options for the Model
 
  • Understand the roles of JDBC and JPA
  • Understand the many elements that make up the model
  • Understand fundamentals of connecting to a database using JDBC or JPA
Asynchronous web applications
 
  • Understand the interactions that are essential to asynchronous web pages
  • Understand the role of AJAX-style client side programming
  • Implement asynchronous servlets using the facilities of Java EE 6
Web application security
 
  • Understand the role of the container in security
  • Describe and implement four authentication models
  • Force the use of encryption between a web application and the client browser
  • Understand the role of JAAS in pluggable/extensible authentication for web applications

Java EE 6 Web Services Developer Certified Expert (1Z0-897)

Step 1 - Prior Certification Requirements
Oracle or Sun Certified Java Programmer (Professional) any version

Step 2 - Pass Exam
Java EE 6 Web Services Developer Certified Expert 1Z0-897

Exam Number : 1Z0-897
Associated Certifications: Oracle Certified Expert, Java EE 6 Web Services Developer
Exam Product Version: Java EE
Exam Price: $150 (approximately)
Duration: 90 minutes
Number of Questions: 55
Passing Score 65%
format: Multiple Choice
Exam Topics

Assume the following:

  • Missing package and import statements: If sample code do not include package or import statements, and the question does not explicitly refer to these missing statements, then assume that all sample code is in the same package, and import statements exist to support them.
  • No file or directory path names for classes: If a question does not state the file names or directory locations of classes, then assume one of the following, whichever will enable the code to compile and run:
  • All classes are in one file
  • Each class is contained in a separate file, and all files are in one directory
  • Unintended line breaks: Sample code might have unintended line breaks. If you see a line of code that looks like it has wrapped, and this creates a situation where the wrapping is significant (for example, a quoted String literal has wrapped), assume that the wrapping is an extension of the same line, and the line does not contain a hard carriage return that would cause a compilation failure.
  • Code fragments: A code fragment is a small section of source code that is presented without its context. Assume that all necessary supporting code exists is present and that the supporting environment fully supports the correct compilation and execution of the code shown and its omitted environment.
  • Descriptive comments: Take descriptive comments, such as "setter and getters go here," at face value. Assume that correct code exists, compiles, and runs successfully to create the described effect.

TOPICS
 
  • Create an SOAP web service in a servlet container
  • Create a RESTful web service in a servlet container
  • Create a SOAP based web service implemented by an EJB component
  • Create a RESTful web service implemented by an EJB component
  • Configure JavaEE security for a SOAP web service
  • Create a web service client for a SOAP based web service
  • Create a web service client for a RESTful web service
  • Create a SOAP based web service using Java SE platform
  • Create handlers for SOAP web services
  • Create low-level SOAP web services
  • Use MTOM and MIME in a SOAP web service
  • Use WS-Addressing with a SOAP web service
  • Configure Message Level security for a SOAP web service
  • Apply best practices to design and implement web services