Duration
9 months access to the course.

Course Requirements
No knowledge is required.



Book now   

STEP 1: The payment
Choose your payment currency.

Dollars (USA): $ 735
Euros (EUROPE): € 675
Pounds (UK): £ 510




STEP 2: The beginning
When you do the payment you will receive the keys to access to the course.



Contact Us

 
 
 
  

 

OnLine Java EE Web Developer Course Syllabus

The History and Evolution of Java
   - Java's Lineage
   - The Creation of Java
   - How Java Changed the Internet
   - Java's Magic: The Bytecode
   - Servlets: Java on the Server Side
   - The Java Buzzwords
   - The Evolution of Java
   - A Culture of Innovation


An Overview of Java
   - Object-Oriented Programming
   - A First Simple Program
   - A Second Short Program
   - Two Control Statements
   - Using Blocks of Code
   - Lexical Issues
   - The Java Class Libraries


Data Types, Variables, and Arrays
   - Java Is a Strongly Typed Language
   - The Primitive Types
   - Integers
   - Floating-Point Types
   - Characters
   - Booleans
   - A Closer Look at Literals
   - Variables
   - Type Conversion and Casting
   - Automatic Type Promotion in Expressions
   - Arrays
   - A Few Words About Strings
   - A Note to C/C++ Programmers About Pointers


Operators
   - Arithmetic Operators
   - The Bitwise Operators
   - Relational Operators
   - Boolean Logical Operators
   - The Assignment Operator
   - The ? Operator
   - Operator Precedence
   - Using Parentheses


Control Statements
   - Java's Selection Statements
   - Iteration Statements
   - Jump Statements


Introducing Classes
   - Class Fundamentals
   - Declaring Objects
   - Assigning Object Reference Variables
   - Introducing Methods
   - Constructors
   - The this Keyword
   - Garbage Collection
   - The finalize() Method
   - A Stack Class


A Closer Look at Methods and Classes
   - Overloading Methods
   - Using Objects as Parameters
   - A Closer Look at Argument Passing
   - Returning Objects
   - Recursion
   - Introducing Access Control
   - Understanding static
   - Introducing final
   - Arrays Revisited
   - Introducing Nested and Inner Classes
   - Exploring the String Class
   - Using Command-Line Arguments
   - Varargs: Variable-Length Arguments


Inheritance
   - Inheritance Basics
   - Using super
   - Creating a Multilevel Hierarchy
   - When Constructors Are Called
   - Method Overriding
   - Dynamic Method Dispatch
   - Using Abstract Classes
   - Using final with Inheritance
   - The Object Class


Packages and Interfaces
   - Packages
   - Access Protection
   - Importing Packages
   - Interfaces


Exception Handling
   - Exception-Handling Fundamentals
   - Exception Types
   - Uncaught Exceptions
   - Using try and catch
   - Multiple catch Clauses
   - Nested try Statements
   - throw
   - throws
   - finally
   - Java's Built-in Exceptions
   - Creating Your Own Exception Subclasses
   - Chained Exceptions
   - Using Exceptions


Multithreaded Programming
   - The Java Thread Model
   - The Main Thread
   - Creating a Thread
   - Creating Multiple Threads
   - Using isAlive() and join()
   - Thread Priorities
   - Synchronization
   - Interthread Communication
   - Suspending, Resuming, and Stopping Threads
   - Using Multithreading


Enumerations,Autoboxing,andAnnotations(Metadata)
   - Enumerations
   - Type Wrappers
   - Autoboxing
   - Annotations (Metadata)


I/O, Applets, and Other Topics
   - I/O Basics
   - Reading Console Input
   - Writing Console Output
   - The PrintWriter Class
   - Reading and Writing Files
   - Applet Fundamentals
   - The transient and volatile Modifiers
   - Using instanceof
   - strictfp
   - Native Methods
   - Using assert
   - Static Import
   - Invoking Overloaded Constructors Through this()


