Font size:

Description:

This is a bundled training package. It contains training for each of the bundled items below:

Course Price
Java SE7 Professional: Syntax and Class Design $74.95
Java SE7 Professional: Generics, Errors, and I/O $74.95
Java SE7 Professional: File I/O, Concurrency, JDBC, and Localization $74.95
Java SE7 New Features: Java Language and Technology Enhancements $74.95
Java SE7 New Features: I/O, Network, and Desktop Enhancements $74.95

Bundle Price: $199.00
Total Savings: $175.75


Java SE7 Professional: Syntax and Class Design

Java technology applications are written in the Java Programming Language and compiled to Java bytecode. This course introduces the Java platforms, how to obtain a JDK, and commercial support options for Java SE. It describes creating simple Java classes, using Java fields, constructors, and methods, modeling business problems using Java classes, using package and import statements, testing Java classes, and creating Java subclasses. In addition, it explores access levels, override methods, overloading constructors, using the instanceof operator to compare object types, using virtual method invocation, using upward and downward casts, and overriding methods from the Object class. Designing general purpose base classes using abstract classes, constructing abstract java classes and subclasses, modeling business problems using the static and final keywords, implementing the Singleton design pattern, and distinguishing between top-level and nested classes are also covered.
  • identify the features of the Java technology
  • create simple Java classes
  • use Java fields, constructors, and methods
  • use package and import statements
  • test Java classes
  • create Java subclasses
  • use access levels
  • override methods
  • use constructors and casts in Java
  • work with abstract Java classes and subclasses
  • use the static and final keywords
  • to override methods and utilize the instanceof operator
  • apply the abstract keyword
  • apply singleton design and recognize nested classes

Java SE7 Professional: Generics, Errors, and I/O

Understanding interfaces and inheritance, collections, string processing, error handling, and I/O is vital to learning to program with Java SE 7. This course covers modeling business problems using interfaces, defining a Java interface, choosing between interface and class inheritance, extending an interface, and refactoring code to implement the DAO pattern. In addition, it explores creating a customer generic class, using the diamond operator to create an object, creating a Collection by using an old style syntax and generics, using enumerated types, as well as implementing an ArrayList, a Set, a HashMap, and a Stack using a Deque. It demonstrates how to read data from the command line, create strings using a StringBuilder, and search, parse, and replace strings by using regular expressions. It defines the purpose of Java exceptions, and explains how to use the try and throw statements and the catch, multi-catch, and finally clauses. It covers autoclosing resources with a try-with-resources statement, common exception classes and categories, creating custom exceptions, and testing invariants by using assertions. The basics of input and output in Java, reading data from and writing data to the console, using streams to read and write files, and reading and writing objects by using serialization are also covered.
  • create and implement an interface
  • recognize how to apply the DAO pattern
  • understand generics and use collections
  • sort collections with comparators
  • read data from the command line and search and parse strings
  • search, parse, and replace strings by using regular expressions
  • handle checked and unchecked exceptions
  • create custom exceptions and use assertions
  • read data from and write data to the console, and use streams to read and write files
  • write and read objects by using serialization
  • deal with exceptions
  • extend exceptions
  • use Java I/O and serialization

Java SE7 Professional: File I/O, Concurrency, JDBC, and Localization

Understanding File I/O, concurrency, how to work with data via JDBC, and localization, are crucial to getting the most out of your Java applications. This course covers using the Path class to operate on file and directory paths, using the Files class to check, delete, copy or move a file or directory, reading and changing file and directory attributes, recursively accessing a directory tree, finding a file by using the PathMatcher class, and watching a directory for changes by using WatchService. In addition, it examines operating system task scheduling, defining, creating, and managing threads, synchronizing threads for accessing shared data, identifying potential threading problems, and using the java.util.concurrent library. It explores the layout of the JDBC API, as well as connecting to a database by using a JDBC driver, submitting queries and getting results from the database, specifying JDBC driver information externally, using transactions with JDBC, using the JDBC 4.1 RowSetProvider and RowSetFactory, and using a DAO pattern to decouple data and business methods. The advantages of localizing an application, defining locales, building a resource bundle for each locale, calling a resource bundle from an application, changing the locale for a resource bundle, and formatting text for localization by using NumberFormat and DateFormat are also covered.
  • use the Path and File classes to work with files and directories
  • read and change file and directory attributes
  • perform recursive operations and use the PathMatcher and FileVisitor classes
  • create and manage threads
  • use the java.util.concurrent library and multithreading
  • connect to a database using a JDBC driver and submit queries and get results
  • use transactions with JDBC
  • use the JDBC 4.1 RowSetProvider, RowSetFactory and a Data Access Object pattern
  • create a localized application
  • use Java and JDBC with the Derby Database
  • localize Java applications

Java SE7 New Features: Java Language and Technology Enhancements

The release of Java SE 7 brings a number of new features and enhancements. This course introduces and describes these features and improvements. The course also describes the operating systems and browser support, and Java SE 7 support in NetBeans IDE 7.0.1. It explores Java language enhancements, such as using Strings in switch statements, improved integral literals, improved type inference, improved exception handling, the try-with-resources statement, and simplified varargs method invocation. Core technology enhancements, such as the JVM enhancements - support for dynamically typed languages, the garbage-first collector, and upgraded class-loader architecture - as well as concurrency and collections, and JDBC enhancements, are also covered.
  • identify the new features of JDK 7
  • use language enhancements in JDK 7
  • describe the Java Virtual Machine (JVM) enhancements in Java SE 7
  • describe the concurrency and collection enhancements in Java SE 7
  • describe the JDBC enhancements in Java SE 7
  • implement the Fork/Join framework
  • use the ThreadLocalRandom class
  • use JDBC enhancements

Java SE7 New Features: I/O, Network, and Desktop Enhancements

The release of Java SE 7 includes several I/O, network, and desktop enhancements. This course covers I/O enhancements, such as enhancements in file I/O APIs, the Path interface and the methods for manipulating a path, as well as the Files class and its methods for file operations. It also explores network enhancements, such as the new Asynchronous I/O API, working with AsychronousSocketChannel and completion handlers, AsychronousServerSocketChannel, AsynchronousFileChannel, and AsynchronousDatagramChannel. Desktop enhancements, such as the new features for Swing components and Java 2D, are also covered.
  • identify enhancements in File I/O APIs
  • work with the Path interface
  • use the Files class to work with files or directories
  • describe how to use the Files class to work with directories, links, and the File Tree
  • describe how to work with the Asynchronous I/O API and completion handlers
  • describe desktop enhancements in Java
  • use the asynchronous file channel API
  • use the JLayer and LayerUI classes
  • use formatted text fields
Register Now
Java SE 7 New Features e-learning bundle
  • Course ID:
    252601
  • Duration:
    8 hours
  • Price:
    $199