CORE JAVA

* Basic of Java Programming

o What is a java technology?
o Classes
+ Declaring Members: Fields and Methods
o Objects
+ Classes Instantiation, Reference Values, and References
o Instance Members
+ Invoking Methods
o Static Members
o Inheritance
o Sample Java Applications
+ Essential Elements of a Java Application
+ Compiling and Running an Application
* Language Fundamentals
o Basic Languages Elements
+ Lexical Tokens
+ Identifiers
+ Keywords
+ Literals
+ Integer Literals
+ Floating Point Literals
+ Boolean Literals
+ Character Literals
+ String Literals
o Primitive Data Types
o Variable Declarations
+ Declaring and Initializing Variables
o Initial Values for Variables
* Declarations
o Classes Declarations
o Method Declarations
o Constructors
+ Default Constructors
+ Overloaded Constructors
o Enumerated Types
o Arrays
o Parameter Passing
o The main() Method
* Access Control
o Java Source Files Structure
o Packages
o Scope Rules
o Other Modifiers for Classes
+ Abstract Classes
+ Final Classes
o Member Accessibility Modifiers
o Other Modifiers for Members
* Operators and Expressions
o Conversions
+ Widening and Narrowing Primitive Conversions
+ Widening and Narrowing Reference Conversions
+ Boxing and Unboxing Conversions
o Type Conversion Contexts
o Type Conversion Contexts
o Evaluation Order of Operands
o The Simple Assignment Operator=
o Arithmetic Operators: *,/,%,+,-
o Variable Increment and Decrement Operator:++,--
 o Boolean Expressions
o Relations Operators:<,<=,>,>=
o Equality
o Boolean Logical Operators:!,^,&
o Conditional Operators:&&,||
o The Conditional Operator:?:
* Control Flow
o Overview of Control Flow Statements
o Selection Statements
+ The Simple if Statement
+ The if-else Statement
+ The switch Statement
o Iteration Statements
o Transfer Statements
o Exception Types
o Exception Handling : try, catch , and finally
o The throw Statement
o The throws Statement
* Object-Oriented programming
o Single Implementation Inheritance
+ Inheritance Hierarchy
+ Relationships: is-a and has-a
+ The Supertype - Subtype Relationship
o Overriding Method
+ Instance Method Overriding
+ Covariant return in Overriding Methods
+ Overriding vs. Overloading
o Hiding Members
+ Field Hiding
+ Static Method Hiding
o The Object Reference super
o Chaining Constructors Using this() and super()
o Interfaces
+ Defining Interfaces
+ Abstract Method Declarations
+ Implementing Interfaces
+ Extending Interfaces
+ Interface Reference
+ Constants in Interfaces
o Arrays and Subtyping
+ Arrays and Subtype Conversions
+ Array Store Check
o Reference Values and Conversions
o Method Invocation Conversions Involving References
+ Overloaded Method Resolution
o Reference Casting and the instance of Opertor
+ The Cast Operator
+ The instance of Operator
o Polymorphism and Dynamic Method Lookup
o Inheritance Versus Aggregatio
o Basic Concepts in Object-Oriented Design
+ Encapsulation
+ Cohesion
+ Coupling
* Nested Type Declarations
o Static Member Types
o Non Static Member Classes
o Local Classes
o Anonymous Classes
* Object Lifetime
 o Garbage Collection