Generics
   - What Are Generics?
   - A Simple Generics Example
   - A Generic Class with Two Type Parameters
   - The General Form of a Generic Class
   - Bounded Types
   - Using Wildcard Arguments
   - Creating a Generic Method
   - Generic Interfaces
   - Raw Types and Legacy Code
   - Generic Class Hierarchies
   - Erasure
   - Ambiguity Errors
   - Some Generic Restrictions
   - Final Thoughts on Generics


String Handling
   - The String Constructors
   - String Length
   - Special String Operations
   - Character Extraction
   - String Comparison
   - Searching Strings
   - Modifying a String
   - Data Conversion Using valueOf()
   - Changing the Case of Characters Within a String
   - Additional String Methods
   - StringBuffer
   - StringBuilder


Exploring java.lang
   - Primitive Type Wrappers
   - Void
   - Process
   - Runtime
   - ProcessBuilder
   - System
   - Object
   - Using clone() and the Cloneable Interface
   - Class
   - ClassLoader
   - Math
   - StrictMath
   - Compiler
   - Thread, ThreadGroup, and Runnable
   - ThreadLocal and InheritableThreadLocal
   - Package
   - RuntimePermission
   - Throwable
   - SecurityManager
   - StackTraceElement
   - Enum
   - The CharSequence Interface
   - The Comparable Interface
   - The Appendable Interface
   - The Iterable Interface
   - The Readable Interface
   - The java.lang Subpackages


java.util Part 1: The Collections Framework
   - Collections Overview
   - Recent Changes to Collections
   - The Collection Interfaces
   - The Collection Classes
   - Accessing a Collection via an Iterator
   - Storing User-Defined Classes in Collections
   - The RandomAccess Interface
   - Working with Maps
   - Comparators
   - The Collection Algorithms
   - Arrays
   - Why Generic Collections?
   - The Legacy Classes and Interfaces
   - Parting Thoughts on Collections


java.util Part 2: More Utility Classes
   - StringTokenizer
   - BitSet
   - Date
   - Calendar
   - GregorianCalendar
   - TimeZone
   - SimpleTimeZone
   - Locale
   - Random
   - Observable
   - Timer and TimerTask
   - Currency
   - Formatter
   - Scanner
   - The ResourceBundle, ListResourceBundle, and PropertyResourceBundle Classes
   - Miscellaneous Utility Classes and Interfaces
   - The java.util Subpackages


Input/Output: Exploring java.io
   - The Java I/O Classes and Interfaces
   - File
   - The Closeable and Flushable Interfaces
   - The Stream Classes
   - The Byte Streams
   - The Character Streams
   - The Console Class
   - Using Stream I/O
   - Serialization
   - Stream Benefits


Networking
   - Networking Basics
   - The Networking Classes and Interfaces
   - InetAddress
   - Inet4Address and Inet6Address
   - TCP/IPClient Sockets
   - URL
   - URLConnection
   - HttpURLConnection
   - The URI Class
   - Cookies
   - TCP/IPServer Sockets
   - Datagrams


The Applet Class
   - Two Types of Applets
   - Applet Basics
   - Applet Architecture
   - An Applet Skeleton
   - Simple Applet Display Methods
   - Requesting Repainting
   - Using the Status Window
   - The HTMLAPPLET Tag
   - Passing Parameters to Applets
   - getDocumentBase() and getCodeBase()
   - AppletContext and showDocument()
   - The AudioClip Interface
   - The AppletStub Interface
   - Outputting to the Console


Event Handling
   - Two Event Handling Mechanisms
   - The Delegation Event Model
   - Event Classes
   - Sources of Events
   - Event Listener Interfaces
   - Using the Delegation Event Model
   - Adapter Classes
   - Inner Classes


Introducing the AWT: Working with Windows, Graphics, and Text
   - AWT Classes
   - Window Fundamentals
   - Working with Frame Windows
   - Creating a Frame Window in an Applet
   - Creating a Windowed Program
   - Displaying Information Within a Window
   - Working with Graphics
   - Working with Color
   - Setting the Paint Mode
   - Working with Fonts
   - Managing Text Output Using FontMetrics


