Not a member yet? Register now and get started.

Java 6 Months Industrial Training
Java (Core + Advanced)

To Download Syllabus - CLICK HERE

Getting Started with Java

 The Java Platform
 Obtaining Java
 Editions and Versions of Java
 Java History
 The JDK
 Your First Java Program
 Revisiting the JVM
 API documentation

Object Oriented Programming in Java

 Objects vs. Primitives
 Creating (Instantiating) Objects
 Stack and Heap
 Using Objects
 Initializing Data
 Creating Object Types
 Building Constructors
 Default Constructor
 Initialization Block

Static

 Class vs. Object
 Static variables
 Static Method
 Static Initialization Block
 "this" Keyword
 Scope
 Garbage Collection (GC) Packaging
 Packages
 Classpath
 Java Archive (JAR)

Java Syntax

 Coding standards
 Valid Identifiers
 Comments
 Primitive Data Types
 Primitive Literals
 Primitive Conversion
 Enums
 Operators
 Conditionals
 Loops
 Break, Continue, and Labels
 Assertions

Strings

 String Objects
 String operations and operators
 Immutable Strings
 Passing by Value

Encapsulation & Data Hiding

 Accessors/Mutators or Getters/Setters
 Access Modifiers
 Encapsulation/Data Hiding Resources

Inheritance

 Chasing Constructors
 Overloading Methods
 Overriding Methods and revisiting the super reference
 The Three Faces of Final

Polymorphism

 Benefits of Polymorphism
 Object Type Casting
 The Object Class

Abstract Classes and Interfaces

 

 Abstract Classes
 Interfaces
 Static Imports

Arrays and Collections

 Arrays
 Polymorphism Revisited
 When arrays are not enough
 Collections
 The Collection Interface
 Iterator
 Lists, Sets, Vector
 The Map Interface
 Hash Map, Hash table
 Limitations of Collections
 Generics and Auto boxing
 Sorting and Searching Arrays and Collections
 Comparable
 Comparator

Exception Handling

 Throwable
 Catching Exceptions
 Finally block
 The Exception Object
 Runtime vs. Checked Exceptions
 Creating Exceptions

Java Input/output

 Defining a Stream
 Reading/Writing Byte Data
 Reading and Writing Character Data
 Decorating
 System.in and System.out
 Scanner
 I/O Exceptions
 File

 

JDBC

 Why JDBC?
 Database Drivers
 Driver Manager
 Connections
 Statements
 Inserting Rows
 Updating Rows
 Deleting Rows
 Other Modifying Statements
 Result Set
 Prepared Statement
 Callable Statement
 SQL Exception
 Metadata
 Data Source

Java GUI

 Java Foundation Classes (JFC)
 Top Level Containers
 Components
 Layout Management
 Border Layout
 Flow Layout
 Box Layout
 Event Handling
 Adapters

JEE Overview

 Multi-Tiers
 Containers
 Java EE APIs
 Open Source APIs

Appendix A - Advanced I/O

 Object Serialization
 Serializable
 URL

Appendix B - Networking

 Socket Server
 Sockets

Appendix C - Threads

 What is a Thread?
 Creating a Thread
 Thread States and the Thread Scheduler
 Sleep, Yield and Join
 Thread Properties
 Extending Thread
 Concurrency and Synchronization
 Deadlocks
 Wait & Notify

STRUTS:
Setting the Landscape
 Defining the need for a Struts 2 architecture
 Specifying the application structure
 Preparing the development environment

Getting started with Struts 2
 Identifying key application components
 Implementing the request processing cycle
 Linking the flow by configurations

Configuring Struts 2 Actions, results and interceptors
 Categorizing requests with namespaces and packages
 Exploiting zero configuration conventions

Setting the default features
 Inspecting out-of-the-box functionality
 Building dependencies with Inversion of Control

Implementing Struts 2 Actions, Controlling application flow
 Utilizing the Action Support base class
 Eliminating redundant code with
 Model Driven actions

 

Simplifying the development process
 Best practices for unit testing your actions
 Improving maintainability through message localization

Gathering and Validating User Input, Building Struts 2 views
 Defining an improved approach to page generation with Struts 2 tags
 Leveraging the Struts 2 On-Demand model for data access
 Gathering user data effortlessly
 Controlling page flow with model data

Struts 2 validation architecture
 Positioning the Struts 2 validation model
 Exploring the built-in validation rules
 Applying validation interceptors
 Efficiently handling validation failures

Adding Functionality with Interceptors
 The role of interceptors
 Processing requests with the interceptor chain
 Working with the default interceptor stack
 Customizing request processing with prepackaged interceptor stacks

Extending built-in interceptor functionality
 Implementing application specific interceptors
 Simplifying interceptor configuration with annotations

