Java SE 7 Syllabus by Oracle

Java Platform Overview

Introductions

Course Schedule

Java Overview

Java Platforms

OpenJDK

Licensing

Java in Server Environments

The Java Community Process

Java Syntax and Class Review

Simple Java classes

Java fields, constructors and methods

Model objects using Java classes

Package and import statements

Encapsulation and Polymorphism

Encapsulation in Java class design

Model business problems with Java classes

Immutability

Subclassing

Overloading methods

Variable argument methods

Java Class Design

Access modifiers: private, protected and public

Method overriding

Constructor overloading

The instanceof operator

Virtual method invocation

Polymorphism

Casting object references

Overriding Object methods

Advanced Class Design

Abstract classes and type generalization

The static and final modifiers

Field modifier best practices

The Singleton design pattern

Designing abstract classes

Nested classes

Enumerated types

Inheritance with Java Interfaces

Java Interfaces

Types of Inheritance

Object composition and method delegation

Implementing multiple interfaces

The DAO design pattern

Generics and Collections

Generic classes and type parameters

Type inference (diamond)

Collections and generics

List, set and Map

Stack and Deque

String processing

String manipulation with StringBuilder and StringBuffer

Essential String methods

Text parsing in Java

Input processing with Scanner

Text output and formatting

Regular expressions with the Pattern and Matcher classes

Exceptions and Assertions

Exceptions categories

Standard Java Exception classes

Creating your own Exception classes

Using try-catch and the finally clause

Using try-with-resources and the AutoCloseable interface

The multi-catch feature

Best practices using exceptions

Assertions

I/O Fundamentals

I/O using Java

Reading the console input stream

Writing to the console

Using I/O Streams

Chaining I/O Streams

Channel I/O

Reading and writing objects using Serialization

File I/O with NIO 2

The Path interface

The Files class

Directory and File operations

Managing file system attributes

Reading, writing, and creating files

Watching for file system changes

Threading

Operating system task scheduling

Recognizing multithreaded environments

Creating multi-threaded solutions

Sharing data across threads

Synchronization and Deadlock

Immutable objects

Concurrency

Creating Atomic variables

Using Read-Write Locks

Thread-safe collections

Concurrenct synchronizers (Semaphore, Phaser, and others)

Executors and ThreadPools to concurrently schedule tasks

Parallelism and the Fork-Join framework

Database Application with JDBC

Layout of the JDBC API

JDBC divers

Queries and results

PreparedStatement and CallableStatement

Transactions

RowSet 1.1 RowSetProvider and RowSetFactory

The DAO Pattern and JDBC

Localization

Advantages of localization

Defining locale

Read and set locale using the Locale object

Resource bundles

Format messages, dates and numbers

Java Syllabus by felight.com

Introduction

Programming language Types and Paradigms.

Computer Programming Hierarchy.

How Computer Architecture Affects a Language ?

Why Java ?

Flavors of Java.

Java Designing Goal.

Role of Java Programmer in Industry.

Features of Java Language.

JVM The heart of Java

Javas Magic Bytecode

Language Fundamentals

The Java Environment:

Installing Java.

Java Program Development

Java Source File Structure

Compilation

Executions.

Basic Language Elements:

Lexical Tokens, Identifiers

Keywords, Literals, Comments

Primitive Datatypes, Operators

Assignments.

Object Oriented Programming

Class Fundamentals.

Object & Object reference.

Object Life time & Garbage Collection.

Creating and Operating Objects.

Constructor & initialization code block.

Access Control, Modifiers, methods

Nested , Inner Class &Anonymous Classes

Abstract Class & Interfaces

Defining Methods, Argument Passing Mechanism

Method Overloading, Recursion.

Dealing with Static Members. Finalize() Method.

Native Method. Use of this reference.

Use of Modifiers with Classes & Methods.

Design of Accessors and Mutator Methods

Cloning Objects, shallow and deep cloning

Generic Class Types

Extending Classes and Inheritance

Use and Benefits of Inheritance in OOP

Types of Inheritance in Java

Inheriting Data Members and Methods

Role of Constructors in inheritance

Overriding Super Class Methods.

Use of super.

Polymorphism in inheritance.

Type Compatibility and Conversion

Implementing interfaces.

Package

Organizing Classes and Interfaces in Packages.

Package as Access Protection

Defining Package.

CLASSPATH Setting for Packages.

Making JAR Files for Library Packages

Import and Static Import

Naming Convention For Packages

