JAVA - Preparatório para prova de certificação JAVA - OCA - Presencial ou Ao Vivo

Carga horária: 32hs

Objetivo: Preparar o aluno para poder tirar a certificação Java OCA 8. 

Pré-requisito: Aluno tem que ter um bom conhecimento em Java SE e Java Orientado a Objetos.

Material de apoio: http://blogedsonbelem.com.br (Blog do Professor e Diretor Edson Belém)

Próximas turmas

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 
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 
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 
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 
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 
 
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 
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