Java Online Training is offered by PRO IT Online Training. The training will provided by Real Time Professionals.

1. J2SE AND J2EE COURSE CONTENT
 Getting Started with J2SE
 What is Java?
 How to Get Java
 A First Java Program
 Compiling and Interpreting Applications
 The JDK Directory Structure
 Language Fundamentals
 A Java Program
 If Statements
 Switch Statements
 Loop Statements
 Syntax Details
 Primitive Data types
 Variables
 Expressions in Java
 Strings
 Arrays
 Enhanced for Loop
 Objects and Classes
 Defining a Class
 Creating an Object
 Instance Data and Class Data
 Methods
 Constructors
 Access Modifiers
 Encapsulation
 Inheritance
 Inheritance
 Inheritance in Java
 Method Overriding
 Polymorphism
 Abstract Classes
 Interfaces
 Wrapper Classes

2.  Packages
 Creating Package
 The import Statement
 Package scope
 Exception Handling
 Exceptions Overview
 Catching Exceptions
 The finally Block
 Exception Methods
 Declaring Exceptions
 Defining and Throwing Exceptions
 Errors and Runtime Exceptions
 Input and Output Streams(java.io)
 Overview of Streams
 Bytes vs. Characters
 Converting Byte Streams to Character Streams
 File Object
 Binary Input and Output
 Print Writer Class
 Reading and Writing Objects
 Basic and Filtered Streams?
 Collections(java.util)
 Binary Input and Output
 Print Writer Class
 Reading and Writing Objects
 Basic and Filtered Streams?
 Tuning Hash Map and Hash Set
 Queue Implementation Classes Sorting with Comparable
 Sorting with Comparator
 Sorting Lists and Arrays
 Collections Utility Methods
 Tuning Array List

3.  Introduction to Threads
 Non-Threaded Applications
 Threaded Applications
 Creating Threads
 Thread States
 Runnable Threads
 Coordinating Threads
 Interrupting Threads
 Runnable Interface
 Thread Groups
 Thread Synchronization and Concurrency
 Race Conditions
 Synchronized Methods
 Deadlocks
 Synchronized Blocks
 Thread Communication — wait()
 Thread Communication — notify()
 Introduction to AWT(java.awt)
 GUI Programming in Java
 AWT Events and Layout Managers
 The Java Event Delegation Model
 Action Events
 List Selection Events
 Mouse Events
 Layout Managers
 Border Layout

4.  Flow Layout
 Grid Layout AWT
 Displaying a Window
 Handling Events
 Arranging Components
 A Scrollable Component
 Menus
 Introduction to JDBC(Using oracle 9i)(java.sql)
 The JDBC different Drivers
 JDBC Connectivity Model Connecting to the Database
 Creating a SQL Query
 Getting the Results
 Updating Database Data
 Finishing Up JDBC SQL Programming
 Error Checking and the SQLException Class
 Executing SQL Queries
 ResultSetMetaData
 Executing SQL Updates
 Using Prepared Statement ,Statements
 Parameterized Statements
 RMI (Remote method Invocation)(java.rmi)
 Architechture
 Rmi Simple Program and jdbc Programs

5.  Introduction to J2EE
 J2SE Building Blocks
 Servlets(using Tomcat server)
 What Is a Servlet?
 The Example Servlets
 Servlet Life Cycle
 Handling Servlet Life-Cycle Events
 Handling Errors
 Accessing Databases
 Initializing a Servlet
 Writing Service Methods
 Getting Information from Requests
 Constructing Responses
 Filtering Requests and Responses
 Programming Filters
 Session Tracking
 Cookies
 JSPs(Using Tomcat server)
 JSP action tags - jsp:useBean, jsp:setProperty and jsp:getProperty
 RequestDispatcher - forward and include
 jsp:forward and jsp:include
 jsp:include vs include directive
 Error Page forwarding via JSP
 Expression Language (EL)
 Operators, keywords, implicit objects
 Understanding pageContext implicit object

6.  Write an EL function
 JSTL Tags - Core tags, Formatting Tags, Function Tags
 Write a SimpleTag
 Springs