Exception Handling:

The Idea behind Exception

Exceptions & Errors

Types of Exception

Control Flow In Exceptions

JVM reaction to Exceptions

Use of try, catch, finally, throw, throws in Exception Handling.

In-built and User Defined Exceptions

Checked and Un-Checked Exceptions

Array & String :

Defining an Array

Initializing & Accessing Array

Multi Dimensional Array

Operation on String

Mutable & Immutable String

Using Collection Bases Loop for String

Tokenizing a String

Creating Strings using StringBuffer

Thread :

Understanding Threads

Needs of Multi-Threaded Programming.

Thread Life-Cycle

Thread Priorities

Synchronizing Threads

Inter Communication of Threads

Critical Factor in Thread -DeadLock

Applet

Applet & Application

Applet Architecture.

Parameters to Applet

Embedding Applets in Web page.

Applet Security Policies

A Collection of Useful Classes

Utility Methods for Arrays

Observable and Observer Objects

Date & Times

Using Scanner

Regular Expression

Input/Output Operation in Java(java.io Package)

Streams and the new I/O Capabilities

Understanding Streams

The Classes for Input and Output

The Standard Streams

Working with File Object

File I/O Basics

Reading and Writing to Files

Buffer and Buffer Management

Read/Write Operations with File Channel

Serializing Objects

GUI Programming

Designing Graphical User Interfaces in Java

Components and Containers

Basics of Components

Using Containers

Layout Managers

AWT Componets

Adding a Menu to Window

Extending GUI Features Using Swing Components

Java Utilities (java.util Package)

The Collection Framework :

Collections of Objects

Collection Types

Sets

Sequence

Map

Understanding Hashing

Use of ArrayList & Vector

Event Handling

Event-Driven Programming in Java

Event- Handling Process

Event-Handling Mechanism

The Delegation Model of Event Handling

Event Classes

Event Sources

Event Listeners

Adapter Classes as Helper Classes in Event Handling

Anonymous Inner classes a Short cut to Event Handling

Avoiding Deadlocks in GUI Code

Event Types & Classes

Networking Programming

Networking Basics

Client-Server Architecture

Socket Overview

Networking Classes and Interfaces

Network Protocols

Developing Networking Applications in Java

Database Programming using JDBC

Introduction to JDBC

JDBC Drivers & Architecture

CURD operation Using JDBC

Connecting to non-conventional Databases.

Mail API

Introduction to Email Technical Internals

Understanding of POP and SMTP framework

Complete understanding the email API

Mass mailer Application development

Introduction to J2EE

J2EE Overview

Why J2EE?

J2EE Architecture

J2EE APIs

J2EE Containers

Java Server Technologies

Servlet

Web Application Basics.

Architecture and challenges of Web Application.

Introduction to servlet

Servlet life cycle

Developing and Deploying Servlets

Exploring Deployment Descriptor (web.xml).

Handling Request and Response

Initializing a Servlet

Accessing Database

Servlet Chaining

Session Tracking & Management

Dealing with cookies

Transferring Request

Accessing Web Context

Passing INIT and CONTEXT Parameter

Sharing information using scope object

Controlling concurrent access

User Authentication

Filtering Request and Response

Programming Filter

Filter Mapping

Servlet Listeners

Java Server Pages:

Basic JSP Architecture

Life Cycle of JSP (Translation, compilation)

JSP Tags and Expressions

Role of JSP in MVC-2

JSP with Database

JSP Implicit Objects

Tag Libraries

JSP Expression Language (EL)

Using Custom Tag

JSP Capabilities:

Exception Handling

Session Management

Directives

JSP with Java Bean

RMI (Remote Method Invocation)

RMI overview

RMI architecture

Example demonstrating RMI

Enterprise JAVA Beans

Enterprise Bean overview

Types of enterprise beans

Advantages of enterprise beans

The Life Cycles of Enterprise Beans

Working with Session Beans

Statefull vs. Stateless Session Beans

Working with Entity Beans

Message Driven Beans

JNDI (Java Naming and Directory Interface)

JNDI overview

JNDI API

Context operations

Using JNDI in J2EE applications

CORE & ADVANCE JAVA SYLLABUS BY SSSIT.ORG

Core Java

Basics of Java
Java - What, Where and Why?
History and Features of Java
Internals of Java Program
Difference between JDK,JRE and JVM
Internal Details of JVM
Variable and Data Type
Unicode System
Naming Convention

