UMBC Training Centers logo

Oracle Certified Professional Java Programmer

 

Course Description | Outline | IT Certification Bootcamps

1. The Java Environment
* Overview of Architecture
* Forms for Java Software
* J2SE, J2EE, and J2ME Platforms
* Java Virtual Machine
* The Core API
* Java Runtime Environment
* Java Developer's Kit
* Java Class Path
* Classes
* Built-In Streams and Command-Line Parameters

2. Language Fundamentals
* Source File Format
* Application Classes
* Code Grammar and Expressions
* Identifiers
* Literals
* Operators
* Calling Methods
* Variable Parameter Lists ("varargs")

3. Data Types
* Strict Type Checking
* Primitive Types
* Numeric Types
* Characters and Booleans
* Enumerations
* Type Conversion
* Formatted Output
* Object References
* Comparing and Assigning References
* Strings
* Arrays

4. Flow Control
* The main Method
* Calling and Returning from Methods
* Conditional Constructs
* Looping Constructs
* Processing Arrays
* Looping and Enumerations
* Processing Varargs
* The Flow-Control Operator
* Break and Continue
* Recursion

5. Object-Oriented Software
* Complex Systems
* Abstraction
* Classes and Objects
* Responsibilities and Collaborators
* UML
* Relationships
* Visibility

6. Classes and Objects
* Java Classes
* Constructors and Garbage Collection
* Naming Conventions and JavaBeans
* Relationships Between Classes
* Using this
* Visibility
* Packages and Imports
* Overloading Methods and Constructors
* JARs

7. Inheritance and Polymorphism in Java
* UML Specialization
* Extending Classes
* Using Derived Classes
* Type Identification
* Compile-Time and Run-Time Type
* Polymorphism
* Overriding Methods
* The @Override Annotation
* Superclass Reference

8. Using Classes Effectively
* Class Loading
* Static Members
* Statics and Non-Statics
* Static Initializers
* Static Imports
* Prohibiting Inheritance
* Costs of Object Creation
* Strings and StringBuffers
* Controlling Object Creation
* Understanding Enumerated Types
* Stateful and Behavioral Enumerations

9. Interfaces and Abstract Classes
* Separating Interface and Implementation
* UML Interfaces and Realization
* Defining Interfaces
* Implementing and Extending Interfaces
* Abstract Classes

10. Collections
* Dynamic Collections vs. Arrays
* UML Parameterized Type
* Generics
* Using Generics
* The Collections API
* The Collection<E> and List<E> Interfaces
* The ArrayList<E> and LinkedList<E> Classes
* Looping Over Collections: Iterable<E>
* Collecting Primitive Values: Auto-Boxing
* Using Wildcards with Generic Types
* Iterators and the Iterator<E> Interface
* Maps and the Map<K,V> Interface
* Sorted Collections
* The SortedSet<E> and SortedMap<K,V> Interfaces
* The Collections Class Utility
* Algorithms
* Conversion Utilities

11. Exception Handling and Logging
* Reporting and Trapping Errors
* Exception Handling
* Throwing Exceptions
* Declaring Exceptions per Method
* Catching Exceptions
* The finally Block
* Catch-and-Release
* Chaining Exceptions
* The J2SE Logging API
* Severity Levels
* Log Hierarchies

12. Inner Classes
* Passing Behavior
* Inner Classes in GUI Programming
* Named Inner Classes
* Outer Object Reference
* Static Inner Classes
* Anonymous Inner Classes

13. The Java Streams Model
* Delegation-Based Stream Model
* InputStream and OutputStream
* Media-Based Streams
* Filtering Streams
* Readers and Writers

14. Working with Files
* File Class
* Modeling Files and Directories
* File Streams
* Random-Access Files

15. Advanced Stream Techniques
* Buffering
* Data Streams
* Push-Back Parsing
* Byte-Array Streams and String Readers and Writers

16. Java Serialization
* The Challenge of Object Serialization
* Serialization API
* Serializable Interface
* ObjectInputStream and ObjectOutputStream
* The Serialization Engine
* Transient Fields
* readObject and writeObject
* Externalizable Interface

17. Automated Unit Testing with JUnit
* Automated Testing
* JUnit and Related Tools
* The @Test Annotation
* The Assert Class Utility
* Test Runners
* Lifecycle Methods

18. Generics
* Using Generics
* Type Erasure
* Type Boundaries
* Wildcards
* Generic Methods
* Strengths and Weaknesses of Generics
* Legacy Code and Generics

19. Threads
* Java Thread Model
* Creating and Running Threads
* Manipulating Thread State
* Thread Synchronization
* Volatile Fields vs. Synchronized Methods
* wait and notify
* join and sleep
* The Concurrency API
* Atomic Operations

20. Reflection
* Uses for Meta-Data
* The Reflection API
* The Class<T> Class
* The java.lang.reflect Package
* Reading Type Information
* Navigating Inheritance Trees
* Dynamic Instantiation
* Dynamic Invocation
* Reflecting on Generics

21. Annotations
* Aspect-Oriented Programming and Java
* The Annotations Model
* Annotation Types and Annotations
* Built-In Annotations
* Annotations vs. Descriptors (XML)

22. Sockets
* The OSI Reference Model
* Network Protocols
* The Socket Class
* The ServerSocket Class
* Connecting Through URL Objects
* HTTP and Other TCP Servers
* Datagram Clients and Servers
* Non-Blocking Sockets