Programma Certificazione Oracle OCA Oracle Certified Associate, Java SE

Java Building Blocks

  • Understanding the Java Class Structure
    • Fields and Methods
    • Comments
    • Classes vs. Files
  • Writing a main() Method
  • Understanding Package Declarations and Imports
    • Wildcards
    • Redundant Imports
    • Naming Conflicts
    • Creating a New Package
    • Code Formatting on the Exam
  • Creating Objects
    • Constructors
    • Reading and Writing Object Fields
    • Instance Initializer Blocks
    • Order of Initialization
  • Distinguishing Between Object References and Primitives
  • Primitive Types
  • Reference Types
  • Key Differences
  • Declaring and Initializing Variables
    • Declaring Multiple Variables
  • Identifiers
  • Understanding Default Initialization of Variables
    • Local Variables
    • Instance and Class Variables
  • Understanding Variable Scope
  • Ordering Elements in a Class
  • Destroying Objects
    • Garbage Collection
    • finalize()
  • Benefits of Java
  • Operators and Statements

    • Understanding Java Operators
    • Working with Binary Arithmetic Operators
      • Arithmetic Operators
      • Numeric Promotion
  • Working with Unary Operators
    • Logical Complement and Negation Operators
    • Increment and Decrement Operators
  • Using Additional Binary Operators
    • Assignment Operators
    • Compound Assignment Operators
    • Relational Operators
    • Logical Operators
    • Equality Operators
  • Understanding Java Statements
    • The if-then Statement
    • The if-then-else Statement
    • The switch Statement
    • The while Statement
    • The do-while Statement
    • The for Statement
  • Understanding Advanced Flow Control
    • Nested Loops
    • Adding Optional Labels
    • The break Statement
    • The continue Statement
  • Core Java APIs

    • Creating and Manipulating Strings
      • Concatenation
      • Immutability
      • The String Pool
      • Important String Methods
      • Method Chaining
  • Using the StringBuilder Class
    • Mutability and Chaining
    • Creating a StringBuilder
    • Important StringBuilder Methods
    • StringBuilder vs. StringBuffer
  • Understanding Equality
  • Understanding Java Arrays
    • Creating an Array of Primitives
    • Creating an Array with Reference Variables
    • Using an Array
    • Sorting
    • Searching
    • Varargs
    • Multidimensional Arrays
  • Understanding an ArrayList
    • Creating an ArrayList
    • Using an ArrayList
    • Wrapper Classes
    • Autoboxing
    • Converting Between array and List
    • Sorting
  • Working with Dates and Times
    • Creating Dates and Times
    • Manipulating Dates and Times
    • Working with Periods
    • Formatting Dates and Times
    • Parsing Dates and Times
  • Methods and Encapsulation

    • Designing Methods
      • Optional Specifiers
      • Return Type
      • Method Name
      • Parameter List
      • Optional Exception List
      • Method Body
    • Working with Varargs
  • Applying Access Modifiers
    • Private Access
    • Default (Package Private) Access
    • Protected Access
    • Public Access
    • Designing Static Methods and Fields
    • Calling a Static Variable or Method
    • Static vs. Instance
    • Static Variables
    • Static Initialization
    • Static Imports
  • Passing Data Among Methods
  • Overloading Methods
  • Creating Constructors
    • Default Constructor
    • Overloading Constructors
    • Final Fields
    • Order of Initialization
  • Encapsulating Data
    • Creating Immutable Classes
  • Writing Simple Lambdas
    • Lambda Example
    • Lambda Syntax
    • Predicates
  • Class Design

    • Introducing Class Inheritance
      • Extending a Class
      • Applying Class Access Modifiers
      • Creating Java Objects
      • Defining Constructors
      • Calling Inherited Class Members
      • Inheriting Methods
      • Inheriting Variables
  • Creating Abstract Classes
    • Defining an Abstract Class
    • Creating a Concrete Class
    • Extending an Abstract Class
  • Implementing Interfaces
    • Defining an Interface
    • Inheriting an Interface
    • Interface Variables
    • Default Interface Methods
    • Static Interface Methods
  • Understanding Polymorphism
    • Object vs. Reference
    • Casting Objects
    • Virtual Methods
    • Polymorphic Parameters
    • Polymorphism and Method Overriding
  • Exceptions

    • Understanding Exceptions
      • The Role of Exceptions
      • Understanding Exception Types
      • Throwing an Exception
  • Using a try Statement
    • Adding a finally Block
    • Catching Various Types of Exceptions
    • Throwing a Second Exception
  • Recognizing Common Exception Types
    • Runtime Exceptions
    • Checked Exceptions
    • Errors
  • Calling Methods That Throw Exceptions
    • Subclasses
    • Printing an Exception