o Facilitating Garbage Collection
o bject Finalization
o Finalizer Chaining
o Initializers
o Instance Intializer Blocks
o Constructing Initial Object State
* Fundamental Classes
o Overview of the java.lang Package
o The Object Class
o The Wrapper Classes
o The String Classes
+ Immutability
+ Creating and Initializing Strings
+ Creating and Initializing Strings
+ Reading Characters from a String
+ Comparing Strings
+ Concatenation of strings
+ Extracting Substrings
+ Formatting Values
+ Pattern Matching
* Files and Streams
o Input and Output
o The File Class
o Byte Streams: I/O Streams
o Character Streams:Readers and Writers
o The Console class
o Object Serialization
+ The ObjectOutputStream Class
+ The ObjectInputStream Class
+ Customizing Object Serialization
+ Serialization and Inheritance
* Localization, Pattern Matching and Formatting
o The java.util.Locale Class
o The java.util.Date Class
o The java.util.Calendar Class
+ Static Factory Methods to Create a Calender
+ Interoperability
+ Selected get and set Methods
+ Manipulating a Calender
+ Comparing Calenders
o The java.text.dateformat Class
+ Static Factory methods to Create a date / Time Formatter
+ Formatting Dates
+ Parsing String to Date/Time
+ Managing the Calender and the Number Formatter
o The java.text.Numberformat Class
+ Static Factory methods to Create a Number Formatter
+ Formatting Numbers and Currency
+ Parsing Strings to Numbers
+ Specifying the Number of Digits
o String Pattern Matching using Regular Expressions
+ Regular Expression Fundamentals
+ Escaping Metacharacters
+ The java.util.regex.Pattern Class
+ The java.util.Scanner Class
o Formatting Values
* Threads
o Multitasking
o Overview of Threads
 o The Main Method
o Thread Creation
+ Implementing the runnable Interface
+ Extending the Thread Class]
o Synchronization
+ Locks
+ Synchronized Methods
+ Synchronized Blocks
o Thread Transition
+ Thread States
+ Thread Priorities
+ Thread Scheduler
+ Running and Yielding
+ Sleeping and Walking
+ Waiting and Notifying
+ Joining
+ Blocking for I/O
+ Thread Termination
+ Deadlocks
* Generics
o Introducing Generics
o Generic Types and Parameterized Types
o Collections and Generics
o Wildcards Types
o Using References of Wildcard Parameterized Types
o Bounded Type Parameters
* Collections and Maps
o Comparing Objects
+ The equals() Method
+ The hashCode() Method
+ The Comparable<E> Interface
+ The Comparator<E> interface
o The java Collections Interface
+ Core Interfaces
+ Implementations
o Collections
o Sets
+ The hashset <E> and LinkedHashSet <E> Classes
o The SortedSet <E> and NavigableSet<E> Interfaces
+ The SortedSet <E> Interface
+ The Navigableset<E> Interface
+ The TreeSet<E> Class
o Lists
+ The ArrayList<E>.LinkedList<e>,and Vector<E> Classes
o Queues
+ The Queue <E> Interface
+ The PriorityQueue<E> and LinkedList<E> Classes
+ The DeQueue<E> Interface
+ The ArrayDeQueue<E> and linked List<E> Interface
o Maps
+ Basic Operations
+ Bulk Operations
+ Collection Views
o Map Implementations
+ The HashMap<K<V>, The LinkedHashMap<K<V>, and Hashtable<K<V> C
lasses
o The SortedMap <K,V> and NavigableMap<K,V> Interfaces
+ The SortedMap<K,V> Interface
+ The NavigableMap<K,V> Interface
+ The TreeMap<K,V> Class
 o Working with Collections
--------------------------------------------------------------------------------
---------------------------------------------------------
ADVANCED JAVA
* Java Servlet Technology
o What is a Servlet?
o Example of Servlets
o Servlet Life Cycle
+ Handling Servlet Life Cycle Events
# Defining The Listener Class
# Specifying Event Listener Class
+ Handling Errors
o Sharing Information
+ Using Scope Objects
+ Controlling Concurrent Access To Shared Resources
+ Accessing Database
o Initializing a Servlet
o Writing Service Methods
+ Getting Information From Request
+ Constructing Responses
o Filtering Requests and Responses
+ Programming Filters
+ Programming Customized Requests and Responses
o Invoking Other Web Resources
+ Including Other Resources In The Response
+ Transferring Control To The other Web Component
o Accessing the Web Context
o Maintaining Client State
+ Accessing A Session
+ Associating Attributes With a Session
+ Session Management
+ Session Tracking
o Finalizing a Servlet
+ Tracking Service Request
+ Notifying Methods To Shut Down
+ Creating Polite Long-running Method

