Diploma in Java

Java Certification Course in Kharghar

Course Information

It is used for:

Java is a popular programming language, created in 1995. Java works on different platforms (Windows, Mac, Linux, Raspberry Pi, etc.) It is open-source, free, secure, fast and powerful and it is one of the most popular programming language in the world. It has a huge community support.

  • Mobile applications (specially Android apps)
  • Desktop applications
  • Web applications
  • Web servers and application servers
  • Games
  • Database connection

Following professionals can go for it:

  • Fresher’s
  • IT Experts


Eligibility: Technical graduate having fundamental knowledge of any programming languages like C, C++.

Lecture Duration: 7 months

Placement: 100% Placement Assistance

Job Profile: Java developer

Placement: 100% Placement Assistance

Job Profile: Java developer


Java as a Programming Tool
Advantages of Java
The Java “White Paper” Buzzwords
Java and the Internet
A Short History of Java
Common Misconceptions About Java

The Java Programming Environment

Installing the Java Software Development Kit
Development Environments
Using the Command Line Tools
Using an Integrated Development Environment
Compiling and Running Programs from a Text Editor
Graphical Applications

Fundamental Programming Structures in Java

A Simple Java Program
Data Types
Assignments and Initializations
Control Flow
Big Numbers

Objects and Classes

Introduction to Object-Oriented Programming
Using Existing Classes
Building Your Own Classes
Static Fields and Methods
Method Parameters
Object Construction
Documentation Comments
Class Design Hints


Extending Classes
Object: The Cosmic Superclass
The Class Class
Design Hints for Inheritance

Interfaces and Inner Classes

Object Cloning
Inner Classes

Graphics Programming

Introduction to Swing
Creating a Frame
Frame Positioning
Displaying Information in a Panel
2D Shapes
Text and Fonts

Event Handling

Basics of Event Handling
The AWT Event Hierarchy
Semantic and Low-Level Events in the AWT
Low-Level Event Types
The Event Queue

User Interface Components with Swing

The Model-View-Controller Design Pattern
An Introduction to Layout Management
Text Input
Making Choices
Sophisticated Layout Management
Dialog Boxes


Applet Basics
The Applet HTML Tags and Attributes
The Applet Context
JAR Files

Exceptions and Debugging

Dealing with Errors
Catching Exceptions
Some Tips on Using Exceptions
Debugging Techniques
Using a Debugger

Streams and Files

The Complete Stream Zoo
ZIP File Streams
Putting Streams to Use
Object Streams
File Management

Advanced Java


What Are Threads?
Interrupting Threads
Thread Properties
Thread Priorities
Selfish Threads
User Interface Programming with Threads
Using Pipes for Communication between Threads


Collection Interfaces
Concrete Collections
The Collections Framework
Legacy Collections


Connecting to a Server
Implementing Servers
Sending E-Mail
Advanced Socket Programming
URL Connections
Posting Form Data
Harvesting Information from the Web

Database Connectivity: JDBC

The Design of JDBC
The Structured Query Language
Installing JDBC
Basic JDBC Programming Concepts
Executing Queries
Scrollable and Updatable Result Sets
Advanced Connection Management
Java IDL and CORBA

Advanced Swings

Styled Text Components
Component Organizers

Advanced Swings

Styled Text Components
Component Organizers

Advanced AWT

The Rendering Pipeline
Transparency and Composition
Rendering Hints
Reading and Writing Images
Image Manipulation
The Clipboard
Drag and Drop


Distributed Multitiered Applications
J2EE Containers
Web Services Support
Packaging Applications
Development Roles
Sun Java System Application Server Platform Edition

Understanding XML

Introduction to XML
Generating XML Data
Designing an XML Data Structure
Getting Started with Web Applications

Web Application Life Cycle

Web Modules
Configuring Web Applications
Duke’s Bookstore Examples
Accessing Databases from Web Applications
Further Information
Java API for XML Processing

An Overview of the Packages

The Simple API for XML APIs
The Document Object Model APIs
The Extensible Stylesheet Language Transformations APIs
Using the JAXP Libraries
Where Do You Go from Here?
Simple API for XML
Echoing an XML File with the SAX Parser
Adding Additional Event Handlers