Using AWT Controls, Layout Managers, and Menus
   - Control Fundamentals
   - Labels
   - Using Buttons
   - Applying Check Boxes
   - CheckboxGroup
   - Choice Controls
   - Using Lists
   - Managing Scroll Bars
   - Using a TextField
   - Using a TextArea
   - Understanding Layout Managers
   - Menu Bars and Menus
   - Dialog Boxes
   - FileDialog
   - Handling Events by Extending AWT Components


Images
   - File Formats
   - Image Fundamentals: Creating, Loading, and Displaying
   - ImageObserver
   - Double Buffering
   - MediaTracker
   - ImageProducer
   - ImageConsumer
   - ImageFilter
   - Cell Animation
   - Additional Imaging Classes


The Concurrency Utilities
   - The Concurrent API Packages
   - Using Synchronization Objects
   - Using an Executor
   - The TimeUnit Enumeration
   - The Concurrent Collections
   - Locks
   - Atomic Operations
   - The Concurrency Utilities Versus Java's Traditional Approach


NIO, Regular Expressions, and Other Packages
   - The Core Java API Packages
   - NIO
   - Regular Expression Processing
   - Reflection
   - Remote Method Invocation (RMI)
   - Text Formatting


Java Beans
   - What Is a Java Bean?
   - Advantages of Java Beans
   - Introspection
   - Bound and Constrained Properties
   - Persistence
   - Customizers
   - The Java Beans API
   - A Bean Example


Introducing Swing
   - The Origins of Swing
   - Swing Is Built on the AWT
   - Two Key Swing Features
   - The MVC Connection
   - Components and Containers
   - The Swing Packages
   - A Simple Swing Application
   - Event Handling
   - Create a Swing Applet
   - Painting in Swing


Exploring Swing
   - JLabel and ImageIcon
   - JTextField
   - The Swing Buttons
   - JTabbedPane
   - JScrollPane
   - JList
   - JComboBox
   - Trees
   - JTable
   - Continuing Your Exploration of Swing


Servlets
   - Background
   - The Life Cycle of a Servlet
   - Using Tomcat for Servlet Development
   - A Simple Servlet
   - The Servlet API
   - The javax.servlet Package
   - Reading Servlet Parameters
   - The javax.servlet.http Package
   - Handling HTTPRequests and Responses
   - Using Cookies
   - Session Tracking


Essential servlet and JSP skills
   - A crash course in HTML
      . How to code HTML documents
         + Tools for working with HTML
         + An HTML document
         + How to code common tags
         + How to code links
         + How to code tables
         + How to include images
         + How to use a style sheet
      . How to code HTML forms
         + How to code a form
         + How to code text boxes, password boxes, and hidden fields
         + How to code buttons
         + How to code check boxes and radio buttons
         + How to code combo boxes and list boxes
         + How to code text areas
         + How to set the tab order or controls
   - How to develop JavaServer Pages
      . The Email List application
         + The user interface for the application
         + The code for the HTML page that calls the JSP
         + The code for the JSP
      . How to code a JSP
      . How to request a JSP
      . How to use regular Java classes with JSPs
      . How to use three more types of JSP tags
      . How to work with JSP errors
   - How to develop Servlets
      . The Email List application
         + The user interface for the application
         + The code for the HTML page that calls the servlet
         + The code for the servlet
         + The mapping for the servlet
      . How to code, map, and request a servlet
         + How to code a servlet
         + How to use map a servlet to a URL
         + How to request a servlet
      . More skills for working with servlets
         + The methods of a servlet
         + How to code instance variables
      . How to work with servlet errors
         + How to solve common servlet problems
         + How to print debugging data to the console
         + How to print debugging data to a log file
   - How to structure a web application with the MVC pattern
      . The Email List application
         + The code for the servlet
         + The code for the JSP
      . Two architectures for web applications
         + The Model 1 architecture
         + The Model-View-Controller (MVC) pattern
      . How to forward requests and redirect responses
      . How to validate data
      . How to include a file in a JSP
      . How to use the web.xml file
   - How to work with sessions and cookies
      . An introduction to session tracking
      . How to work with sessions
      . How to work with cookies
      . How to work with URL rewriting and hidden fields
      . The Download application
         + The user interface
         + The file structure
         + The web.xml file
         + The code for the JSPs and servlets
   - How to use standard JSP tags with JavaBeans
      . A JSP that uses a JavaBean
      . How to code JSP tags for JavaBeans
      . The Email List application with JSP tags for JavaBeans
         + The application when the MVC pattern is used
         + The application when the Model 1 architecture is used
   - How to use the JSP Expression Language (EL)
      . An introduction to JSP Expression Language
      . Essentials skills for working with EL
      . Others skills for working with EL
   - How to use the JSP Standard Tag Library (JSTL)
      . An introduction to JSTL
      . How to work with thw JSTL core library
      . The Cart application
         + The user interface
         + The code for the business classes
         + The code for the serlvets and JSPs
   - How to use custom JSP tags
      . How to code a custom tag that doesn't have a body
      . How to code a custom tag that has a body
      . How to code a custom tag that has attributes
      . How to code a custom tag that reiterates its body
      . How to work with scripting variables
      . Classes, methods, and fields for working with custom tags