OOPS Conecpts
Advantage of OOPs
Object and Class
Method Overloading
Constructor
static variable, method and block
this keyword
Inheritance (IS-A)
Aggregation and Composition(HAS-A)
Method Overriding
Covariant Return Type
super keyword
Instance Initializer block
final keyword
Runtime Polymorphism
static and Dynamic binding
Abstract class and Interface
Downcasting with instanceof operator
Package and Access Modifiers
Encapsulation
Object class
Object Cloning
Java Array
Call By Value and Call By Reference
strictfp keyword
Creating API Document

String Handling
String : What and Why?
Immutable String

String Comparison
String Concatenation
Substring
Methods of String class
StringBuffer class
StringBuilder class
Creating Immutable class
toString method
StringTokenizer class

Exception Handling
Exception Handling : What and Why?
try and catch block
Multiple catch block
Nested try
finally block
throw keyword
Exception Propagation
throws keyword
Exception Handling with Method Overriding
Custom Exception

Nested Classes
Nested Class : What and Why?
Member Inner class
Annonymous Inner class
Local Inner class
static nested class
Nested Interface

Multithreading
Multithreading : What and Why?
Life Cycle of a Thread
Creating Thread
Thread Schedular
Sleeping a thread
Joining a thread
Thread Priority
Daemon Thread
Thread Pooling
Thread Group
ShutdownHook

Performing multiple task by multiple thread

Garbage Collection
Runnable class

Synchronization
Synchronization : What and Why?
synchronized method
synchronized block
static synchronization
Deadlock
Inter-thread Communication
Interrupting Thread

Input and output

FileOutputStream & FileInputStream
ByteArrayOutputStream
SequenceInputStream
BufferedOutputStream & BufferedInputStream
FileWriter & FileReader
CharArrayWriter
Input from keyboard by InputStreamReader
Input from keyboard by Console
Input from keyboard by Scanner
PrintStream class
PrintWriter class
Compressing and Uncompressing File
Reading and Writing data simultaneously
DataInputStream and DataOutputStream
StreamTokenizer class

Serialization
Serialization & Deserialization
Serialization with IS-A and Has-A
transient keyword

Networking
Socket Programming
URL class
Displaying data of a web page
InetAddress class

DatagramSocket and DatagramPacket

Two way communication

AWT and EventHandling

AWT Controls
Event Handling by 3 ways
Event classes and Listener Interfaces
Adapter classes
Creating Games and Applications

Swing
Basics of Swing
JButton class
JRadioButton class
JTextArea class
JComboBox class
JTable class
JColorChooser class
JProgressBar class
JSlider class
Digital Watch
Graphics in swing
Displaying Image
Edit Menu for Notepad
Open Dialog Box
Creating Notepad
Creating Games and applications

LayoutManagers
BorderLayout
GridLayout
FlowLayout
BoxLayout
CardLayout

Applet
Life Cycle of Applet
Graphics in Applet
Displaying image in Applet
Animation in Applet
EventHandling in Applet
JApplet class

Painting in Applet
Digital Clock in Applet
Analog Clock in Applet
Parameter in Applet
Applet Communication
Creating Games

Reflection API
Reflection API
newInstance() & Determining the class object
javap tool
creating javap tool
creating appletviewer
Accessing private method from outside the class

Collection
Collection Framework
ArrayList class
LinkedList class
ListIterator interface
HashSet class
LinkedHashSet class
TreeSet class
PriorityQueue class
ArrayDeque class
Map interface
HashMap class
LinkedHashMap class
TreeMap class
Hashtable class
Comparable and Comparator
Properties class

JDBC
JDBC Drivers
Steps to connect to the database
Connectivity with Oracle
Connectivity with MySQL
Connectivity with Access without DSN
DriverManager
Connection interface
Statement interface
ResultSet interface

PreparedStatement
ResultSetMetaData
DatabaseMetaData
Storing image
Retrieving image
Storing file
Retrieving file
Stored procedures and functions
Transaction Management
Batch Processing
JDBC New Features
Mini Project

Java New Features

Assertion
For-each loop
Varargs
Static Import
Autoboxing and Unboxing
Enum Type
Annotation
etc.

Internationalization
Internationalization
ResourceBundle class
I18N with Date
I18N with Time
I18N with Number
I18N with Currency

Advance Java
Servlet
Basics of Servlet
Servlet: What and Why?
Basics of Web
Servlet API
Servlet Interface
GenericServlet
HttpServlet

Servlet Life Cycle

