title
Please take a moment to fill out this form. We will get back to you as soon as possible.
All fields marked with an asterisk (*) are mandatory.
Introduction to Core Java Programming for OO Experienced Developers (C#, C++ etc.)
Course Description
Overview
Write Robust Java Applications with Sound Development Techniques, Improved Performance & Capabilities for Rapid AppDev.Introduction to Core Java Programming for Object Oriented (OO) Experienced Developers is a five-day, comprehensive hands-on introduction to Java training course geared for developers who have prior working knowledge of object-oriented programming languages such as C# or C++. Throughout the course, students learn the best practices for writing great object-oriented programs in Java, using sound development techniques, new improved features for better performance and new capabilities for addressing rapid application development.
This “skills-centric” course is about 50% hands-on lab and 50% lecture, designed to train attendees in core OO coding and Java development skills, coupling the most current, effective techniques with the soundest industry practices.
Objectives
- Understand not only the fundamentals of the Java language, but also its importance, uses, strengths and weaknesses
- Understand the basics of the Java language and how it relates to OO programming and the Object Model
- Learn to use Java multi-threading and exception handling features
- Understand and use classes, inheritance and polymorphism
- Understand and use collections, generics, autoboxing, and enumerations including new Java features and capabilities
- Become familiar with the concept of functional programming using Lambda Expressions
- Process large amounts of data using the Stream API introduced in Java 8
- Take advantage of the Java tooling that is available with the programming environment being used in the class Specific Java 8 features: The new Date API, Lambda Expressions, Streams, Collectors
Audience
Topics
- Java Platforms
- Lifecycle of a Java Program
- Responsibilities of JVM
- Documentation and Code Reuse
- Setting Up Environment
- Locating Class Files
- Compiling Package Classes
- Source and Class Files
- Java Applications
- Lab: Exploring MemoryViewer
- Lab: Exploring ColorPicker
- Workbench and Workspace
- Views
- Editors
- Perspectives
- Projects
- Tutorial: Working with Eclipse Photon
- Classes in Java
- Class Modifiers and Types
- Class Instance Variables
- Primitives vs. Object References
- Creating Objects
- Lab: Create a Simple Class
- Passing Parameters into Methods
- Returning a Value from a Method
- Overloaded Methods
- Constructors
- Optimizing Constructor Usage
- Lab: Create a Class with Methods
- Operators
- Comparison and Logical Operators
- Looping
- Continue and Break Statements
- The switch Statement
- The for-each() Loop
- Lab: Looping
- Lab: Language Statements
- Strings
- String Methods
- String Equality
- StringBuffer
- StringBuilder
- Lab: Fun with Strings
- Lab: Using StringBuffers and StringBuilders
- Extending a Class
- Casting
- The Object Class
- Default Constructor
- Implicit Constructor Chaining
- Lab: Creating Subclasses
- Lab: Defining the Student Subclass
- Instance vs. Local Variables: Usage Differences
- Data Types
- Default Values
- Block Scoping Rules
- Final and Static Fields
- Static Methods
- Lab: Field Test
- Arrays
- Accessing the Array
- Multidimensional Arrays
- Copying Arrays
- Variable Arguments
- Lab: Creating an Array
- Lab: Defining the Student Array
- Class Location of Packages
- The Package Keyword
- Importing Classes
- Executing Programs
- Java Naming Conventions
- Polymorphism: The Subclasses
- Upcasting vs. Downcasting
- Calling Superclass Methods From Subclass
- The final Keyword
- Lab: Salaries - Polymorphism
- Separating Capability from Implementation
- Abstract Classes
- Implementing an Interface
- Abstract Classes vs. Interfaces
- Lab: Mailable - Interfaces
- Exception Architecture
- Handling Multiple Exceptions
- Automatic Closure of Resources
- Creating Your Own Exceptions
- Throwing Exceptions
- Checked vs. Unchecked Exceptions
- Lab: Exceptions
- Wrapper Classes
- The Number Class
- Random Numbers
- Autoboxing/Unboxing
- The Date Class
- Lab: Using Primitive Wrappers
- Enumeration Syntax
- When You Should Use Enumerations
- Using Static Imports
- When You Should Use Static Imports
- Lab: Enumerations
- Introduce the new Date/Time API
- LocalDate, LocalDateTime, etc.
- Formatting Dates
- Working with time zones
- Manipulate date/time values
- Lab: Agenda
- Generics and Subtyping
- Bounded Wildcards
- Generic Methods
- Legacy Calls To Generics
- When Generics Should Be Used
- Lab: DynamicArray
- Lab: Adding Generics to Dynamic Array
- Characterizing Collections
- Collection Interface Hierarchy
- Iterators
- The Set Interface
- The List Interface
- Queue Interface
- Map Interfaces
- Using the Right Collection
- Collections and Multithreading
- Lab: Using Hashtable and HashMap
- Lab: Collections Poker
- Lab: Writing a Collection
- Functional vs OO Programming
- Anonymous Inner-classes
- Lambda Expression Syntax
- Functional Interfaces
- Method references
- Constructor references
- Introduce the ConcurrentHashMap
- Lambda expressions and Collections
- Lab: Functional Collections
- Processing Collections of data
- The Stream interface
- Reduction and Parallelism
- Filtering collection data
- Sorting Collection data
- Map collection data
- Find elements in Stream
- Numeric Streams
- Create infinite Streams
- Sources for using Streams
- Lab: Working with Streams
- Creating Collections from a Stream
- Group elements in the Stream
- Multi-level grouping of elements
- Partitioning Streams
- Lab: Collecting
- Principles of Multithreading
- Creating a Threaded Class
- Basic Features of the Thread Class
- Thread Scheduling
- Thread Synchronization
- Lab: Simple Thread Class
- Lab: Simple Runnable Class
- Concurrent Locks are Explicit and Flexible
- Executor Interfaces Provide Thread Management
- Challenges for Concurrent Use of Collections
- Concurrent Collections
- Atomic Variables Avoid Synchronization
- Lab: Working with Concurrent Java
- Lab: Sleeping Threads
- Lab: Safe Data Access
- Lab: Producer/Consumer
- Annotations Overview
- Working with Java Annotations
- Lab: Annotations
- Lab: Using Annotations
- Connecting to the Database
- Statement and PreparedStatement
- ResultSet
- Executing Inserts, Updates, and Deletes
- Controlling Transactions and Concurrency
- Tutorial: Setup The Derby Database
- Lab: Reading Table Data
- Lab: Using JdbcRowSet
- Lab: Executing within a Transaction
- Additional Topics: Time Permitting
- StringJoiner
- String.format
- System.out.printf
- The Formatter class
- Using the formatting syntax
- The common thread pool
- Atomic variables
- LongAdder and LongAccumulator
- CompletableFuture
- Non-blocking asynchronous tasks
- Lab: CompletableFuture
Related Courses
-
Securing Web Applications | 2021 OWASP Top Ten and Beyond (Language Neutral)
WDSE-120- Duration: 2 Days
- Delivery Format: Classroom Training
- Price: 1,400.00 USD
-
Secure Java Web Application Development
TT8120-J- Duration: 2 Days
- Delivery Format: Classroom Training, Online Training
- Price: 1,400.00 USD
Self-Paced Training Info
Learn at your own pace with anytime, anywhere training
- Same in-demand topics as instructor-led public and private classes.
- Standalone learning or supplemental reinforcement.
- e-Learning content varies by course and technology.
- View the Self-Paced version of this outline and what is included in the SPVC course.
- Learn more about e-Learning
Course Added To Shopping Cart
bla
bla
bla
bla
bla
bla
Self-Paced Training Terms & Conditions
Exam Terms & Conditions
Sorry, there are no classes that meet your criteria.
Please contact us to schedule a class.
STOP! Before You Leave
Save 0% on this course!
Take advantage of our online-only offer & save 0% on any course !
Promo Code skip0 will be applied to your registration
Purchase Information
title
Please take a moment to fill out this form. We will get back to you as soon as possible.
All fields marked with an asterisk (*) are mandatory.