* Java Server Pages Technology

o What is a JSP Page?
o The Life Cycle of a JSP Page
o Translation and Compilation
o Execution
+ Buffering
+ Handling Errors
o Initializing and Finalizing a JSP Page
o Creating Static Content
o Creating Dynamic Content
+ Using Objects Within JSP Pages
# Implicit Objects
# Application Specific Objects
# Shared Objects
# JSP Scripting Elements
# Declarations
# Scriptlets
# Expression
o Including Content in a JSP Page
o Transferring Control to Another Web Component
 + jsp:param Element
o Including an Applet
o Extending Control to Another Web Component

1. Java Beans Components in JSP Pages

o Java Beans Component Design Conventions
o Why use a Java Beans Component?
o Creating and Using a Java Beans Component
o Setting Java Beans Component Properties
o Retrieving Java Beans Component Properties

2. Custom Tags in JSP Pages

o What is a Custom Tags?
o Using Tags
+ Declaring Tag Libraries
+ Making the Tag Library Implementation Available
+ Types of Tags
# Simple Tags
# Tags With Attributes
# Tags With Bodies
# Tags that Define Scripting Variables
# Cooperating Tags
o Defining Tags
o Tag Handler
o Tag Library Descriptors
+ Listener Element
+ Tag Element
o Simple Tags
+ Tag Handlers
+ Body-Content Element
o Tags With Attributes
+ Defining Attribute in a Tag Handler
+ Attribute Element
+ Attribute Validation
o Tags with Bodies
+ Tag Handlers
+ Body-Content Element
o Tags that Define Scripting Variables
+ Tag Handlers
+ Providing Information about the Scripting Variable
o Cooperating tags

3. Java Server Pages Standard Tag Library

o Using JSTL
o Using JSTL
o c
+ Twin Libraries
+ JSTL Expression Language
# Attributes
# Implicit Objects
# Literals
# Literals
+ Tag Collaboration
o Core Tags
+ Expression Tags
+ Flow Control Tags
# Conditional Tags
# Iterator Tags
 + URL Tags
o XML Tags
+ Core Tags
+ Flow Control Tags
+ Transformation Tags
o Internationalization Tags
+ Setting the Locale
+ Messaging Tags
+ Formatting Tags
o SQL Tags
+ Query Tag Result Interface
4. Understanding XML
o Introduction to XML
+ What is XML
# Tags and Attributes
# Empty Tags
# Comments In XML Files
# XML Prolog
+ Why is XML Important?
# Plain Text
# Data Identification
# Easily Processed
# Hierarchical
+ How You can use XML
# Traditional Data Processing
# Document-Driven Programmin
# Binding
# Archiving
o XML and Related Specs: Digesting the Alphabet Soup
+ Basic Standards
# SAX
# DOM
# JDOM and dom4j
# DTD
# Namespaces
# XSL
# XSLT
+ Schema Standards
# XML Schema
# RELAX NG
# TREX
# SOX
+ Linking And Presentation Standards
# XML Linking
# XHTML
+ Knowledge Standards
# RDF
# RDF Schema
# XTM
+ Standards That build on XML
# Extended Document Standards
# eCommerce Standards

5. Web Application Security

o User s, Groups and Roles
o Web-Tier Security
o EIS-Tier Security
o Installing and configuring SSL Support on Tomcat
 + Managing Roles and Users
# Using the Tomcat Web Server Administration Tool
# Managing Roles
# Managing Users

6. Enterprise JavaBeans Technolog

