LOGO For Immediate Assistance Call 855-211-9361

Open Enrollment

Java Web Developer (900)

Price: $1,750.00

Call for availability 855-211-9361

In this course, you will learn the fundamentals of Java, including language structures, OO concepts, and a sampling of tools, and you will get in-depth coverage of JavaServer Pages (JSP), including working with user data, and architectural considerations such as the use of JavaBeans. You will examine in detail the Java Database Connectivity (JDBC) API (across any RDBMS) and the APIs for XML processing.

Course Overview

By the end of the class students will be able to:

  • Run and compile Java programs
  • Understand data types, language constructs, and flow control
  • Understand classes and objects, and inheritance
  • Use the JavaServer Pages environment to create dynamic pages and work with user data
  • Use JavaBeans in your JSPs
  • Manage state in web applications using the sessions and cookies
  • Use JDBC to connect to and modify databases
  • Use XML to transform data for web pages
  • Fundamentals of JSTL and EL
  • Work with Regular Expressions in Java
  • Debug JSP applications

Prerequisites

Prior programming experience in at least one object-oriented language such as a .NET language (e.g., C#, VB.NET), Java, C++, or SmallTalk, or significant programming experience in a modern language such as MS Visual Basic.

Course Outline

  • Introducing Java and JavaServer Pages

    • Source File Structure
    • In which environments does Java run?
    • What types of programs is Java used to write?
    • Java File Types
    • What Servlets Are
    • What software do I need in order to run JSP applications?
    • What does the J2EE framework include?
    • What happens the first time a JSP file is executed?
    • Example: Examining a Simple JSP (simpledate.jsp)
    • Directives with <%@ %>
    • Using <% ... %>, <%! ...%>, and <%= some expression %>
    • JSPs: The Inside Out Servlet
    • Example: Examining a JSP that Uses Scriptlets (simplefor.jsp)
    • Embedding Scriptlets with <% %>
    • Java Operators
    • Implicit Objects
    • Example: Another Way to Embed Scriptlets (simplefor2.jsp)
    • Primer on Classes, Objects, and Packages
      • Packages
      • Importing a Package
      • Instantiating an Object or Variable
      • Assigning to Primitive Variables
      • Separating Variable Declarations and Assignments
    • Comments
      • < !-- HTML Comment -->
      • // Single-line Java Comment
      • /* Multi-line Java Comment */
    • Lab: Completing a JSP that Generates a Formatted Date
  • The Java Platform

    • A Little History
      • The Original Java: An Internet Language
      • The Java Community Process
    • The Java Editions
  • Java: Conditionals

    • The if Statement
      • if
      • else
      • else if
    • Example: Implementing a Conditional (ifdemo.jsp)
    • Example: Conditional in JSP (ifdemo2.jsp )
  • JSP: Processing Form Input

    • Example: The Request Object (simplegetform.html and simple getresponse.jsp)
    • Lab: Processing a Form Submission
    • Example: Combining the Form and Processing Code Together
      • HTML Primer: Omitting the Action from the <form> Tag
      • Java Primer: Testing Strings for Equal Values Using the equals() Method
    • Lab: Combining Your Form and Processing Code into a Single File
    • Processing Form Inputs with Multiple Parameters
    • Example: request.getParameterValues()
    • Retrieving All Form Parameters
    • Example: request.getParameterNames()
    • Lab: Processing Multiple Form Values
  • JSP: Forwards and Includes

    • The <jsp:forward> Action
      • Example: Automatic JSP Forwarding (simpleForward.jsp)
    • Conditional Forwarding
      • Example: Conditional Forwarding (ifValidForm.jsp)
    • A Preprocessed Include
      • Example: Including a Standard Footer (welcomeWithFooter.jsp)
    • Dynamic Includes Using <jsp:include>
      • Example: Dynamically Including a Header (welcomeWithHeader.jsp)
    • Lab: Number Guessing
  • Java: Data, Operators, and Variables

    • Variables in Java
      • Strong Typing in Java
      • Data Types in Java
      • Variable Names
      • Declaring a Variable
    • Value and Reference Types
      • Positioning Variable Declarations in Code
    • Boolean Data Types
      • Boolean Literals
    • Numeric Data Types
      • Numeric Literals
    • Character Data
      • Character Literals
    • Strings
  • JSP: Type Casting Operations on Form Data

    • Number Classes vs. Primitive Numeric Types
    • Converting from a Numeric Object to a Primitive
    • Casting Among Primitive Numeric Types
    • Instance Methods vs. Static (Class) Methods
      • Instance Method Example
      • Static Method Example
    • Using the parseXXX() Static Methods to Convert Strings to Primitive Numerics
    • Example: Totaling an Order from the User
    • Lab: Totaling a User's Order
  • JSP: Exceptions and Basic Form Validation

    • Example: Ignoring Bad Numeric Input (add.html)
    • Basic Validation using Exception Handling
      • Try-Catch-Finally Block
      • Exceptions as Objects
    • Example: Validating Bad Numeric Input (add2.html)
    • A Note on Finally
    • Lab: Handling Basic Validation using Exception Handling
  • JSP: Error Trapping

    • Page Level: The errorPage and isErrorPage Attributes
      • Example: Pagel-Level Error Handling
    • Lab: Handling Basic Validation using Error Pages
    • Application Level Trapping: web.xml
    • Example: Setting Error Pages by Using web.xml
    • Lab: Trapping Internal Errors
  • Java: Control Structures

    • The Switch Statement
      • Statements, Expressions, and Blocks
      • Blocks
      • Blocks and Variable Scope
    • The Tertiary Conditional Operator
    • Loops in Java
      • while Loops
      • do-while Loops
    • Arrays
      • for Loops with Arrays
      • The Structure of a for Loop
    • The break Statement
    • The continue Statement
    • Methods
      • Return Value of a Method
    • Returning from a Method
  • JSP: State Management

  • JSP: Cookies

    • Example: Cookies (CookieDemo.jsp)
    • Setting a Cookie
    • Retrieving a Cookie Value
    • Generating Output Based on the Cookie Value
    • Comparing Strings
    • Clearing Cookies
    • Lab: Setting Persistent User Preferences Using Cookies
  • JSP: Session

    • Example: Simple Session Values (sessionDemo.jsp)
    • Retrieving Session Data
    • Integer Objects, int Primitives, and toString()
    • Converting Strings to ints
    • Setting Session Data with session.setAttribute()
    • Retrieving the Session ID
    • Clearing the Session Variable
    • Lab: Working with the Session Object
  • JSP: Request and Page Attributes

    • Example: Request Scope with a Forward
    • Lab: Using a Request Attribute in a Header
  • Java: Classes and Inheritance

    • Introduction to Object-Oriented Concepts
      • Why do we need object-oriented programming?
    • Classes are Templates
      • Members
      • Class Members vs. Object Members
    • Objects are Instantiated from Classes
      • To Instantiate an Object, Call the Class's Constructor
    • Classes Inheritance
    • Relevance for Java Server Pages
      • Creating Classes and Instances of Them
  • Session Variables

    • Retrieving the session data: session.getAttribute()
    • Casting via the () Operator
    • Converting Strings to integers: Integer.parseInt()
    • Setting the Sesion data: session.setAttribute()
    • Retrieving the Session id: session.getId()
    • Clearing the Session Variables with session.invalidate()
    • Lab: Working with the Session Object
  • Java: Introducing JavaBeans

    • What are JavaBeans?
    • What distinguishes JavaBeans from Java Classes?
    • Examining our First Bean
    • Serializable and Star Trek
    • Motivation
    • No Argument Constructor
    • Getting and Setting Properties
  • JSP: Integrating JavaBeans

    • Example: Bean Demo
    • What does ID mean?
    • What does the class mean ?
    • Where are JavaBeans stored?
    • The Programming Approach to Reading and Writing to Bean Parameters
    • Scoping Your Beans
    • The Source for SimpleDataBean
    • Labs: Using a JavaBean within a JSP
  • JSP: Assigning and Retrieving Bean Properties

    • The Script-Less Approach: <jsp:setProperty/>
      • Example: <jsp:setProperty/> (BeanSetForm.html)
    • Lab (Part A): Loading Bean Parameters using jsp:setProperty
    • Even Less Code: <jsp:setProperty/>
    • Updating Bean Properties En Masse
    • Lab (Part B): Setting Properties En Masse and Getting Properties
  • Java: Compiling Java Classes

    • Down at the Command Line!
    • : Hello World
    • Demo: Packages in Brief (SimpleDate.java)
    • Demo: Creating and Using a Class in a Package
    • Lab: Adding a Property to our SimpleDataBean
  • JSP: Exploring Bean Scope and Persistence

    • A Refresher on the Scope of your Beans
    • Compare Bean Scope to Intrinsic Object Attributes
    • Lab: Exploring Bean Persistence
  • Java: Introduction JDBC

    • Example: Generating a List from the Database
    • The Seven Steps Carried Out by Database-Driven Applications
    • Why We Declare and Intialize Objects to Null Above the Try...Catch?
      • Variable Scopes in Exception Handling
      • So, why do we initialize the variables to null?
    • Loading the Database Driver
    • Connecting to the Database
    • DSN-Less Connections
    • Assemble the SQL Statement
    • Execute the SQL Statement
    • Display the Results
    • Close the Statement and ResultSet
    • Close the Connection
    • Using context-param's in web.xml
    • Example: Displaying the Data in a Table
    • Example: Working with ResultSetMetaData
    • Lab: Using JDBC to Query a Database and Display the Results
  • JSP: Searching with Form Data

    • Example: Searching on Last Name
    • Example: Searching with Like
    • Lab: Querying Tables Based on Form Data
  • JSP: Dynamically Populate Interface

    • Demo: Search for Books by an Author
  • Java: Modifying Data with JDBC

    • Non Query Data Manipulation Operations
    • Lab: Completing a Record Insertion Application
    • Using JavaScript to Confirm Form Submissions
      • Demo: Confirm Delete
    • Lab: Updating a Record in the Database
  • Java: Invoking Stored Procedures

    • What are Stored Procedures?
    • Advantages of Stored Procedures
    • Example: Calling a Stored Procedure from JSP
    • Demo: Passing Parameters to a Stored Procedure
    • Lab: Passing Parameters to a Stored Procedure
  • Java: JDBC-Driven JavaBeans

    • Labs: Implementing a JDBC-Driven JavaBean
  • Java: Introducing XML

    • What is XML?
    • XML Logical Structure
      • Language Declaration Requirement
      • Required Single Root Element
    • XML Physical Structure
      • Case Sensitivity
      • Required Closing Tags
      • Syntax for "empty elements"
      • Tags must be Nested Properly
      • Attribute Values Must Be Enclosed Properly in Single or Double Quotes
      • XML Comments
      • Character References
      • Why Use Attributes?
    • Applications of XML (and related technologies)
      • Data Interchange Among Applications
      • Writing Applications that Generate Output in Multiple Formats
      • Defining New Markup Languages
      • Roundtrip Data Interchange Between Desktop Applications and the Web
  • Java: XSLT

    • Example: Using the Java Transformer
    • Exercise: Transform XML to HTML
  • Java: Introducing SAX

    • What is SAX ?
    • Example: Parsing a Document Using SAX
    • Using SAX to Parse XML
      • Creating a File URL
      • Getting a Parser
      • Specifying a ContentHandler
      • Specifying an ErrorHandler
      • Parsing the Document
      • Displaying Output and Errors
    • A SAX ContentHandler
      • Creating a ContentHandler: Implement or Extend
    • The Five Most Important ContentHandler Methods
    • Other Methods Specified by ContentHandler
    • Examining an Implementation of ErrorHandler
      • A Word about Creating Classes in a JSP
    • Exercise: Parsing an XML Document and Generating HTML Output with SAX
  • JSP: Introducing Java Standard Tag Library (JSTL) and Expression Language (EL)

    • The JSTL Tag Libraries
    • Expression Language
    • Analysis of the JSP Expression Language
      • Dot Operator Usage to Access Map and Property Values
      • The [ ] Operator
    • Example: Basic EL
    • Analysis of the Application
      • Registering the Tag Library
      • Creating an Array and Setting it into the Request Collection
      • Accessing the Variable using EL
      • Accessing the Variable using a Core Tag Library Loop and EL
    • Example: HTML Headers
      • Analysis of the Application
    • Example: Scoped Variables
      • Analysis of the Application
    • Example: Database Access with SQL Tags
      • Analysis of the Code
    • Example: XML Tags
      • Analysis of the Code
    • Lab: XML with JSTL
  • Java: Regular Expressions

    • Introducing Regular Expressions
    • Learning Regular Expressions the Fun Way
    • Special Characters for Pattern Matching
    • Escape Sequences for Special Characters
    • Specifying Ranges in Patterns
    • Matching a Specified Number of Occurrences
    • Character-Range Escape Sequences
    • Matching at the Beginning or End of a String with ^ and $
    • The Word-Boundary Pattern Anchors: \b and \B
    • Ignoring Case with the i Modifier
    • Regular Expressions in Action: Form Validation
      • Refresher: Methods and Declarations in JSP
      • Refresher: Importing the Package
    • The matches() Method of java.util.regex.Pattern
      • Validating the Form
    • Lab: Completing a Form Validation Application
    • Lab: Validating a More Complex Form
  • Intermediate Java: Enums

    • Example: A Simple Enum
    • Enum Class Capabilities
    • Example: An Advanced Enum Class
      • Analysis of the Code
    • Lab: Creating an Enumeration for Edition Types
  • Intermediate Java: Generics and Generic Collections

    • Example: Generic Aggregator
      • Analysis of the Code
    • Example: Strongly Typed Collection
      • Generic Iterators
    • Lab: Creating a Strongly Typed Collection for Our Classes
  • Intermediate Java: For-Each

    • Example: For-Each Over an Array
      • Analysis of the Code
    • Example: For-Each Over an ArrayList
    • Example: For-Each Over a Parameterized ArrayList
    • Lab: Using For-Each with a Strongly Typed Collection
  • Appendix A: Setup for Demos and Labs

    • Deployment
    • Demos/Labs
    • Use of JSPs and Java Code
    • Database Connectors
    • Database Login Information
  • Appendix B: Java EE Containers

    • Write Once Run Anywhere Enterprise Applications
    • Choosing a Java EE Application Server
      • Web vs. Enterprise Container
  • Appendix C: Creating an ODBC DSN

  • Appendix D: An Overview of SQ

    • Data Types in SQL
    • Creating a Table in SQL
    • Inserting a Row into the Table in SQL
    • Inserting a Partial Row (or Fields in a Different Order) in SQL
    • Retrieving Information from the Database via SELECT
      • Comparison Operators
      • Sorting Your Results using ORDER BY
      • Ensuring that the Results of a SELECT are DISTINCT
    • Editing Records in the Database with the UPDATE Statement
    • Removing Records from the Database with the DELETE Statement