Java Bootcamp Training Course
Java Bootcamp: Java 7 and OO Development – 5 Day – JAV120 Request a Class Date
Intensive and hands on, this java programming training course emphasizes provides a broad and deep introduction to Java for non-Java programmers. The course covers all the basic concepts of Object-Oriented Programming and Java 7.
Get Multi-Enrollment Discounts at Check-Out Too!
Java Bootcamp: Java 7 & OO Development – JAV120

Java Training Intensive Bootcamp
Intensive and hands on, this Java programming training course emphasizes provides a broad and deep introduction to Java for non-Java programmers. The course covers all the basic concepts of Object-Oriented Programming and Java.Included is the material and labs on all the key OO concepts, including topics like encapsulation, composition, and inheritance. This course also includes some coverage of advanced Java capabilities such as JDBC/JPA and the Collections Framework, as well as coverage and usage of many of the newer capabilities in Java 7. This course is truly the fast track to learning Java 7 and object oriented development.
There are a large number of labs, and all labs except the first are done with a development environment (e.g. Eclipse).
Training Course Delivery Options
This course is offered as a live hands-on instructor-led online or onsite training class for individuals and small groups on our public schedule. Additionally we can deliver this training course privately onsite at your location or privately online. A private training course typically makes most financial sense with about four participants. To receive a customized training proposal and quotation for a private training at your location or online, please complete the request a quote form.
Course ID: JAV120 Duration: 5 days
Audience: Programmers with exposure to Java or related languages (ie. C or C++) or programmers with entirely unrelated backgrounds.
Prerequisites:Previous programming experience in C, C++, or C#®, and some knowledge of basic object-oriented concepts are recommended.
Java Training Bootcamp Course Topics
- A Simple Application Class
- The HelloWorld Program Broken Down
- Compiling HelloWorld
- Note on Comments
Java Overview
- Language and Platform Features
- What is Java?
- Java is Modern and Object-Oriented
- Java is Portable and Safe
- Java has Multiple Platforms
- Program Life Cycle
- Java Source and Java Bytecode
- Life Cycle of a Java Program
- Java Programs Insulated from Environment
- Java is Dynamic – The Runtime Process
- The Java SE Software Development Kit (JDK)
- The Java API
- Downloading and Installing the JDK
Class and Object Basics
- Object-Oriented Programming Overview
- What is Object-Oriented Programming?
- What is an Object?
- Important Characteristics of Objects
- About Object-Oriented Programming (OOP)
- What’s a Type?
- Types, Instances, and Property Values
- Classes and Objects
- Identity and Object References
- Classes, References, and Instantiation
- The Class in Java
- Class Definition
- A Class Definition is a Blueprint
- Creating and Referencing Objects
- More About Identifiers
- Methods and Data in a Class
- Behavior and Methods
- Invoking Methods
- Storing Data in Objects
- About Instance Variables
- Data Access and Return Values in Methods
- Accessing Data (Another Way)
- Pretty Pictures
- More About Variables
- About Java Primitive Data Types
- Numeric Literals
- Non-numeric Literals
- Strings
- Primitive Types are Value Types
- Arithmetic Operations
- Primitive Type Conversion and Casting
More on Classes and Objects
- Working with Methods and Data
- Working Within Methods
- Calling Methods
- Local Variables
- The this Variable and Instance Data
- Pretty Pictures
- Overloading Methods
- Calling Overloaded Methods
- The tostring() Method
- Encapsulation and Access Control
- Encapsulation: Black Boxes
- Key Advantages of Encapsulation
- Program Correctness
- Access Control
- Access for Data Members and Methods
- Private Access
- Public Access
- Constructors
- Using Constructors
- Explicit Constructor Call
- Static or Class Members
- Declaring Static Members
- Accessing Static Members
- Accessing Data in Static Methods
- final Variables
- Odds and Ends
- Scopes and Blocks
- Assignment
- Comparison
- Null Objects
- Wrapper classes
- Reference Types as Method Parameters
- final Method Parameters
Flow of Control
- Branching Statements
- Program Execution Sequence in Java
- The Comparison Operators
- The Logical Operators
- if-else Statement
- switch Statement
- Iteration Statements
- while Statement
- do-while Statement
- for Statement
- break Statement
- continue Statement
Strings and Arrays
- String and StringBuffer/StringBuilder
- Using Strings
- Changing Strings
- Classes StringBuffer and
- StringBuilder
- Using StringBuffer and
- StringBuilder
- Regular Expressions
- Arrays
- Creating Arrays and Accessing Elements
- Array of Object References
- Array of Strings
- args Array
- Iterating Over Arrays
- varargs
Packages
- Packages Overview
- Dealing with Complexity
- Packages
- package Statement
- The Default Package
- import Statement
- Importing a Complete Package
- Importing a Single Package Member
- Using the Fully Qualified Name
- Standard Imports
- Resolving Naming Conflicts
- Creating a Package
- Access Control for Class Members
- Access Control for Classes
- Finding Classes
- Tools Must Locate Class Definitions
- Organizing Files and Packages
- Class Path
- What is a JAR?
- Composition
- Dealing with Complexity and
- Composition
- Composition
- Delegation
- Benefits of Composition
- Issues with Composition
- About Object Relationships
- Other Kinds of Relationships
- Inheritance
- Inheritance and Dealing with Complexity
- Inheritance Hierarchy
- The extends Keyword
- Inheriting from the Superclass
- Inheritance and Superclass Data Members
- A Subclass IS-A Superclass
- Accessing Superclass Members
- Constructors and Inheritance
- Final Classes
- Overriding and Polymorphism
- Changing Behavior with Method Overriding
- OO Concepts – Polymorphism
- Polymorphism
- Importance of Polymorphism
- The super keyword
- Access Control – protected Access
- Class Object
- Methods of Class Object
- Automatic Storage Management
- Abstract Classes
- Using Abstract Classes
Interfaces
- What if All You Have to Share is an Idea?
- Interface Types
- Interface Definitions
- The implements Keyword
- Interface Types – Revisited
- Extending Interfaces
- Implementing Extended Interfaces
- Interfaces are Abstract
- Data Members in Interfaces
- Implementing Multiple Interfaces
Exceptions
- Overview of Exceptions
- Exception Hierarchy
- Exception, Error, RuntimeException
- Handling Exceptions with try and catch
- Exceptions and Program Flow
- Variable Scope
- The throws Clause
- Throwing Exceptions with throw
- User-Defined Exceptions
- Multiple catch Blocks
- finally Block
- Runtime Exceptions
- Multicatch (Java7)
- Using try-with-resources
- (Java 7)
Collections and Generics
- Java Collections Framework Overview
- java.util Collection Interfaces
- Collection Interface
- Generics and Type-Safe Collections
- List and ArrayList
- List Interface
- ArrayList
- The for-each Construct
- Autoboxing and Collections of Object
- Autoboxing
- Summarizing Collections Features
- Collections of Object
- Issues with Collection of Object
- Other Collection Types
- Set Interface
- Using Sets
- Map Interface
- HashMap
- Generic HashMaps
- Creating and Using HashMap
- Iterating Through a HashMap
- Iterator
- Processing Items with an Iterator
- Iterator Interface
- What are Generics
- Declaring a Generic Class
- Summary – Basic Generics Usage
- Inheritance with Generic Types
- Assignment with Generic Types
- Wildcard Parameter Types
- Generic Methods
- The Collections Class
- Unmodifiable Wrappers
- Algorithms
Database Access with JDBC and JPA
- What is JDBC?
- JDBC Architecture
- The Fundamental JDBC API
- Common JDBC Types
- Naming Databases with URLs
- The Item Database Table
- JPA Overview
- Java Persistence API (JPA)
- JPA Architecture – High Level View
- JPA Architecture – Programming View
- Working with JPA
- Entity Classes
- MusicItem Entity Class
- Annotation Overview
- Additional MusicItem Annotations
- Mapping an Entity Class
- The Persistence Unit
- persistence.xml Structure
- The EntityManager
- Working with Transactions
- Using JPA
- Persisting a New Entity
- Updating a Persistent Instance
- Removing an Instance
- Executing a Query
Additional Language Features
- Assertions Defined
- Assertion Uses
- Assertion Non-Uses
- Assertion Syntax
- Using Assertions to Check Flow of Control
- Enabling/Disabling Assertions at Runtime
- What They Look Like at Runtime
- Type-Safe Enums
- Enumerated Types Defined
- Problems with int Enumerated Types
- The enum Keyword
- switch on enum
- for-each with enum
- Advanced enum Features
- Annotations
- The Issue
- Annotations – The Solution
- Other Java Features
- XML and Web Service Support
- Java DB
- Scripting Language Integration
- Desktop Application Improvements
- Monitoring and Management Tools
- Other Features (Java 6+)
I/O Streams
- Readers and Writers
- Overview of I/O Streams
- Character Streams
- Class Reader
- Class Writer
- Common Reader Subclasses
- Common Writer Subclasses
- Using Readers and Writers
- Path Separators
- Filter Streams
- High-Level and Low-Level Streams
- Converting between Streams & Readers/Writers
- Byte Stream Classes
- Common Stream Subclasses
- Converting Between Byte & Character Streams
- Character Stream and Byte Stream Equivalents
- Formatted Output
- Integer Format Specifiers
- Format Specifier Modifiers
- Other Format Specifiers
- New I/O (NIO) APIs
- New I/O (NIO)
- NIO Features
- Recap
- Resources
Appendix – JDBC Java Database Connectivity