Essential database skills
   - How to use MySQL as the database management system
      . An introduction to MySQL
      . How to work with the MySQL monitor
      . The SQL statements for data manipulation
   - How to use JDBC to work with a database
      . How to work with JDBC
      . The SQL Gateway application
      . How to work with connection pooling
      . The Email list application


Advanced serlvet and JSP skills
   - How to use JavaMail to send email
      . An introduction to the JavaMail API
      . How to create and send an email message
      . Example classes that send an email message
   - How to use SSL to work with a secure connection
      . An introduction to SSL
      . How to configure a testing environment for SSL
      . How to work with a secure connection
   - How to restrict access to a web resource
      . An introduction to authentication
      . How to restict access to web resources
      . How to implement a security realm
      . How to allow access to authorized users
   - How to work with HTTP requests and responses
      . An introduction to HTTP
      . How to work with the request
      . How to work with the response
      . Practical skills for working with HTTP
   - How to work with listeners
      . How to use a ServletContextListener
      . How to work with other types of listeners
   - How to work with filters
      . An introduction to filters
      . How to add a filter
      . Two filter classes
      . Other skills for working with filters


Struts
   - Introduction
   - Introduction to Struts
      • Struts features
      • The Struts application controller
      • JSP action libraries
   - Creating an application with Struts
      • Initial steps: Creating the project
      • Example application for sending and receiving messages
         - Model
         - ActionForm Definition and Registration
         - The action classes
            . Implementing the action classes
            . Registering the action classes
            . Using NetBeans to create the action classes
         - Defining ActionForward objects
         - The views
   - JSP tag libraries
      • HTML library
         - Page actions
         - Graphic controls
         - Others
      • The BEAN library
      • The LOGIC library
   - Resource File
      • Resource File Contents
      • Referencing the Resource File
      • Accessing the strings defined in the Resource File
      • Multilingual applications
   - Error Handling
      • Overriding the VALIDATE() method
      • Creating ACTIONERROR objects
      • Displaying error messages


JavaServer Faces (JSF)
   - Introduction
      • JSF features
   - Components of a JSF application
      • FACES-CONFIG.XML Configuration file
      • FACESSERVLET servlet
      • Managed beans
      • Application context. The FACESCONTEXT class
      • JSP actions
   - Creating your first JSF application
      • Creating the application structure
      • Implementing the model
      • Creating and registering managed beans
      • Implementing action controllers
      • Defining the navigation rules
      • Creating the views
   - Action events
      • Lifecycle of the processing of a JSF request
      • Restore view
      • Apply request values
      • Process validation
      • Update model values
      • Invoke application
      • Render response
   - JSF graphic components
      • Renderization
      • JSF component tags
         - Form
         - Controls: Common attributes.
         - Text fields
         - Command controls
         - Static text
         - Checkboxes
         - Single-selection lists
            . List components
         - Multiple-selection lists
      • The VALUECHANGEEVENT event
   - Converters and validators
      • Validators
         - Automatic validation
         - Implicit JSF validators
         - Custom validators
      • Converters
         - Implicit JSF converters