Object Graph Navigation Language (OGNL)
 Reading and writing object properties
 Accessing complex types: lists, sets and maps

Manipulating data on the Value Stack
 Navigating complex graphs with OGNL operators
 Invoking non-property methods

Generating Dynamic Views, Dispatching the request
 Selecting the correct output page
 Combining multiple actions in a logical sequence
 Considering presentation technology alternatives
 Enabling other result types with the plug-in architecture


 Improving application response with lightweight presentation tags
 Reducing developer effort through user interface tags

Specifying the layout
 Eliminating repetitive code with templates
 Choosing the look and feel using Struts 2 themes

 

Hibernate:
Persisting Objects with Hibernate
 Simplifying data access with O/R mapping
 Unraveling the Hibernate architecture
 Deploying and configuring Hibernate
 Generating Hibernate applications
 Developing the persistent class
 Defining the Hibernate mapping rules
 Storing and retrieving Java objects
 Handling Complex Object Relationships, The role of the Hibernate Session
 Establishing a thread-safe session object
 Defining object states: transient, persistent, detached

Mapping collections
 Persisting and retrieving collections
 Preserving collection order for data integrity

Strategies for building object associations
 Specifying one-to-many and many-to-many relationships
 Controlling the association life cycle

Effectively mapping inheritance relationships
 Applying class rules for inheritance
 Techniques for class-database mapping

Optimizing Data Access, Applying Hibernate Query Language (HQL)
 Selecting and filtering queries
 Improving structure with named queries
 Augmenting HQL with native SQL
 Maximizing Hibernate performance
 Accelerating data access via Hibernate cache

Integrating Spring and Hibernate
 Employing the Spring Hibernate template
 Configuring Hibernate resources in Spring

Spring:
Spring architecture fundamentals
 Identifying Spring application components
 Defining the n-tier application architecture

Applying Inversion of Control (IoC) and Dependency Injection (DI)
 Delegating object creation to the Spring bean factory
 Controlling bean creation with scopes and factory methods
 Initializing and destroying beans

Minimizing Code with Aspect-Oriented Programming (AOP)
 Evaluating the benefits of AOP

 Minimizing configuration with Autoproxying
 AspectJ style AOP
 AspectJ pointcut expression language
 Applying AspectJ style with annotations
 Building aspects with POJOs and XML schema-based configuration

Simplifying data access with JDBC templates
 Streamlining runaway code with JDBC templates
 Structuring queries and callbacks for maintainability

Abstracting the Data Access Layer
 Supporting the Data Access Object (DAO) pattern
 Achieving implementation independence with platform agnostic exceptions

Building a Web Tier with Spring MVC
 Analyzing Spring Model View Controller (MVC) architecture
 Mapping requests to controllers with annotations
 Processing commands, form submissions and simple wizards
 Server-side validation

Rendering the response
 Resolving views with ViewResolvers
 Spring JSP support

Accessing enterprise services
 Performing code-free JNDI lookups
 Sending e-mail using mail templates
 Scheduling tasks using the Quartz scheduler

 

JavaEE - Enterprise Java

Building the web tier - Servlets, JSP and JSF

 Servlets
 Java Server Pages (JSPs)
 Java Server Faces (JSF) benefits
 Understanding JSF components
 Building the UI with JSF: component classes and rendering model
 Web application screen flow with the JSF navigation model
 JSF custom tags
 Integration with standard tag libraries
 Client and server-side validation
 Presenting data easily with Unified
 Expression Language and Backing Beans

Implementing the business tier with EJB 3.0

 Implementing stateless and stateful beans
 Abstracting the business service layer
 Injecting services with annotations
 Accessing beans locally and remotely
 Transforming session beans into web services
 Integrating applications with message driven beans

Persisting data with JPA

 No more entity beans: persistence units and entity classes
 Persistent access with an Entity Manager
 Annotation-driven OR mapping
 Managing multiplicity in relationships
 Entity inheritance strategies
 Querying data with JPQL

Container Services

 

Transactions

 Container-managed transaction
 Strategies
 Annotations for transactions
 Bean-managed transactions with JTA

Security on the Java EE platform

 Metadata annotations, declarative and programmatic approaches
 Authentication and authorization mechanisms in the web and EJB tiers
 Protecting resources
 Propagating security identities

 

Java Messaging Services (JMS)

 Synchronous message management with session beans

 Asynchronous message reception with message driven beans

 Point-to-point and publish-subscribe application models

Java EE and Frameworks

 Why Enterprise Java is no longer as difficult as it used to be Spring Framework: a supplement or alternative to Java EE?
 Integrating Hibernate as an alternative to JPA

Java-related technologies

 Overview of Web Services
 Web Hosting Concepts
 Introduction to Live Project and its Development Phases
 LIVE PROJECT Implementation

To Download Syllabus - CLICK HERE