Oracle Java
Java SE 7 Fundamentals : IZ0-803
Introducing the Java Technology
- Relating Java With Other languages
- Showing how to download, install, and configure the Java environment on a Windows system.
- Describing the various Java technologies such as Java EE, JavaME, Embedded Java SE
- Describing key features of the technology and the advantages of using Java
- Using an Integrated Development Environment (IDE)
Thinking in Objects
- Defining the problem domain
- Identifying objects and recognizing the criteria for defining objects
Introducing the Java Language
- Defining classes
- Identifying the components Of a class
- Creating and using a test class
- Compiling and executing a test program
Working with Primitive Variables
- Declaring and initializing field variables
- Describing primitive data types such as integral, floating point, textual, and logical
- Declaring variables and assigning values
- Using constants
- Using arithmetic operators to modify values
Working with Objects
- Declaring and initializing objects
- Storing Objects in memory
- Using object references to manipulate data
- Using JSE javadocs to look up the methods of a class
- Working with String and StringBuiIder objects
Using operators and decision constructs
- Using relational and conditional operators
- Testing equality between strings
- Evaluating different conditions in a program and determining the algorithm
- Creating if and if/else constructs
- Nesting and chaining conditional statements
- Using a switch statement
Creating and Using Arrays
- Declaring, instantiating, and initializing a one-dimensional Array
- Declaring, instantiating, and initializing a two-dimensional Array
- Using a for loop to process an Array
- Creating and initializing an ArrayList
- Using the import statement to work with existing Java APIs
- Accessing a value in an Array or and ArrayList
- Using the args Array
Using Loop Constructs
- Creating while loops and nested while loops
- Developing a for loop
- Using ArrayLists with for loops
- Developing a do While loop
- Understanding variable scope
Working with Methods and Method Overloading
- Creating and Invoking a Method
- Passing arguments and returning values
- Creating static methods and variables
- Using modifiers
- Overloading a method
Using Encapsulation and Constructors
- Creating constructors
- Implementing encapsulation
Introducing Advanced Object Oriented Concepts
- Using inheritance
- Using types of polymorphism such as overloading, overriding, and dynamic binding
- Working With superclasses and subclasses
- Adding abstraction to your analysis and design
- Understanding the purpose of Java interfaces
- Creating and implementing a Java interface
Handling Errors
- Understanding the different kinds Of errors that can occur and how they are handled in Java
- Understanding the different kinds of Exceptions in Java
- Using Javadocs to research the Exceptions thrown by the methods of foundation classes
- Writing code to handle Exceptions
The Big picture
- Creating packages and JAR files for deployment using java
- Two and three tier architectures
- Looking at some Java applications examples
Java SE 7 Programming : IZ0-804
Java platform Overview
- Introductions
- Course Schedule
- Java Overview
- Java Platforms
- OpenJDK
- Licensing
- Java in Server Environments
- The Java Community Process
Java Syntax and Class Review
- Simple Java classes
- Java fields, constructors and methods
- Model objects using Java classes
- Package and import statements
Encapsulation and Polymorphism
- Encapsulation in Java class design
- Model business problems with Java classes
- Immutability
- Subclassing
- Overloading methods
- Variable argument methods
Java Class Design
- Access modifiers: private, protected and public
- Method overriding
- Constructor overloading
- The instanceof operator
- Virtual method invocation
- Polymorphism
- Casting object references
- Overriding Object methods
Advanced Class Design
- Abstract classes and type generalization
- The static and final modifiers
- Field modifier best practices
- The Singleton design pattern
- Designing abstract classes
- Nested classes
- Enumerated types
Inheritance with Java Interfaces
- Java Interfaces
- Types of Inheritance
- Object composition and method delegation
- Implementing multiple interfaces
- The DAO design pattern
Generics and Collections
- Generic classes and type parameters
- Type inference (diamond)
- Collections and generics
- List, set and Map
- Stack and Deque
String processing
- String manipulation with StringBuilder and StringBuffer
- Essential String methods
- Text parsing in Java
- Input processing with Scanner
- Text output and formatting
- Regular expressions with the Pattern and Matcher classes
Exceptions and Assertions
- Exceptions categories
- Standard Java Exception classes
- Creating your own Exception classes
- Using try-catch and the finally clause
- Using try-with-resources and the AutoCloseabIe interface
- The multi-catch feature
- Best practices using exceptions
- Assertions
I/O Fundamentals
- I/O using Java
- Reading the console input stream
- Writing to the console
- Using I/O Streams
- Chaining I/O Streams
- Channel I/O
- Reading and writing Objects using Serialization
File I/O with NIO 2
- The Path interface
- The Files class
- Directory and File operations
- Managing file System attributes
- Reading, writing, and creating files
- Watching for file system changes
Threading
- Operating System task scheduling
- Recognizing multithreaded environments
- Creating multi-threaded solutions
- Sharing data across threads
- Synchronization and Deadlock
- Immutable Objects
Concurrency
- Creating Atomic variables
- Using Read-Write Locks
- Thread-safe collections
- Concurrenct synchronizers (Semaphore, Phaser, and others)
- Executors and ThreadPools to concurrently schedule tasks
- Parallelism and the Fork-join framework
Database Application with JDBC
- Layout of the JDBCAPI
- JDBC divers
- Queries and results
- PreparedStatemeni CallabfeStatement
- Transactions
- RowSet 1.1 ROWSetprovider and RowSetFactory
- The DAO Pattern and JDBC
Localization
- Advantages Of localization
- Defining locale
- Read and set locale using the Locale Object
- Resource bundles
- Format messages, dates and numbers
Exam Detail
Oracle Certified Associate, JavaSe7 programmer
Exam Code |
1Z0-803 |
Duration |
120 Minutes |
Number of Question |
70 |
Passing score |
63% |
Oracle Certified Professional, JavaSe7 Programmer
Exam Code |
1Z0-804 |
Duration |
150 Minutes |
Number of Question |
65 |
Passing score |
65% |
Oracle Certified Associate, Java SE-8 programmer
Recommended Training : Java SE 8 Fundamentals
- Course Topics
- What Is a java Program?
- Introduction to Computer Programs
- Key Features of the Java Language
- The Java Technology and Development Environment
- Running/testing a Java program
Creating a Java Main Class
- Java Classes
- The main Method
Data In the Cart
- Introducing variables
- Working with Strings
- Working with numbers
- Manipulating numeric data
Managing Multiple Items
- Working with Conditions
- Working with a List of Items
- Processing a list of items
Describing Objects and Classes
- Working with objects and classes
- Defining fields and methods
- Declaring, Instantiating, and Initializing Objects
- Working With Object References
- Doing more with Arrays
- Introducing the NetBeans IDE
- Introducing the Soccer League Use Case
Manipulating and Formatting the Data in Your Program
- Using the String Class
- Using the Java API Docs
- Using the String Builder Class
- More about primitive data types
- The remaining numeric operators
- Promoting and casting variables
Creating and using Methods
- Using methods
- Method arguments and return values
- Static methods and variables
- How Arguments are Passed to a Method
- Overloading a method
Using Encapsulation
- Access Control
- Encapsulation
- Overloading constructors
More on Conditionals
- Relational and conditional operators
- More ways to use if/else constructs
- Using Switch Statements
- Using the NetBeans Debugger
More on Arrays and Loops
- Working with Dates
- Parsing the args Array
- Two-dimensional Arrays
- Alternate Looping Constructs
- Nesting Loops
- The ArravList class
Using Inheritance
- Overview of inheritance
- Working with subclasses and superclasses
- Overriding methods in the superclass
- Introducing polymorphism
- Creating and extending abstract classes
Using Interfaces
- Polymorphism in the JDK foundation classes
- Using Interfaces
- Using the List Interface
- Introducing Lambda expressions
Handling Exceptions
Exam Detail
Exam - Java SE 8 Programmer
Exam Number |
IZO-808 |
Duration |
150 |
Number of Question |
77 |
Passing score |
65% |
Oracle Certified Professional, Java SE8 programmer
Recommended Training Java SE 8 programming
- Course Topics
- Java Platform Overview
- Defining how the Java language achieves platform independence
- Differentiating between the Java ME, Java SE, and Java EE Platforms
- Evaluating java libraries, middle-ware, and database options
- Defining how the Java language continues to evolve
Java Syntax and Class Review
- Creating simple lava classes
- Creating primitive variables
- Using operators
- Creating and manipulate strings
- Using if-else and switch statements
- Iterating with loops: while, do-while, for, enhanced forCreating arrays
- Using Java fields, constructors, and methods
Encapsulation and Subclassing
- Using encapsulation in Java class design
- Modeling business problems using Java classes
- Making classes immutable
- Creating and use Java subclasses
- Overloading methods
Overriding Methods, Polymorphism, and Static Classes
- Using access levels; private, protected, default, and public.
- Overriding methods
- Using virtual method invocation
- Using varargs to specify variable arguments
- Using the instanceof operator to compare object types
- Using upward and downward casts
- Modeling business problems by using the static keyword
- Implementing the singleton design pattern
Abstract and Nested Classes
- Designing general-purpose base classes by using abstract classes
- Constructing abstract Java classes and subclasses
- Applying final keyword in Java
- Distinguish between top-level and nested classes
Interfaces and Lambda Expressions
- Defining a Java interface
- Choosing between interface inheritance and class inheritance
- Extending an interface
- Defaulting methods
- Anonymous inner classes
- Defining a Lambda Expression
Collections and Generics
- Creating a custom generic class
- Using the type inference diamond to create an object
- Creating a collection by using generics
- Implementing an ArrayList
- Implementing a TreeSet
- Implementing a HashMap
- Implementing a Deque
- Ordering collections
Collections Streams, and Filters
- Describing the Builder pattern
- Iterating through a collection using lambda syntax
- Describing the Stream interface
- Filtering a collection using lambda expressions
- Calling an existing method using a method reference
- Chaining multiple methods together
- Defining pipelines in terms of lambdas and collections
Lambda Built-in Functional Interfaces
- Listing the built-in interfaces included in java.util.function
- Core interfaces - Predicate, Consumer, Function, Supplier
- Using primitive versions of base interfaces
- Using binary versions of base interfaces
Lambda Operations
- Extracting data from an Object using map
- Describing the types Of stream operations
- Describing the Optional class
- Describing lazy processing
- Sorting a stream
- Saving results to a collection using the collect method
- Grouping and partition data using the Collectors class
Exceptions and Assertions
- Defining the purpose of Java exceptions
- Using the try and throw statements
- Using the catch, multi-catch, and finally clauses
- Autoclose resources With a try-with-resources statement
- Recognizing common exception classes and categories
- Creating custom exceptions
- Testing invariants by using assertions
Java Date/Time API
- Creating and manage date-based events
- Creating and manage rime-based events
- Combining date and time into a single object
- Working with dates and times across time zones
- Managing changes resulting from daylight savings
- Defining and create timestamps, periods and durations
- Applying formatting to local and zoned dates and times
I/O Fundamentals
- Describing the basics of input and output in Java
- Read and write data from the console
- using streams to read and write files
- Writing and read objects using serialization
File 1/0 (NIO.2)
- Using the Path interface to operate on file and directory paths
- Using the Files class to check, delete, copy, or move a file or directory
- Using Stream API with N102
Concurrency
- Describing operating system task scheduling
- Creating worker threads using Runnable and Callable
- Using an ExecutorService to concurrently execute tasks
- Identifying potential threading problems
- using synchronized and concurrent atomic to manage atomicity
- using monitor locks to control the order of thread execution
- using the java.utiLconcurrent collections
The Fork-Join Framework
- Parallelism
- The need for Fork-join
- Work stealing
- RecursiveTask
- RecursiveTask
Parallel Streams
- Reviewing the key characteristics of streams
- Describing how to make a stream pipeline execute in parallel
- List the key assumptions needed to use a parallel pipeline
- Defining reduction
- Describing why reduction requires an associative function
- Calculating a value using reduce
- Describing the process for decomposing and then merging work
- Listing the key performance considerations for parallel Streams
Database Applications with JDBC
- Defining the layout Of the JDBC API
- Connecting to a database by using a JDBC driver
- Submitting queries and get results from the database
- Specifying JDBC driver information externally
- performing CRUD operations using the JDBC API
Localization
- Describing the advantages of localizing an application
- Defining what a locale represents
- Read and set the locale by using the Locale Object
- Building a resource bundle for each locale
- Calling a resource bundle from an application
- Changing the locale for a resource bundle
- Copyright
Exam Detail
Exam - Java SE 8 Programmer II IZO-809
Exam Number |
IZ0-809 |
Duration |
150 minutes |
Number of Question |
85 |
Passing score |
65% |
Java EE 6 Web Component Developer Certified Expert
Web Component Development with Servlets & JSPs, Java EE 6 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 ISPs
- 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 ISP
- 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 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 ISP pages
- Understand the origins, benefits, and weaknesses of JSPs
- Describe 'SP technology, the conversion Of ISPs to servlets, and the lifecycle Of JSPs
- Understand ISP scripting elements, declarations and directives
- Use JSP implicit variables
- Understand and use jsp: tags
Developing J SP pages using custom tags
- Relate the JSTL to common job roles in web application development and understand the use of tags in ISP development
- Recognize correct syntax for tags
- Configure a ISP to use tags from the JSTL
- Write ISP 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
Exam Detail
Exam Number |
IZ0-899 |
Duration |
140 minutes |
Number of Question |
57 |
Passing score |
64% |