Handling Errors with the Nonvalidating Parser

Displaying Special Characters and CDATA
Parsing with a DTD
Choosing Your Parser Implementation
Using the Validating Parser
Parsing a Parameterized DTD
Handling Lexical Events
Using the DTDHandler and EntityResolver
Further Information
Building Web Services with JAX-RPC
Setting the Port

Creating a Simple Web Service and Client with JAX-RPC

Types Supported by JAX-RPC
Web Service Clients
Web Services Interoperability and JAX-RPC
Further Information

SOAP with Attachments API for Java

Overview of SAAJ
Code Examples
Further Information
Java API for XML Registries
Overview of JAXR
Implementing a JAXR Client

Running the Client Examples

Using JAXR Clients in J2EE Applications
Further Information
Java Servlet Technology
What Is a Servlet?
The Example Servlets
Servlet Life Cycle
Sharing Information
Initializing a Servlet
Writing Service Methods
Filtering Requests and Responses
Accessing the Web Context
Maintaining Client State
Finalizing a Servlet
Further Information

JavaServer Pages Technology

What Is a JSP Page?
The Example JSP Pages
The Life Cycle of a JSP Page
Creating Static Content
Creating Dynamic Content
Expression Language
JavaBeans Components
Using Custom Tags
Reusing Content in JSP Pages
Transferring Control to Another Web Component
Including an Applet
Setting Properties for Groups of JSP Pages
Further Information

JavaServer Pages Documents

The Example JSP Document
Creating a JSP Document
Identifying the JSP Document to the Container
JavaServer Pages Standard Tag Library
The Example JSP Pages
Using JSTL
Core Tag Library
XML Tag Library

Internationalization Tag Library

SQL Tag Library
Further Information
Custom Tags in JSP Pages
What Is a Custom Tag?
The Example JSP Pages
Types of Tags

Encapsulating Reusable Content Using Tag Files

Tag Library Descriptors
Programming Simple Tag Handlers

Scripting in JSP Pages

The Example JSP Pages
Using Scripting
Disabling Scripting


Programming Tags That Accept Scripting Elements
JavaServer Faces Technology
JavaServer Faces Technology Benefits
What Is a JavaServer Faces Application?
Framework Roles

A Simple JavaServer Faces Application

User Interface Component Model
Navigation Model
Backing Bean Management
How the Pieces Fit Together
The Life Cycle of a JavaServer Faces Page
Further Information
Using JavaServer Faces Technology in JSP Pages
The Example JavaServer Faces Application

Setting Up a Page

Using the Core Tags
Using the HTML Component Tags
Using Localized Messages
Using the Standard Converters
Registering Listeners on Components
Using the Standard Validators
Binding Component Values and Instances to External Data Sources
Referencing a Backing Bean Method
Using Custom Objects
Developing with JavaServer Faces Technology
Writing Component Properties
Performing Localization
Creating a Custom Converter
Implementing an Event Listener

Creating a Custom Validator

Writing Backing Bean Methods
Internationalizing and Localizing Web Applications
Java Platform Localization Classes
Providing Localized Messages and Labels
Date and Number Formatting
Character Sets and Encodings
Further Information

Enterprise Beans

What Is an Enterprise Bean?
What Is a Session Bean?
What Is an Entity Bean?
What Is a Message-Driven Bean?
Defining Client Access with Interfaces
The Contents of an Enterprise Bean
Naming Conventions for Enterprise Beans
The Life Cycles of Enterprise Beans
Further Information

Getting Started with Enterprise Beans

Creating the J2EE Application
Creating the Enterprise Bean
Creating the Application Client
Creating the Web Client
Mapping the Enterprise Bean References

Specifying the Web Client’s Context Root

Deploying the J2EE Application

Running the Application Client
Running the Web Client
Modifying the J2EE Application
Session Bean Examples
The CartBean Example

A Web Service Example: HelloServiceBean