o The EJB Containery
o Enterprise Beans
+ Remote and Home Interfaces
+ Business Methods
+ Entity Beans
+ Session Beans
+ Life Cycle Methods
+ Back to the Remote and Home Interfaces
o Enterprise Beans as Distributed Objects

7. Entity Type Enterprise Beans

o Container-Managed Persistence
+ Bean Class
+ Home Interface
+ Remote Interface
+ Callback Methods
o Bean-Managed Persistence
8. Session Type Enterprise Beans
o Stateless Session Beans
o Stateful Session Beans

9. Struts
o
+ Basic Struts
+ The MVC Design Pattern
+ Basic Struts Tags
+ Custom Tags
+ Simple Validation(Action Form)
+ Processing Business Logic(Action)
+ Configuring Struts
+ More Tags
+ Uploading Files
+ Internationalization
o Advanced Struts
+ Tiles
+ The Validator Framework
+ Dynamic Forms

10. Hibernate
o Integrating and configuring Hibernate
o The Persistence Life cycle
o An Overview of mapping
o Mapping With Annotations
o Creating mapping with Hibernate XML Files
o Using the Session Object
o HQL - Hibernate Query Language Overview
o The Criteria API(Advanced Queries)
o Filtering the Results of Searches
 11. Network Programming
o Connection Pooling
o Client-Server Architecture
o Socket Overview
o Networking Classes and Interfaces
o Network Protocols
o Developing Networking Applications in Java

12. RMI(Remote Method Invocation)

o General Concepts of Distributed Applications
o Introduction to Distributed Computing with RMI
o Java RMI Architecture
o Naming Remote Objects
o Using RMI
o RMI Clients-side Callbacks
o Distributing and Installing RMI Software
o Activatable RMI

13. Java Mail API

o Introducing the Java Mail API
o Reviewing Related Protocols
+ SMTP
+ POP
+ IMAP
+ MIME
+ NNTP and Others
o Installing
+ Installing the JavaBeans Activation Framework
+ Using with the Java 2 Enterprise Edition
o Reviewing the Core Classes
+ Session
+ Message
+ Address
+ Authenticator
+ Transport
+ Store and Folder
+ Moving On
o Using the JavaMail API
+
# Sending Messages
# Fetching Messages
# Deleting Messages and Flags
# Authenticating Yourself
# Replying to Messages
# Forwarding Messages
# Working with Attachments
* Sending Attachments
* Getting Attachments
# Processing HTML Messages
* Sending HTML Messages
* Including Images with Your Messages
o Searching with SearchTerm

14. DataBase Programming using JDBC

o Introduction to JDBC
o JDBC Drivers & Architecture
o Overview of Database Driver Architecture
 o Introduction to JDBC Standard Extension API (javax.sql)
o Connecting a Java program to a database
o Talking to a Database
+ Database Updates
+ Database Queries
+ Prepared Statements
o Metadata
+ Information about a database
+ Information about a table within a database
o Transactions
o Batch Processing
o Java-SQL Type Equivalence
o JDBC Exception Types
+ SQLExceptions
+ SQLWarnings
+ Data Truncation
o Connection Pooling
o Working with Streams

http://brainvista.com/bv/search.php?page=15
Substitute digits for the letters in multiplication

Syllabus For Elitmus Test

Hello friends,Here i am providing syllabus for elitnus test,whch may b helpful f
or you .As we know elitnus test has 3 sections1>quantitative.2> DI and Logical R
easoning3>Verbal communication These 3-section have a time limit of 3-hours.
Exame Pattern:
Total 3 sections:Section 1:
Quant Section
( 20 Questions)Number System work and time permutation geometrySection 2:
DI and Logical Reasoning
( 20 Questions)DI- tabular data with conditions 5 questionsArrangement ( visitin
g 3 villages each day, 5 villages... with lots of conditions) 3 questionsCoding/
Decoding based on multiplicationSection 3:
Verbal (
20 Questions)3 RC 4 question in eachparagraph formationfill in the blank ( appro
priate word)gramma