Core Java SE 8 Application Development

Duration: 5 days

Students who attend this course will leave the course armed with the skills they require to develop solid modern object-oriented applications written in Java, using sound coding techniques and best coding practices. Working in a hands-on environment, developers will:

  • Understand Java as a Platform and Language
  • Comprehend the Java Syntax
  • Core data types (String, Date, Calendar etc)
  • Introduce Object-oriented Programming in Java
  • Apply Inheritance and Polymorphism
  • Throwing and correct handling of Exceptions
  • Use and optionally develop Generics (classes and methods)
  • Use the Collection API
  • Learn to use Java multi-threading (including different locking mechanism)
  • Understand the concept of JavaBeans™ (and the use in frameworks)
  • Use Java I/O capabilities
  • Access database using JDBC™
  • Standard classes: Build Basic user Interfaces using Swing
  • On bespoke courses: option to replace Swing with Java Web Development instead

This five-day workshop is comprised of carefully integrated lessons and hands-on lab exercises. Each lesson in this Developer's Workshop is driven by performance-based objectives specific to the critical skills you are learning in this training -- no more, no less.

The training is comprised of approximately 60% hands-on lab and 40% lecture. Many complete "mini-projects" are laced throughout the course, designed to reinforce fundamental skills and concepts learned in the lessons. Because these lessons, labs and projects are presented in a building block fashion, students will gain a solid understanding of not only the core concepts, but also of how all pieces fit together in a complete application.

Ideally students should have a minimum of six months experience with an imperative programming language, such as Python, JavaScript, C.

Please find the course objectives below:

Contemporary Object Oriented Programming

  • List the two features contained within an object.
  • Name the OO component that provides the blueprint for creating object instances.
  • Name the OO component that provides behaviors to an object.
  • Name the term used to expose the capabilities of an object

Inheritance, Abstraction, and Polymorphism

  • Provide one benefit of encapsulation.
  • Name an example of where inheritance cannot be used in place of aggregation, and provide one clear example showing this to fail.
  • List two reasons for using inheritance.
  • Give one example of a benefit of using polymorphism.

The Java Platform

  • Understand what Java is
  • Understand the difference between the JDK and JRE
  • Understand the role of the JVM
  • Understand the development steps
  • Which Tools to use
  • Understand how to setup your (development) environment

Using the JDK

  • Use the command line compiler to compile a Java class.
  • Use the command line Java interpreter to run a Java application class.
  • Correctly set up the CLASSPATH environment variable to allow the compiler and interpreter to run correctly.

Java Syntax

  • List the Java keywords
  • List the four arithmetic operators.
  • List the three operators to increment and decrement numbers.
  • List the six comparison operators.
  • List the two logical operators.
  • Name the return type of the comparison and logical operators.
  • Use one of the increment operators to increment an integer.
  • Write a for loop that can iterate a specified number of times.

Data types

  • Declare an array reference.
  • Allocate an array.
  • Initialize the entries in an array.
  • Appreciate the extended for-loop for iterating over an array

Using Strings

  • Create an instance of the String class.
  • Test if two String objects are equal.
  • Test if two String objects are the same object.
  • Get the length of a String object.
  • Parse a String object for its token components.
  • Perform a case-insensitive equality test.
  • Build up a String object using a StringBuffer object.
  • Build up a String object using a StringBuilder object.
  • Understand the difference between the StringBuffer and StringBuilder
  • Convert between String and StringBuffer/StringBuilder.
  • Explain the java.util.Formatter class
  • Explain format specifiers, using printf
  • Use printf and String.format to format numbers and dates
  • Explain the Formattable interface

Writing classes, an introduction

  • Write a class that does not explicitly extend another class.
  • Define instance fields for a class.
  • Implement a main method to create an instance of the defined class.

Adding Methods to the Class

  • Write a class with accessor methods to read and write private instance fields.
  • Write a constructor to initialize an instance with data.
  • Write a constructor that calls other constructors of the class to benefit from code reuse.
  • Use the this keyword to distinguish local variables from instance fields.
  • Explain variable arguments (varargs)

Java™ Packages

  • Use the package keyword to define a class within a specific package.
  • Explain the effects of the four levels of accessibility.
  • Use the import keyword to declare references to classes in a specific package.
  • Use the standard type naming conventions when creating packages, classes, and methods.
  • Correctly execute a Java application class that is defined in a package.

Enums, Static Methods and Fields

  • Create static fields in a class.
  • Explain one use of static fields.
  • Create static methods in a class.
  • Explain one benefit of static fields.
  • Understand the concept of a static import
  • Appreciate enums
  • Explain how to define your own enumerations
  • Explain the syntax used to reference static fields and methods.