Other Enterprise Bean Features
Using the Timer Service
Handling Exceptions
Bean-Managed Persistence Examples
Mapping Table Relationships for Bean-Managed Persistence
Primary Keys for Bean-Managed Persistence
Deploytool Tips for Entity Beans with Bean-Managed Persistence

What Is a Transaction?

Container-Managed Transactions
Bean-Managed Transactions
Summary of Transaction Options for Enterprise Beans
Transaction Timeouts
Isolation Levels

Updating Multiple Databases

Transactions in Web Components
Resource Connections
JNDI Naming
Data Source Objects and Connection Pools
Database Connections
Mail Session Connections
URL Connections
Further Information


Realms, Users, Groups, and Roles
Web-Tier Security

Understanding Login Authentication Installing and Configuring SSL Support

XML and Web Services Security
EJB-Tier Security
Application Client-Tier Security
EIS-Tier Security
Propagating Security Identity
What Is Java Authorization Contract for Containers?
Further Information
The Java Message Service API
Basic JMS API Concepts
The JMS API Programming Model

Writing Simple JMS Client Applications

Creating Robust JMS Applications
Using the JMS API in a J2EE Application
Further Information
J2EE Examples Using the JMS API
A J2EE Application That Uses the JMS API with a Session Bean
A J2EE Application That Uses the JMS API with an Entity Bean
An Application Example That Consumes Messages from a Remote J2EE
An Application Example That Deploys aMessage-Driven Bean on Two
J2EE Servers
Enterprise Beans
Application Client
Web Client
Building, Packaging, Deploying, and Running the Application
Running the Clients

Spring Framework

Introduction to Spring
Steps to use Spring Framework in applications
Understanding IOC and Dependency Injection
Understanding the bean life-cycle – Auto wiring and bean scopes
Annotation-based dependency injection
Adding behavior to an application using aspects – AOP
Creating and applying aspects
Introducing data access with Spring – JDBC through spring
Transactions in a Spring environment
Getting started with Hibernate in a Spring environment
Working with Spring MVC
Spring MVC Form Handling
Creating Views in Spring MVC


Hibernate with annotation
Web Application using hibernate Generator Classes in Hibernate
Inheritance mapping Table Per Hierarchy Table per Concrete Collection
in hibernate
Hibernate Query language Hibernate Criteria Query Language Caching
in Hibernate
First level Cache Second Level Cache


Introduction Architecture
Struts Configuration File Struts.xml
Multi configuration Multi namespace Struts Validation Custom
Bundled Ajax
Struts Interface Servlet Action Context Session Ae are
Servlet Context Aware Hibernate With Struts Struts Date Time Picker
Registration Example Login Example
Fetch all Record of a table

Web Development

HTML & CSS Overview

HTML Attributes
HTML Styles
HTML Forms
HTML Input Element Types 
HTML Input Attributes
HTML File Paths
Script tag and its uses 
CSS Introduction 
CSS Syntax
CSS Selectors 
CSS Styling

Javascript Primer

Introduction to Javascript 
Javascript Statements 
Javascript Keywords 
Javascript Functions 
Javascript Programs 
Javascript Operators 
Function Parameters 
Function Return Values 
Javascript Data Types 
Primitive Types

Working with Objects

Object Overview
Object Oriented Programming 
Object creation
Adding Properties to Objects 
Adding Methods to Objects 
Javascript Conditional Statements 
Javascript Loops & Iteration 
Enumerating properties
Environmental setup
MVC Architecture
Model-View-Controller explained 
Why MVC matters
MVC – the AngularJS way
First Application
Introduction to Directives 
Directive lifecycle
Using AngularJS built-in directives 
Binding controls to data 
Matching directives
Creating a custom directive 
Role of a Controller
Attaching properties and functions to scope 
Nested Controllers
Using filters in Controllers 
Controllers in External Files 
Controllers & Modules
Built-in filters
Using AngularJS filters 
Creating custom filters 
Introduction to AngularJS Modules Bootstrapping
Working with Angular Forms 
Model binding
Form controller  
Validating Angular Forms
Updating models with a twist
$error object
Form events
Scope lifecycle
Two way data binding 
Scope inheritance 
Scope & controllers 
Scope & directives
$apply and $watch 
Scope broadcasting
Dependency Injection & Services
What is Dependency Injection 
Using Dependency Injection 
What are services
Creating services
Factory, Service & Provider 
Using AngularJS built in services
Single Page Application(SPA)
What is SPA
Pros & Cons of SPA
Installing the ngRoute module 
Configure routes
Passing parameters 
Changing location 
Resolving promises
Create a Single Page Application


