Core Java SE 8 Application Development
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 (
- 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.
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.
- 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.
- Declare an array reference.
- Allocate an array.
- Initialize the entries in an array.
- Appreciate the extended for-loop for iterating over an array
- 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)
- 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.
- Define supertype contracts using interfaces.
- Implement concrete classes using interfaces.
- Understand what generics are
- Understand how to create generic classes
- Understand how to create generic methods
- Understand generic wildcards
- Understand how to use generics
- 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
- 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
- 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
- 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
- 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
- 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.