AJAX
   - Ajax Basics
      • Ajax to the rescue
      • How Ajax works
      • Ajax Technologies
      • How to build an Ajax Application
         - Creating the XMLHTTPREQUEST object
         - Preparing the request
         - Sending the request
         - Manipulating the response
      • Sending data to the server using post
   - Manipulating documents using DOM
      • DOM basics
      • DOM interfaces
      • Accessing the contents of an XML document
      • Accessing the contents of an XHTML document
      • Manipulating the structure of a document
         - Creating new elements
   - Best practice for building Ajax Applications
      • Guarantee cross browser compatibility
      • Encapsulating the functionality of the XMLHTTPREQUEST object
      • Error control
   - JSON data format
      • Creating a JSON object
      • Interpreting JSON strings
   - Freeware utilities
      • The PROTOTYPE library
         - The AJAX.REQUEST object
         - The AJAX.UPDATER object
         - The AJAX.PERIODICALUPDATER object
         - PROTOTYPE functions
      • The DOJO toolkit
         - The DOJO.IO.BIND() function
         - Modifying the page contents
         - Sending the request parameters
         - Error control
   - Direct Web Remoting (DWR)
      • How DWR works
      • The DWR toolkit
      • Building a DWR application
         - The server layer
            + Creating the server classes
            + Configuring the application
         - The client layer
            + Reference to the client’s files
            + Implementing the client code
      • DWR JavaScript Functions
      • Converters


Enterprise Java Beans
   - Introduction
   - Enterprise JavaBeans Basics
      • Definition of an EJB
      • Enterprise Services
      • EJB Containers
      • The EJB 3.0 Specification
      • Structure of an EJB
      • Types of EJB
         - Stateless Session Beans
         - Stateful Session Beans
         - Message Driven Beans
   - Implementating an EJB
      • Implementating a Stateless Session Bean
         - Implementating an EJB using NetBeans
         - Creating an EJB client application
      • Implementating a Stateful Session Bean
         - Creating the EJB
         - A Stateful Session Bean Client application
         - Accessing an EJB with JNDI
         - References
      • Lifecycle of a Session Bean
         - PostConstruct and PreDestroy calls
         - Passivation: PrePassivate and PostActivate methods
         - Eliminating Instances of a Stateful Session Beans
      • Message Driven Beans
         - Creating the EJB
            . Using the NetBeans IDE
         - Creating a client application


Hibernate
   - Introduction
   - Hibernate components
   - Hibernate architecture
   - Creating an Hibernate Application
      • Creating entities
      • Configuration files
         - ORM configuration files
         - The HIBERNATE.CFG.XML configuration file
      • Using the Hibernate API
         - The Session Object
            . Creating a configuration object
            . Obtaining a SESSIONFACTORY object
            . Creating the Session Object
         - Operations with entities: Session Object Methods
         - Transactions
   - Using Hibernate with Netbeans
   - Queries and HQL
      • HQL
         - Basic syntax
         - Joins
      • HQL queries: the query interface
         - Creating a query object
         - Executing a query
   - Relationships between entities
      • Types of relationship
      • Mapping relationships
         - One to many and many to one relationships
   - Composite keys
      • Relationships between entities with composite keys


Web Services
   - SOA Architecture and Web Services
      • What is Service Oriented Architecture (SOA)?
      • Concept of a Web Service
      • Applications and situations for using Web Services
      • Structure of a Web Service
   - Web Service Technologies
      • Base technologies: HTTP and XML
      • The SOAP protocol
      • Describing Web Services with WSDL
      • Publishing Web Services with UDDI
   - Implementing Web services
      • Structure of a Java EE Web Service
      • JAX-WS Web Services
      • Creating a Web Service from a Java Bean
      • Creation and deployment of a Web Service using NetBeans
      • Testing a Web Service
   - Web Service Client applications
      • Interoperability of Web Services
      • Use of proxy classes
      • Creating a proxy from a WSDL document
      • Implementing a Java client with NetBeans
      • Creating a complete Web application based on the use of Web services