Getting Started

  1. Course Introduction.
  2. What is Angular?
  3. Angular vs Angular 2 vs Angular 4+
  4. Project Setup and First App.
  5. Editing the First App.
  6. The Course Structure.
  7. What is TypeScript.
  8. A Basic Project Setup using Bootstrap for Styling

The Basics
How an Angular App gets Loaded and Started Components
Using Custom Components
Creating Components with the CLI & Nesting Components
Working with Component Templates
Working with Component Style

Assignment 1: Practicing Components
What is Databinding

  • String Interpolation
  • Property Binding
  • Property Binding vs String Interpolation
  • Event Binding
  • Bindable Properties and Events
  • Passing and Using Data with Event Binding
  • Two-Way-Databinding
  • Important: FormsModule is Required for Two-Way-Binding
  • Combining all Forms of Databinding

Assignment 2: Practicing Databinding

  • Understanding Directives
  • Using ngIf to Output Data Conditionally
  • Enhancing ngIf with an Else Condition.

Components & Databinding Deep Dive

  • Splitting Apps into Components
  • Property & Event Binding Overview
  • Binding to Custom Properties
  • Assigning an Alias to Custom Properties
  • Binding to Custom Events
  • Assigning an Alias to Custom Events
  • Custom Property and Event Binding Summary
  • Understanding View Encapsulation
  • More on View Encapsulation
  • Using Local References in Templates.
  • Getting Access to the Template & DOM with @ViewChild.
  • Understanding the Component Lifecycle

Lifecycle Hooks
Assignment 3: Practicing Property & Event Binding and View Encapsulation
Directives Deep Dive

  • ngFor and ngIf ngClass and ngStyle
  • How to create a Basic Directive
  • Using Services & Dependency Injection Why would you Need Services?
  • Creating a Logging Service
  • Injecting the Logging Service into Components Creating a Data Service
  • Understanding the Hierarchical Injector
  • How many Instances of Service Should It Be? Injecting Services into
  • Services
  • Using Services for Cross-Component Communication

Assignment 4: Practicing Services
Changing Pages with Routing

  • Why do we need a Router?
  • Understanding the Example Project.
  • Setting up and Loading Routes.
  • Navigating with Router Links.
  • Understanding Navigation Paths.
  • Styling Active Router Links.

Navigating Programmatically

  • Using Relative Paths in Programmatic Navigation Passing Parameters to Routes
  • Fetching Route Parameters
  • Fetching Route Parameters Reactively
  • An Important Note about Route Observables Passing Query Parameters and Fragments Retrieving Query Parameters and Fragments Setting up Child (Nested) Routes
  • Using Query Parameters – Practice Configuring the Handling of Query Parameters Redirecting and Wildcard Routes
  • Important: Redirection Path Matching An Introduction to Guards
  • Protecting Routes with canActivate
  • Protecting Child (Nested) Routes with canActivateChild Using a Fake Auth Service

Controlling Navigation with canDeactivate

  • Handling Forms in Angular Apps
  • Template-Driven (TD) vs Reactive Approach
  • TD Forms

Assignment 5: Practicing Template-Driven Forms

  • Introduction to the Reactive Approach
  • Reactive Forms

Assignment 6: Practicing Reactive Forms

  • Using Pipes to Transform Output
  • Introduction & Why Pipes are Useful Using Pipes
  • Making Http Requests
  • Introduction & How Http Requests Work in SPAs
  • Sending Requests (Example: POST Request)
  • Adjusting Request Headers
  • Sending GET Requests Sending a PUT Request
  • Transform Responses Easily with Observable Operators (map())
  • Using the Returned Data
  • Catching Http Errors
  • Using the “async” Pipe with Http Requests.