1. Overview
 Introduction to Spring Framework
 Spring Modules
 Controlling Object Creation
 Persistence Support
 Aspect-Oriented Programming
 Web Applications
 Integrating Other Frameworks
 Component-Based Software
 The Factory Pattern
 Inversion of Control
 XML View: Declaring Beans
 Java View: Using Beans
 Singletons and Prototypes
 Initializing Bean State
 Dependency Injection
 Dependency Injection
 Single and Multiple Relationships
 The Utility Schema
 Autowiring
 Bean Aliases
 Order of Instantiation
 Validation
 Validators
 The Errors Object
 ValidationUtils
 Error Messages and Localization

7.  Nested Property Paths
 Spring MVC
 Servlets and JSPs: What's Missing
 The MVC Pattern
 The Front Controller Pattern
 DispatcherServlet
 Request/Response Cycle
 Strategy Pattern
 JavaBeans as Web Components
 Web Application Contexts
 Handler Mappings
 "Creating" a Model
 View Resolvers
 Customizing Spring MVC
 HandlerMapping Options
 ViewResolver Options
 Chaining View Resolvers
 Triggering Redirects
 Controllers and Commands
 Working with Forms
 Command Objects
 Template Method Pattern
 Command Controllers
 Data Binding
 MultiActionController
 Scope and Granularity of Command Objects
 Web Binding and Validation
 Property Editors
 Custom Property Editors
 Registrars

8.  Validating Form Input
 Form Controllers
 Form Controllers
 AbstractFormController
 SimpleFormController
 Spring Custom Tags
 <form:form> and Friends
 <form:errors>
 Reporting Errors
 Refining the Handling
 Intercepting Filter Pattern
 Exception Handling
 Interceptors
 Decorator Pattern
 Context and Lifecycle
 Awareness Interfaces
 Support and Utility Classes
 "Death By XML"
 Persistence Tier
 DAO Pattern
 DaoSupport Hierarchy
 The DataAccessException Hierarchy
 JDBC DAOs
 JdbcTemplate and RowMapper
 Object/Relational Mapping
 Hibernate® DAOs
 Transaction Control
 AOP vs. Annotations
 Hibernate
Introduction to Hibernate
 Benefits of Hibernate as ORM Framework

9.  Architecture of Hibernate Framework
 Understanding Persistence lifecycle
 Getting started with Hibernate ORM quickly
 Mapping tables to beans
 Mapping propertied to columns
 Setting up the user POJO object
 Create a simple CRUD Application using Hibernate ORM
 Relationships
 Simple Association (one to one)
 Basic Collection mapping (one-to-many)
 Simple unidirectional mapping (many-to-one)
 Collection (many to many)
 Examples: Setting up one to one, one-to-many, many-to-one and many-to-one
relationship
 Basic Queries
 Working with queries
 Named queries
 Examples: Using queries and named queries
 Transaction Support
 Local transaction, global transaction
 Transaction API
 Isolation levels
 Examples: Using Transaction API
 Locking Examples
 Examples: Implementing optimistic locking with versioning
 More mapping concepts
 Type system
 Mapping collections of value types
 Three ways to map inheritance
 Examples: Re-implementing roles as a typed collection
 Examples: Re-implementing Employee as a separate table

10.  Working with compound keys
 Examples: Working with compound keys
 Advanced Queries
 Working with the Query API
 Working with Binding Parameters
 Grouping
 Sub-queries
 Optimizing queries
 Native SQL queries
 Examples: Using advanced query support
 Examples: Using native SQL query support
 Spring support for ORM and Hibernate ORM Framework
 Spring Introduction
 How spring simplifies Hibernate ORM framework development
 Using Hibernate Template
 Using spring DAO support
 Using spring's transaction support
 Using spring DAOs
 Using declarative transactions
 Examples: Spring DAO Injection
 Caching Support
 Caching Overview
 Caching Architecture
 API to control cache
 Working with EHCache
 Struts
 Struts Architecture
 Validation
 Tiles
 Action Mappings
 ActionServlet
 Action and ActionMapping
 Forms
 Validation
 Coarse-Grained Form Beans

11.  Struts Tag Libraries
 Building View Components
 Struts Tag Libraries
 Attributes and Struts Expressions
 Building Forms
 Forms and Form Beans
 Scope and Duration of Form Data
 Managing Hyperlinks
 Error Messages
 Logic Tags
 The JSP Standard Tag Library
 JSTL Overview
 JSP Expression Language
 Core Tags
 Formatting Tags
 XML Tags