Specializing in a Subclass

  • Construct a class that extends another class.
  • Correctly implement equals and toString.
  • Write constructors that pass initialization data to the parent constructor as appropriate.
  • Use instanceof to verify the class type of an object reference.
  • Override subclass methods and use the super keyword to leverage behaviors in the parent.
  • Safely cast references to a more refined type.
  • Understand the concept of polymorphism
  • Use the final keyword on methods and classes to prevent overriding through subclassing.

Interfaces

  • Define supertype contracts using interfaces.
  • Implement concrete classes using interfaces.

Generics

  • Understand what generics are
  • Understand how to create generic classes
  • Understand how to create generic methods
  • Understand generic wildcards
  • Understand how to use generics

Handling Exceptions

  • Define a try/catch block that allows methods that throw exceptions to be called.
  • Correctly implement try/catch blocks for methods which throw multiple exceptions.
  • Name the exception supertype which is not checked for by the compiler.
  • Correctly implement a method which throws exceptions.
  • Correctly override a method which throws exceptions.

Throwing and Developing Exceptions

  • Understand how How to throw exceptions.
  • Define your own application exceptions.
  • Introduce the assert keyword

Collections

  • Understand the different types of collections in the Java SE
  • Understand the difference between collection interfaces and collection implementations
  • For each collection type, understand it\'s usage.
  • Use ArrayList to maintain a list of data elements.
  • Use Iterator to search elements of a collection.
  • Use methods of List to access sublists.
  • Appreciate the extended for-loop for iterating over a collections
  • Appreciate how generics ease the development of (type-safe) collection
  • Sort and shuffle elements in a list.
  • Create read-only collections from standard.
  • Understand the Comparable interface
  • Understand the proper use of the hashCode and equals methods within the Set
  • Write a Comparator to provide custom sorting.
  • Become familiar with Queue implementations
  • Introduce the EnumSet and EnumMap

Developing Threads in Java

  • Create threaded class using both Thread, Runnable and Callable
  • Start and manage threads/tasks using the Executor framework
  • Appreciate Future
  • Use and configure thread pools
  • Use thread synchronization to guarantee data integrity in a multithreaded application
  • Use object synchronization to allow multiple threads to work cooperatively on a shared set of data
  • Use the Lock API

JavaBeans

  • Understand what JavaBeans are
  • Understand how JavaBeans are used
  • Understand JavaBean features
  • List tools and frameworks that rely on the JavaBean specification
  • Introduce reflection and introspection
  • Understand BeanInfo (and the default BeanInfo)
  • Understand JavaBeans properties
  • Understand how to write JavaBeans event sources and listeners
  • Understand the different JavaBeans design patterns

Inner classes

  • Explain inner classes (static, non-static, local (method) and anonymous)
  • Explain the allowed usages of modifiers
  • Briefly explain the strictfp and volatile modifiers
  • Understand the restrictions of Local Inner classes

Java Annotations

  • Explain Metadata in Java SE 5
  • Be able to develop custom annotations
  • Introduce annotation elements (properties)
  • Declare default values for annotation elements
  • Show how annotations can be used at runtime
  • Explain package-wide annotations and the package-info.java file
  • Introduce the three standard compiler annotations
  • Explain the Deprecated, Override and SuppressWarnings annotation
  • Provides examples of the usage of annotations by other frameworks

Containers and Layout Managers

  • Create a window frame.
  • Nest panels within a frame for better layout control.
  • Create and display buttons in a panel.
  • List two component attributes that are controlled by a layout manager.
  • Set the layout manager for a container.
  • Place components in a panel using BorderLayout, GridLayout, and FlowLayout.
  • Name one advantage of each of the layout managers.
  • Create panels with titles.

Essential graphical components

  • Place text fields, text areas, and buttons in a graphical application
  • Handle action events from a button.
  • Write code within an event handler to manipulate the content of text fields and text areas.
  • Place check boxes, radio buttons, and combo boxes in a graphical application.
  • Create a combo box consisting of a list of string elements.
  • Create radio buttons in a radio button group.
  • Create a menu for a frame containing menu items, sub-menus, check boxes, and radio buttons.

Advanced Layout (optional)

  • Use GridBagLayout to create forms with properly aligning and resizing labels, text fields, and text areas.
  • Provide scroll bars for components.
  • Add multiple components to a container, separated by splitter bars.
  • Create tabbed panels that contain other components and containers.

Files and resources

  • Create a file in the file system
  • Create a directory in the file system
  • List the contents of a directory
  • List two advantages of using resources instead of files
  • Write code to use resources

Java I/O

  • Understand the purpose of Java I/O
  • Understand the overall design of this API
  • Understand the concept of a stream
  • List and explain all standard java.io classes for byte level I/O
  • Understand the performance benefits in direct buffering and using a buffering stream

Java™ JDBC™ Data Access API

  • Connect to a database using JDBC.
  • Execute a statement against a database that returns a ResultSet.
  • Extract multiple rows of data from a ResultSet, where each column value is represented as a String.
For an onsite course please contact us