Java se 8 fundamentals

1. Java SE 8 Fundamentals
What Is a Java Program?
 Introduction to Computer Programs
 Key Features of theJava 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 UseCase
Manipulating and Formatting the Data in
Your Program
 Using theString Class
 Using theJava API Docs
 Using theStringBuilder Class
 Moreabout 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
 Moreways to use if/else constructs
 Using Switch Statements
 Using theNetBeans Debugger
More on Arrays and Loops
 Working with Dates
 Parsing the args Array
 Two-dimensional Arrays
 Alternate Looping Constructs
 Nesting Loops
 The ArrayList class
Using Inheritance
 Overview of inheritance
 Working with subclasses and superclasses
 Overriding methods in thesuperclass
 Introducing polymorphism
 Creating and extending abstract classes
Using Interfaces
 Polymorphismin the JDK foundation classes
 Using Interfaces
 Using theList Interface
 Introducing Lambda expressions
Handling Exceptions
 Handling Exceptions: An overview
 Propagation of exceptions
 Catching and throwing exceptions
 Handling multiple exceptions and errors
Course objectives
 Write Java code that uses variables, arrays, conditional and loop constructs
 Manipulateprimitive numeric data and string data using Java operators
 Create Java classes and use object references
 Access the fields and methods of an object
 Manipulatetext data using themethods of the String and StringBuilder classes
 Use casting without losing precision or causing errors
 Declare, override, and invoke methods
 Access and create staticfields and methods
 Use classes from the java.time and java.time.format packages to format and print thelocal date and time
 Encapsulate a class using access modifiers and overloaded constructors
 Define and implement a simple class hierarchy
 Demonstratepolymorphismby implementing a Java Interface
 Use a Predicate Lambda expression as the argument to a method
 Handle a checked exception in a Java application

2. Java SE 8 Programmer II (1z0-809 - Oracle Certified Professional, Java SE 8 Programmer )
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 Java classes
 Creating primitive variables
 Using operators
 Creating and manipulate strings
 Using if-else and switch statements
 Iterating with loops: while,do-while,for,enhanced for
 Creating 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

3.  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 time-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 I/O (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 NIO2
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.util.concurrent collections
The Fork-Join Framework
 Parallelism
 The need for Fork-Join
 Work stealing
 RecursiveTask

4.  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
Objectives
 Creating high-performing multi-threaded applications
 Creating Java technology applications that leverage the object-oriented features of the Java
language, such as encapsulation, inheritance, and polymorphism
 Implementing input/output (I/O) functionality to read from and write to data and text files and
understand advanced I/O streams
 Executing a Java technology application from the command line
 Manipulating files, directories and file systems using the JDK NIO.2 specification
 Creating applications that use the Java Collections framework
 Performing multiple operations on database tables, including creating, reading, updating and
deleting using both JDBC and JPA technology
 Searching and filter collections using Lambda Expressions
 Implementing error-handling techniques using exception handling
 Using Lambda Expression concurrency features

5. Java SE 8 Programmer I
1Z0-808 AssociatedCertifications:
Oracle CertifiedAssociate, Java SE 8 Programmer
Exam Product Version: Java SE
Java Basics
 Define thescope of variables
 Define thestructureof a Java class
 Create executable Java applications with a main method; run a Java program from thecommand 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: platformindependence, 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 thestatickeyword to methods and fields
 Create and overload constructors;including impact on default constructors
 Apply access modifiers
 Apply encapsulation principles to a class
 Determine theeffect upon object references and primitive values when they are passed into methods that change the
values
Working with Inheritance
 Describe inheritance andits benefits
 Develop code that demonstrates theuse of polymorphism; includingoverridingandobject type versus reference type
 Determine when castingis necessary
 Use super andthis to access objects andconstructors
 Use abstract classes andinterfaces
Handling Exceptions
 Differentiate amongcheckedexceptions, uncheckedexceptions, andErrors
 Create a try-catchblockanddetermine howexceptions alter normal programflow
 Describe the advantages of Exceptionhandling
 Create andinvoke a methodthat throws an exception
 "Recognize commonexception classes (such as NullPointerException, ArithmeticExcpetion,ArrayIndexOutOfBoundsException,
ClassCastException)"
Workingwith Selected classes from the Java API
 Manipulate data usingthe StringBuilder class andits methods
 CreatingandmanipulatingStrings
 Create andmanipulate calendar datausingclasses from java.time.LocalDateTime, java.time.LocalDate, java.time.LocalTime,
java.time.format.DateTimeFormatter, java.time.Period
 Declare anduse an ArrayList of a giventype
 Write a simple Lambda expression that consumes a Lambda Predicate expression