Core Java
Object-Oriented Programming
The Four OOP Principles
A First Simple Program
Entering
the Program
Compiling the Program
Command line Arguments
A Closer Look at the First Sample Program
Two Control Statements
The if Statement
The for Loop
Data Types, Variables, and Arrays
The Primitive Types
Integers
byte
short
int
long
Floating-Point Types
float
double
Characters
Booleans
A Closer Look at
Literals
Integer
Literals
Floating-Point
Literals
Boolean
Literals
Character
Literals
String
Literals
Variables
Declaring
a Variable
Dynamic
Initialization
The
Scope and Lifetime of Variables
Arrays
One-Dimensional
Arrays
Multidimensional
Arrays
Operators
Arithmetic Operators
The
Basic Arithmetic Operators
The
Modulus Operator
Arithmetic
Compound Assignment Operators
Increment
and Decrement
Relational Operators
Boolean Logical
Operators
The Assignment Operator
The ? Operator
Operator Precedence
Using Parentheses
Control Statements
Java’s Selection
Statements
if
switch
Iteration Statements
while
do-while
for
For-Each
Nested
Loops
Jump Statements
Using
break
Using
continue
Introducing Classes
Class Fundamentals
The
General Form of a Class
A
Simple Class
Declaring Objects
A
Closer Look at new
Assigning Object
Reference Variables
Introducing Methods
Adding
a Method to Class
Returning
a Value
Adding
a Method That Takes Parameters
Constructors
Parameterized
Constructors
The this Keyword
Instance
Variable Hiding
Garbage Collection
The finalize( ) Method
A Closer Look at Methods and Classes
Overloading Methods
Overloading
Constructors
Using Objects as
Parameters
Call By Reference
Call By Value
Returning Objects
Introducing access
control
Public, private, protected and default
access modifiers
What’s static
What’s final
Inheritance
Inheritance Basics
Member
Access and Inheritance
An
Example
Using super
Call
Super class Constructors
Using Abstract Classes
Packages and Interfaces
Packages
Defining
a Package
Finding
Packages and CLASSPATH
A
Short Package Example
Interfaces
Defining
an Interface
Implementing
Interfaces
Applying
Interfaces
Variables
in Interfaces
Extending Interfaces
Exception Handling
Exception-Handling
Fundamentals
Exception Types
Uncaught Exceptions
Using try and catch
Displaying
a Description of an Exception
Multiple catch Clauses
Nested try Statements
throw
throws
finally
Java’s Built-in
Exceptions
Creating Your Own
Exception Subclasses
Multithreaded Programming
Thread
Priorities
Synchronization
The
Thread Class and the Runnable Interface
The Main Thread
Creating a Thread
Implementing
Runnable
Extending
Thread
Enumerations, Autoboxing, and Annotations
(Metadata)
Enumerations
Enumeration
Fundamentals
The
values( ) and valueOf( ) Methods
Autoboxing
Annotations (Metadata)
Annotation
Basics
I/O and Other Topics
I/O Basics
Streams
Byte
Streams and Character Streams
The
Predefined Streams
Reading Console Input
Reading
Characters
Reading
Strings
Writing Console Output
The PrintWriter Class
Reading and Writing
Files
Automatically Closing a
File
The transient and volatile
Modifiers
Using instanceof
Static Import
Generics
What Are Generics?
A Simple Generics
Example
String Handling
The String Constructors
String Length
Special String
Operations
String
Literals
String
Concatenation
String
Concatenation with Other Data Types
String
Conversion and toString( )
Character Extraction
charAt(
)
getChars(
)
getBytes(
)
toCharArray(
)
String Comparison
equals(
) and equalsIgnoreCase( )
regionMatches(
)
startsWith(
) and endsWith( )
equals(
) Versus ==
compareTo(
)
Searching Strings
Data Conversion Using
valueOf( )
StringBuffer
StringBuilder
The Collections Framework
Collections Overview
The Collection
Interfaces
The
Collection Interface
The
List Interface
The
Set Interface
The Collection Classes
The
ArrayList Class
The
LinkedList Class
The
HashSet Class
The
LinkedHashSet Class
The
TreeSet Class
Accessing a Collection via
an Iterator
Using
an Iterator
The
For-Each Alternative to Iterators
Storing User-Defined
Classes in Collections
Working with Maps
The
Map Interfaces
The
Map Classes
Comparators
Using
a Comparator
The Collection Algorithms
The Legacy Classes and
Interfaces
The
Enumeration Interface
Vector
Stack
Dictionary
Hashtable
Properties
Inner Classes
Inner Class
Static Inner Class
Local Inner Class
Anonymous Inner Class
Advance Java
Java Beans
What Is a Java Bean?
Advantages of Java
Beans
The Java Beans API
A Bean Example
Server Awareness
Introduction to Web Applications
and Servers
Web Application v/s
Traditional Applications
HTTP protocol
Web containers
Difference Web Server and
Application Server
Servlets
Background
The Life Cycle of a
Servlet
Servlet Development
Options
Using Tomcat
A Simple Servlet
Create
and Compile the Servlet Source Code
Start
Tomcat
Start
a Web Browser and Request the Servlet
The Servlet API
The javax.servlet
Package
Reading Servlet
Parameters
The javax.servlet.http
Package
Handling HTTP Requests
and Responses
Handling
HTTP GET Requests
Handling
HTTP POST Requests
Using Cookies
Session Tracking
JSP
JSP Architecture
Your first JSP
Implicit Objects
Scriptlets
Directives
Declarations
Making error pages
Tag Libraries
Database Handling
Introduction to MYSQL
JAVA Database Connectivity.
JDBC API
Connection Objects
Statement Objects
ResultSet Objects
Opening/Closing
Database connection
Fetching tables in
ResultSet
Manipulating ResultSet
Statement, Prepared
Statement, Callable Statement etc.
Add-on
Courses
Spring Framework
What is framework?
What is Spring
Framework?
The Bean Factory and
Application Context
Dao support –
JDBCTemplate and HibernateTemplate
Spring IOC
Spring ORM
Spring MVC
Spring integration with
other technologies
Sample Application
Hibernate
Introduction to ORM
Persistence and
persistence problem
Difference between JDBC
and ORM
Introduction to Hibernate
Hibernate Architecture
Basics components of
Hibernate
HQL
Criteria API
Relationships using
Hibernate
Databases
What is a database?
Transactions – ACID
properties
DDL, DML and DCL
statements
Joins
Inner Join
Left Outer Join
Right Outer Join
Self Join
Constraints
Indexes
Sequences, Triggers,
procedures and Views
Subqueries
Better Job Assistance
Career Counseling
Awareness about all IT
career lines and Salaries
End to end assistance in building better RESUME
What to be included and what
not.
Prioritizing the
information
Cover Letter
Having multiple resumes (if
required)
Best practices to find a good job
Interview mockups during training
Technical topic presentations
Major
Project
How requirement gathering is done.
What all different documents get prepared.
Different phases of project.
Project development using MVC pattern.
Using Views, Controllers, Service and DAO layers
Using tomcat as server and MYSQL as database.
Best Practices/Patterns for building dynamic project