Working with Apache Tomcat Server
Steps to create a servlet in Tomcat
How servlet works?
servlet in Myeclipse
servlet in Eclipse
servlet in Netbeans

ServletRequest
ServletRequest methods
Registration example with DB

Servlet Collaboration
RequestDispatcher
sendRedirect

ServletConfig
ServletConfig methods
ServletConfig example

ServletContext
ServletContext methods
ServletContext example

Attribute
How to set, get and remove example?

Session Tracking
Cookies
Hidden Form Field
URL Rewriting
HttpSession

Event and Listener

Filter
Filter
Authentication Filter

FilterConfig
Useful examples

ServletInputStream and ServletOutputStream

Annotation Servlet
Project Development

JSP
Basics of JSP
Life cycle of JSP
JSP API
JSP in Eclipse and other IDE's

Scripting elements
scriptlet tag
expression tag
declaration tag

9 Implicit Objects
out
request
response
config
application
session
pageContext
page
exception

Directive Elements
page directive
include directive
taglib directive

Exception Handling

Action Elements
jsp:forward
jsp:include
Bean class
jsp:useBean
jsp:setProperty & jsp:getProperty
Displaying applet in JSP

Expression Language
MVC in JSP
JSTL
Custom tags
Custom Tag : What and Why?
Custom Tag API?
Custom Tag Example
Attributes
Iteration
Custom URI

Project Development in JSP

.

JavaMail API
JavaMail API
Sending Email
Sending email through Gmail server
Receiving Email
Sending HTML content

Design Pattern
Design Pattern
Singleton
DAO
DTO

MVC
Front Controller
Factory Method
etc.

JUnit
JUnit
JUnit: What and Why?
Types of Testing
Annotations used in JUnit
Assert class
Test Cases

Maven
Maven
Maven: What and Why?
Ant Vs Maven
How to install Maven?
Maven Repository
Understanding pom.xml
Maven Example
Maven Web App Example
Maven using Eclipse

Struts 2
Basics of Struts2
Struts : What and Why?
Model1 vs Model2
Struts2 Features
Steps to create Struts2 application
Understanding Action class
Understanding struts.xml file
Struts2 in Eclipse IDE
Struts2 in Myeclipse IDE

Core Components
Interceptors
ValueStack

ActionContext
ActionInvocation
OGNL

Struts 2 Architecture
Struts2 Action
Action Interface
ActionSupport class

Struts2 Configuration
multi configuration
multi namespace

Interceptors
Custom Interceptor : Life Cycle of Interceptor
params interceptor
execAndWait interceptor
prepare interceptor
modelDriven interceptor
exception interceptor
fileUpload interceptor

Struts 2 Validation
Custom Validation : workflow interceptor
Input Validation : validation interceptor
Ajax Validation : jsonValidation interceptor

Aware Interfaces
ServletActionContext
SessionAware
Login and Logout Application
ServletContextAware

Struts2 with I18N

Zero Configuration
By convention
By annotation

Struts2 with Tiles2

Hibernate with Struts2

Spring with Struts2
Project Development in Struts2

Working with IDE

IDE
Eclipse IDE
Netbeans IDE
Myeclipse IDE

Working with Servers

Servers
Apache Tomcat
Glassfish Server
JBoss Server
Weblogic Server

EJB 3
Introduction to JavaEE
The Need for JavaEE.
Overview on the JavaEE Architecture
1 tier
2 tier
3 tier
N tier
JavaEE Key Standards

Introduction to EJB3
The EJB Model
Key Services of the Application Server

Developing Session Beans

Stateless Session Beans

Stateful Session Beans

Packaging
Writing Clients

Using Dependency Injection

No More JNDI
Injection of EJBContext

JMS
JMS Overview
JMS Messaging Domains
Example of JMS using Queue
Example of JMS using Topic

Message Driven Beans

Persistence Introduction to JPA
Object Relational Mapping
Mapping configurations
Embedded Objects
EJBQL

Web Technology
HTML 5
Introduction to HTML
HTML Tags
Creating Forms
Creating tables
Managing home page

CSS
Introduction to CSS
Three ways to use CSS
CSS Properties
Designing website
Working with Templates

Javascript

Introduction to Javascript
Three ways to use Javascript
Working with events
Client-side Validation

JQuery
Introduction to JQuery
Validation using JQuery
JQuery Forms
JQuery Examples

AJAX
Introduction to AJAX
Servlet and JSP with AJAX
Interacting with database