Duration : 18 hours
Skill Level :Beginner to Intermediate
Table of Contents
Module 1: Before You Begin
Lesson 1: Why would I take the Oracle Certified Associate Java Programmer Exam
Lesson 2: The path to certification
Lesson 3: Preparation strategies
Lesson 4: Test Taking Strategies
4.1: How to take exam questions
4.2: Prepare for exam questions, confidence, and other resources
Module 2: Java Basics
Lesson 1: Define the scope of variables
1.1: The meaning of scope, blocks, and curly braces
1.2: Special cases of scope
Lesson 2: Define the structure of a Java class
2.1: Java class files: Contents and naming rules
2.2: Java classes: The class, member variables, methods and constructors
Lesson 3: Create executable Java applications with a main method; run a Java program from the command line; including console output
3.1: Create executable Java applications with a main method
3.2: Running Java from the command line
3.3: Managing the classpath
3.4: Working with console output
Lesson 4: Import other Java packages to make them accessible in your code
4.1: About packages and their purpose
4.2: Statement order, wildcard imports, importing sub-packages, and handling duplicate class names
Lesson 5: Compare and contrast the features and components of Java such as: platform independence, object orientation, encapsulation, etc.
5.1: Understanding Java’s execution model
5.2: Understanding the value of threading and garbage collection
5.3: Understanding the value of object orientation and encapsulation
Module 3: Working with Java Data Types
Lesson 1: Declare and initialize variables (including casting of primitive data types)
1.1: Using the general form of simple declarations
1.2: Using the general form of initialized declarations
1.3: Understanding integer primitive types, literal forms
1.4: Understanding floating point primitive types, literal forms
1.5: Understanding logical and character primitive types, literal forms
1.6: Casting primitive types
Lesson 2: Differentiate between object reference variables and primitive variables
2.1: Using the == operator with primitives and references
2.2: Understanding method argument passing
Lesson 3: Know how to read or write to object fields
3.1: Selecting a field from a reference expression
3.2: Using "this" to access fields
3.3: Code examples
Lesson 4: Explain an Object's Lifecycle (creation, "dereference by reassignment" and garbage collection)
4.1: Understanding allocation and referencing
4.2: Collecting garbage
Lesson 5: Develop code that uses wrapper classes such as Boolean, Double, and Integer
5.1: Understanding and identifying wrapper objects, understanding autoboxing
5.2: Investigating the API of Integer
Module 4: Using Operators and Decision Constructs
Lesson 1: Use Java operators; including parentheses to override operator precedence
1.1: Using operators, operands, and expressions
1.2: Using arithmetic operators + - * / %
1.3: Using the plus operator with Strings
1.4: Promoting operands
1.5: Using increment and decrement operators
1.6: Using shift operators
1.7: Using comparison operators
1.8: Using logical operators
1.9: Using short-circuit operators
1.10: Using assignment operators
1.11: Understanding assignment compatibility
1.12: Understanding other elements of expressions
1.13: Using parentheses and operator precedence
Lesson 2: Test equality between Strings and other objects using == and equals ()
2.1: Understanding the meaning of == and the intended meaning of equals ()
2.2: Determining if equals() is implemented, and implementing equals()
Lesson 3: Create if and if/else and ternary constructs
3.1: Understanding the basic form of if and if/else
3.2: Using braces with if/else. Effect of "else if"
3.3: Understanding the if / else if / else structure
3.4: Using the ternary operator
Lesson 4: Use a switch statement
4.1: Using the general form of switch, case, break, and default
4.2: Code examples for the general form of switch
4.3: Understanding break
4.4: Identifying switchable types
Module 5: Creating and Using Arrays
Lesson 1: Declare, instantiate, initialize and use a one-dimensional array
1.1: Understanding simple array declarations, and variables of array type
1.2: Instantiating an array, array length
1.3: Initializing arrays by iteration, array indexes
1.4: Using a combined declaration and initialization of arrays
1.5: Using immediate array creation not in a declaration
1.6: Initializing arrays by copying
Lesson 2: Declare, instantiate, initialize and use multi-dimensional array
2.1: Declaring multi-dimensional arrays
2.2: Using immediate initialization of multi-dimensional arrays
2.3: Using iterative initialization of multi-dimensional arrays
2.4: Code examples for multi-dimensional arrays
Module 6: Using Loop Constructs
Lesson 1: Create and use while loops
1.1: Creating and using while loops
1.2: Code examples of the while loop
Lesson 2: Create and use for loops including the enhanced for loop
2.1: Understanding the simple use of the for loop
2.2: Understanding the initialization section of the for loop
2.3: Understanding the test section of the for loop
2.4: Understanding the increment section of the for loop
2.5: Omitting sections of a for loop
2.6: Code examples for basic for loops
2.7: Understanding the simple use of the enhanced for loop
2.8: Identifying the valid targets of the enhanced for loop
2.9: Using the enhanced for loop with generic collections
2.10: Code examples for enhanced for loops
Lesson 3: Create and use do/while loops
3.1: Creating and using do/while loops
Lesson 4: Compare loop constructs
4.1: Comparing while and do while loops
4.2: Comparing while and simple for loops
4.3: Comparing while and enhanced for loops working on Iterables
4.4: Comparing while and enhanced for loops working on arrays
Lesson 5: Use break and continue
5.1: Using break from a single loop
5.2: Using continue in a single loop
5.3: Using a labeled break from multiple loops
5.4: Using a labeled continue from multiple loops
Module 7: Working with Methods and Encapsulation
Lesson 1: Create methods with arguments and return values including overloaded methods
1.1: Creating Methods
1.2: Code example for simple methods
1.3: Understanding basic syntax of overloaded methods
1.4: Understanding rules and guidance for using overloaded methods
1.5: Code example for overloaded methods
1.6: Investigating variable length argument lists
Lesson 2: Apply the static keyword to methods and fields
2.1: Comparing class fields and object fields
2.2: Using static on methods
2.3: Code example
Lesson 3: Create and overload constructors; including impact on default constructors
3.1: Creating and overloading constructors
3.2: Differentiating between default and user defined constructors
Lesson 4: Apply access modifiers
4.1: Using the access modifiers public and private
4.2: Using default access and the protected modifier
Lesson 5: Apply encapsulation principles to a class
5.1: Designing for encapsulation
5.2: Implementing encapsulation
Lesson 6: Determine the effect upon object references and primitive values when they are passed into methods that change the values
6.1: Changing values through method local variables
6.2: Changing the value of method local variables
6.3: Code example
Module 8: Working with Inheritance
Lesson 1: Describe inheritance and its benefits
1.1: Understanding interface and implementation inheritance
1.2: Basic coding of implementation inheritance
1.3: Changing inherited behavior
1.4: Code examples
1.5: Philosophy and terminology of inheritance (Part 1)
1.6: Philosophy and terminology of inheritance (Part 2)
Lesson 2: Develop code that demonstrates the use of polymorphism
2.1: Understanding the concepts of polymorphism
2.2: Code example
2.3: Understanding the core terminology of polymorphism
2.4: Understanding variable type and object type
2.5: Determining object type
2.6: Code examples
Lesson 3: Determine when casting is necessary
3.1: Understanding the Liskov substitution principle and the "is a" relationship
3.2: Recognizing impossible assignments
3.3: Understanding casting with interface types in assignments
Lesson 4: Use super and this to access objects and constructors
4.1: Understanding "this" for accessing object features
4.2: Understanding "super" for accessing parent features
4.3: Understanding "this()" for accessing overloaded constructors
4.4: Understanding "super()" for accessing parent constructors
4.5: Understanding the underlying principles of "this" and "super" for invoking other constructors
4.6: Code examples
Lesson 5: Use abstract classes and interfaces
5.1: Preventing instantiation
5.2: Marking behaviors abstract
5.3: Understanding the rules about abstract classes and methods
5.4: Understanding and defining interfaces
5.5: Implementing and using interfaces
5.6: Code example for interfaces
5.7: Understanding the rules about interfaces
5.8: Understanding static and default methods
Module 9: Handling Exceptions
Lesson 1: Differentiate among checked exceptions, RuntimeExceptions and Errors
1.1: Understanding exception types
Lesson 2: Create a try-catch block and determine how exceptions alter normal program flow
2.1: Coding try and catch
2.2: Passing an exception to our caller
2.3: Using finally to clean up resources
2.4: Using the try with resources mechanism
2.5: Code example for try / catch / finally
2.6: Code example for try with resources
Lesson 3: Describe the advantages of Exception handling
3.1: Investigating the philosophy of the exception mechanism
Lesson 4: Create and invoke a method that throws an exception
4.1: Handling exceptions thrown by called code
4.2: Code example
Lesson 5: Recognize common exception classes and categories (such as NullPointerException, ArithmenticException, ArrayIndexOutOfBoundsException, ClassCastException)
5.1: Common Exception Classes
Module 10: Working with Selected Classes from the Java API
Lesson 1: Manipulate data using the StringBuilder class and its methods
1.1: Understanding the common StringBuilder constructors
1.2: Using methods that modify StringBuilders
1.3 Using methods that read and search in StringBuilders, and using methods that interact with the internal storage of StringBuilders
Lesson 2: Creating and manipulating Strings
2.1: Creating Strings
2.2: Understanding common String methods: Immutability
2.3: Using common String methods
2.4: Using common String methods to perform comparisons
Lesson 3: Create and manipulate calendar data using...
3.1: Creating Time and Date Objects
3.2: Changing Times and Dates
3.3: Using the DateTimeFormatter
3.4: Comparing and Ordering Times and Dates, and Using the Period class
Lesson 4: Declare and use an ArrayList of a given type
4.1: Understanding the purpose and benefits of ArrayList
4.2: Declaring and initializing an ArrayList
4.3: Using common methods of, and uses of, ArrayList
4.4: Investigating documentation and code for ArrayList
4.5: Understanding simple generics with the ArrayList
Lesson 5: Write a simple Lambda expression that consumes a Lambda Predicate expression
5.1: Understanding the Predicate interface
5.2: Creating Lambda expressions for Predicates
5.3: Reviewing the rules for Lambda expressions
Summary
======================================================================
This DVDs are only suitable for a PC/laptop/Mac; it WILL NOT play on a TV
This DVDs are only suitable for a PC/laptop/Mac; it WILL NOT play on a TV
======================================================================