Authentication & Route Protection in Angular Apps

  • How Authentication Works in Single-Page-Applications
  • Creating a Signup Page and Route
  • Setting up the Firebase SDK Signing Users Up
  • Signin Users In
  • Requiring a Token (on the Backend) Sending the Token
  • Checking and Using Authentication Status
  • Adding a Logout Button
  • Route Protection and Redirection. Wrap Up
  • The HttpClient (ANGULAR 5 Addition Bonus SECTION)
  • Request Configuration and Response.
  • Requesting Events.
  • Setting Headers.
  • Interceptors.

SQL – Structure Query Language

  • RDBMS – An Introduction Database
  • Relational Database Systems
  • Working with the Book’s Sample Database
  • SQL: A Relational Database Language
  • Normal Forms
  • Entity-Relationship Model
  • Syntax Conventions

Foundations of T-SQL

  • A Short History of T-SQL
  • Imperative vs. Declarative Languages
  • SQL Basics
  • Statements
  • Databases
  • Transaction Logs
  • Schemas
  • Tables
  • Views
  • Indexes
  • Stored Procedures
  • User-Defined Functions
  • SQL CLR Assemblies
  • Elements of Style
  • Whitespace
  • Naming Conventions
  • One Entry, One Exit
  • Defensive Coding
  • SQL-92 Syntax Outer Joins
  • The SELECT * Statement
  • Variable Initialization

Procedural Code and CASE Expressions

  • Three-Valued Logic
  • Control-of-Flow Statements
  • The BEGIN and END Keywords
  • The IF…ELSE Statement
  • The WHILE, BREAK, and CONTINUE Statements
  • The GOTO Statement
  • The WAITFOR Statement
  • The RETURN Statement
  • The TRY…CATCH Statement
  • The CASE Expression
  • The Simple CASE Expression
  • The Searched CASE Expression
  • CASE and Pivot Tables
  • Cursors

User-Defined Functions

  • Scalar Functions
  • Recursion in Scalar User-Defined Functions
  • Procedural Code in User-Defined Functions
  • Multistatement Table-Valued Functions
  • Inline Table-Valued Functions
  • Restrictions on User-Defined Functions
  • Nondeterministic Functions
  • State of the Database

Stored Procedures

  • Introducing Stored Procedures
  • Calling Stored Procedures
  • Managing Stored Procedures
  • Stored Procedures in Action
  • Recursion in Stored Procedures
  • Table-Valued Parameters
  • Temporary Stored Procedures
  • Recompilation and Caching
  • Stored Procedure Statistics
  • Parameter Sniffing
  • Recompilation


  • DML Triggers
  • When to Use DML Triggers
  • Auditing with DML Triggers
  • Nested and Recursive Triggers
  • The UPDATE and COLUMNS_UPDATED Functions
  • Triggers on Views
  • DDL Triggers
  • Logon Triggers

Common Table Expressions and Windowing Functions

  • Common Table Expressions
  • Multiple Common Table Expressions
  • Recursive Common Table Expressions
  • Windowing Functions
  • The ROW_NUMBER Function
  • The RANK and DENSE_RANK Functions
  • The NTILE Function
  • Aggregate Functions and OVER


  • Legacy XML
  • OPENXML Result Formats
  • FOR XML Clause
  • The xml Data Type
  • Untyped xml
  • Typed xml
  • The xml Data Type Methods
  • The query Method
  • The value Method
  • The exist Method
  • The nodes Method
  • The modify Method
  • XML Indexes
  • XSL Transformations

XQuery and XPath

  • XPath and FOR XML PATH
  • XPath Attributes
  • Columns Without Names and Wildcards
  • Element Grouping
  • The data Function
  • XPath and NULL
  • Node Tests
  • XQuery and the xml Data Type
  • Expressions and Sequences
  • The query Method
  • Location Paths
  • Node Tests
  • Namespaces
  • Axis Specifiers
  • Dynamic XML Construction
  • XQuery Comments
  • Data Types
  • Predicates
  • Conditional Expressions (if…then…else)
  • Arithmetic Expressions
  • XQuery Functions
  • Constructors and Casting
  • FLWOR Expressions

