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
Java Building Blocks
- 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
Java Building Blocks
- 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
Flow Control
- 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
Core Java APIs
- 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
Core Java APIs
- 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
Methods and Encapsulation
- 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
Methods and Encapsulation
- Working with Varargs
- 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
Class Design
- 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