Catalog Views and Dynamic Management Views

  • Catalog Views
  • Table and Column Metadata
  • Index Metadata
  • Querying Permissions
  • Dynamic Management Views and Functions
  • Session Information
  • Connection Information
  • Currently Executing SQL
  • Tempdb Space
  • Server Resources
  • Unused Indexes

SQL CLR Programming

  • The Old Way
  • The SQL CLR Way
  • SQL CLR Assemblies
  • User-Defined Functions
  • Stored Procedures
  • User-Defined Aggregates
  • Creating a Simple UDA
  • Creating an Advanced UDA
  • SQL CLR User-Defined Types

New T-SQL Features

  • Set Operators
  • The OUTPUT Clause
  • The TOP Keyword
  • The TABLESAMPLE Clause
  • Date and Time Functions
  • The max Data Types
  • Synonyms
  • FILESTREAM Support
  • Enabling FILESTREAM Support
  • Creating FILESTREAM Filegroups
  • FILESTREAM-Enabling Tables
  • Accessing FILESTREAM Data

Error Handling and Dynamic SQL

  • Error Handling
  • Legacy Error Handling
  • Try…Catch Exception Handling
  • The RAISERROR Statement
  • Debugging Tools
  • PRINT Statement Debugging
  • Trace Flags
  • SSMS Integrated Debugger
  • Visual Studio T-SQL Debugger
  • Dynamic SQL
  • The EXECUTE Statement
  • SQL Injection and Dynamic SQL
  • Troubleshooting Dynamic SQL
  • The sp_executesql Stored Procedure
  • Dynamic SQL and Scope
  • Client-Side Parameterization

Performance Tuning

  • SQL Server Storage
  • Files and Filegroups
  • Space Allocation
  • Data Compression
  • Indexes
  • Heaps
  • Clustered Indexes
  • Nonclustered Indexes
  • Filtered Indexes
  • Optimizing Queries
  • Reading Query Plans
  • Methodology

Software Testing

Duration: 12 hrs.

Software Development Life Cycle :

  • What are the different phases of SDLC?
  • How does the process of Software Development Start?
  • Project Initiation

Requirement Gathering and Analysis

  • What is Requirement document and what it contains?
  • What is use case document and what it contains?
  • What is Basic path and Alternate Path?
  • Role of Business Analyst
  • Example for explaining each phase
  • Role of technical specification team
  • What is Technical specification document?

What is System Design?

  • Role of Design team
  • What is design document?
  • Role of architecture team

System development

  • Role of development team
  • Deliverable of Development phase

System testing

  • Role of testers and types of testing
  • User acceptance testing
  • System deployment

System maintenance

  • Events in the maintenance phase like bug fixes

Software Testing Life Cycle

  • How are the phases of STLC carried out?
  • What is testing?
  • Role of testers
  • Why do we need to test?
  • Activities involved in the testing phase

What is test plan and test case document?

  • Steps of test case execution
  • What does test case document contain?
  • How to write test case document?
  • What is required to test any application?


  • What is test case?
  • What does test case document contain?
  • How to write test case document?
  • Different test case techniques


  • What is Test Plan?
  • How to write test plan document?
  • What does the test plan document contain?
  • Who writes and approves the test plan document?
  • How manage the test case documents?
  • What is the pass/fail criterion?


  • Different Phases of testing
  • What is unit testing?
  • What is Minimum acceptance testing?
  • What is integration, system and system integration testing?
  • What is User acceptance testing?
  • What is Regression Testing?


  • What is a defect?
  • Various Defect tracking tools
  • How to use the defect tracking tools?
  • How to enter the details of defect in the defect tracking tool?
  • How to identify a defect?
  • What is severity and priority?


  • What is Traceability Matrix[TM]?
  • Who Prepares the TM document?
  • What is the reference for writing TM?
  • What is the use of TM?
  • What is present in the TM document?
  • Sample TM
  • Tools used for developing TM

Get Trained from best industry expert, contact for online Java certification course and training in kharghar, Navi Mumbai.

Contact Us

Our Top Recruiters