JAVA

Lean Six Sigma Green Belt Certification Workshop Pune

2011-04-26T08:52:00.000-07:00

4 Day Lean Six Sigma Green Belt Certification Workshops

Pune

Workshop Dates:

Workshop 1 - 14th, 15th, 21st and 22nd May 2011

Workshop 2 – 04th, 05th, 11th and 12th June 2011

Note: The workshops have been scheduled on weekends specifically to accommodate working professionals

Batch Size: maximum of 10 participants per workshop

Last date for registration:

Workshop 1 – 5th May 2011

Workshop 2 – 23rd May 2011

Workshop Timings:

9:30 am to 6:00pm

Workshop Venue:

Premium Business Hotel in Pune

For registrations:

Email us at contactus@morpheusarchetypes.com

Call us on 020-41322100 / 9860361610 / 9049392089

Nilesh Chavan

Head - Process Consulting Group

Morpheus Archetypes Management Solutions Pvt. Ltd.

Ohio Treatment Centers Are ready to co-opearte with you

2011-04-14T23:23:00.000-07:00

Today, there is a huge craze of the drug rehab program for the better recovery from the problem of drug addiction. Drug addiction is the most dangerous problem which is mostly occurred among the young generation of the modern era in an eminent manner. This problem is mostly seen on most of the people of the modern era currently.

Ohio treatment centers are the centers which are mainly established for the purpose of treating the problems like drug addiction in an efficient manner. The Ohio treatment centers are actually the online directory of the centers for the drug addiction removal problems.

The Ohio treatment centers generally make use of the several sorts of useful drug rehab programs which plays a vital role in the treatment of the problems mentioned above. The entire abuse treatment center generally possesses a great specialization in their drug addiction removal by the use of genuine drug rehab programs of the centre.

One can easily fill the online registration form and avail for the requisite drug addiction treatment after a proper visit on the sites offering the same. So, it is better for the user to have an easy visit on the site and opt for the genuine program for treating the drug addiction problems in an efficient manner.

Access different file formats in Java

2009-09-14T00:13:00.001-07:00

How do I access the XYZ file format in java?

Specifications for many file formats can be found at Wotsit. A large database of file types can be found at www.file-extensions.org. Marco Schmidt maintains several very useful lists of links about processing a multitude of document formats.

An interesting article about Microsoft's binary file formats, especially DOC and XLS, is Why are the Microsoft Office file formats so complicated? (And some workarounds) It also mentions some alternatives to dealing with those formats directly.

Access

JDBC/ODBC bridge - JDBC driver for ODBC databases, comes as part of the JDK; on Linux, you'll have to get ODBC up and running first: http://www.unixodbc.org/
Jackcess - library to read and write MDB files
HXTT Access - commercial pure Java JDBC driver for MS Access

CGM

cgmva - an applet to display CGM files; comes with source code

CHM

JChm - library to read CHM files

Excel

Ostermiller Utils, CSVObjects, CSVBeans and opencsv - libraries to read and write CSV files. CSV is not as easy to read and write as it first looks - once all the special cases are considered, one might as well use a library.
POI - library to read and write XLS files
JExcelAPI - library to read and write XLS files
Opinions on jExcelApi vs. POI: here and here
jXLS - library for writing XLS files based on templates
Java2Excel - library for creating Excel files based on Collections
It is possible to use JDBC to read Excel files
Obba works with Excel spreadsheets on Windows
OpenXLS - "OpenXLS is the open source version of ExtenXLS - a Java spreadsheet SDK that allows you to read, modify and create Java Excel spreadsheets from your Java applications."

HDF (Hierarchical Data Format)

Java products by the HDF Group

Image files

ImageJ - Java image processing application and library that has plugins for lots of image file formats
JIMI - library to read and write BMP, CUR, GIF, ICO, JPEG, PICT, PNG, PSD, Sun Raster, TGA, TIFF, XBM and XPM. There's a plugin for using JIMI with ImageJ, which also includes a couple of JIMI patches.
GIF write, and TIFF, RAW, PNM and JPEG2000 read/write support for ImageIO

Matlab

JMatIO - Matlab's MAT-file I/O in JAVA

OpenDocument (ODF)

basic Java code for reading ODF files is here
ODFDOM is a Java library for accessing ODF files.
jDocument.org has an open-source library for accessing all Open Document file types.
Obba works with OpenOffice? spreadsheets

Office Open XML

These are the new XML-based Microsoft Office formats.
OpenXML4J
docx4j - create and edit docx documents using a JAXB content model matching the WordML schema
Apache POI 3.5 (which is in beta, but is usable already) implements these formats.

OpenOffice Java API

OpenOffice can read a number of file formats, and makes them accessible through its API. A starting point might be this article, this article and of course the OO developer site
Some introductory information about the OO file format can be found here and here
oooview is an OO Viewer written in Java.
JODConverter is a Java library that uses the OO Java API to perform document conversions between any formats supported by OO

Outlook MSG

The Jakarta POI project developed some code that can read the texual contents of Outlook's MSG files. This page talks about that.

PDF

PDF is a hard to read format. The best one can do is try to extract the text contained in a PDF file.
iText - library to create PDFs
FOP - libray to create PDFs (and other formats) from XML by using XSL-FO transformations
FlyingSaucer - library to convert CSS-styled XHTML to PDF
PDFBox - library to create PDFs; can also extract text
PDF Clown - general-purpose library to read/create/modify PDF files. It features a rich multi-layered object model that allows access even to each single content stream instruction. wikipedia article
JPedal - library to extract text from PDFs
PDFTextStream - commercial library to extract text from PDFs
Adobe AcrobatViewer for JavaBean - freeware, library to display and print PDFs; introductory article ; this library hasn't been updated in a long time and has problems displaying files that were created with recent PDF versions.
PDF Renderer is a more up-to-date PDF viewer that renders using Java2D. It can also be used to print PDFs.

PowerPoint

The Jakarta POI project developed some code that can open and (to a limited extent) edit PPT files. This page talks about it.

Project

The MPXJ library can work with several Project file formats.

QIF (used by Microsoft Money and Quicken)

Buddi and Eurobudget are Java applications that can import and export QIF files (and thus contain code you may be able to use in your application). Both are licensed under the GPL.

RTF

iText - library to create RTFs
JavaCC - is a lexer/parser for which an RTF grammar is available. From that an RTF reader can be constructed.

Visio

The Jakarta POI project developed some code that can read Visio files. This page talks about that.

Word

POI - library to read and write DOC files. (Note that according to the POI-Dev mailing list this is unmaintained code. If it works for you - great, if not, then it will likely not be fixed soon.) Slow progress is being made, though, and it can be used for extracting the text of a document.
docx4j - for docx files (as opposed to doc files)
WordApi.exe is native Windows component with a Java interface, which lets you create Word documents, and alter word templates. Some impressions about it can be found here.

Something else?

If you encounter an obscure format for which no library is available, it may be feasible to create a reader for it if you have a file format description (which may be available on Wotsit, see link above). Several libraries, so-called lexers and parsers, are available that help in creating a reader, especially if the file format is ASCII, and not binary. You will need knowledge of regular expressions, though. Some file formats that have been tackled using this approach include RTF, CSV, HPGL and PBM/PGM/PPM. Lexers are easier to start with, but parsers can do more of the work for you. All these have ready-to-use examples on their web sites.

Lexers: JFlex (introductory article in the JavaRanch Journal)
Parsers: Antlr, SableCC, JavaCC

The markup in the document preceeding the root element must be well-formed

2009-08-21T09:05:00.000-07:00

Check if this is correct:

1) All text content must be between a start and an end tag
2) The document must have 1 root element
3) every start tag must have a matching end tag

Directory structure of a web application, WEB-INF

2009-08-21T03:49:00.001-07:00

The directory structure of a web application consists of two parts.
A private directory called WEB-INF
A public resource directory which contains public resource folder.

WEB-INF folder consists of
1. web.xml
2. classes directory
3. lib directory

Life cycle methods of a Servlet

2009-08-21T03:46:00.000-07:00

The javax.servlet.Servlet interface defines the three methods known as life-cycle method.
public void init(ServletConfig config) throws ServletException
public void service( ServletRequest req, ServletResponse res) throws ServletException, IOException
public void destroy()
First the servlet is constructed, then initialized wih the init() method.
Any request from client are handled initially by the service() method before delegating to the doXxx() methods in the case of HttpServlet.

The servlet is removed from service, destroyed with the destroy() methid, then garbaged collected and finalized

Methods of the javax.servlet.Servlet interface

2009-08-21T03:42:00.001-07:00

init() This method is called by the servlet container to indicate to the servlet
that it must initialize itself and get ready for service. The container
passes an object of type ServletConfig as a parameter.

service() This method is called by the servlet container for each request from the
client to allow the servlet to respond to the request.

destroy() This method is called by the servlet container to indicate to the servlet
that it must clean up itself, release any required resources, and get ready
to go out of service.

getServletConfig() Returns information about the servlet, such as a parameter to the
init() method.

getServletInfo() The implementation class must return information about the servlet,
such as the author, the version, and copyright information

Communicating with Objects by Waiting and Notifying

2009-08-21T03:21:00.000-07:00

The wait() method lets a thread to be added to a waiting pool, unless it is invoked again to run
The notify() method is used to send a signal to one and only one of the threads that are waiting in that same object's waiting pool.
The notify() method can NOT specify which waiting thread to notify.
The method notifyAll() works in the same way as notify(), only it sends the signal to all of the threads waiting on the object.
All three methods—wait(), notify(), and notifyAll()—must be called from within a synchronized context! A thread invokes wait() or notify() on a particular object, and the thread must currently hold the lock on that object.

Concurrent Access Problems ,Synchronized Threads

2009-08-21T03:20:00.000-07:00

synchronized methods prevent more than one thread from accessing an object's critical method code simultaneously.
You can use the synchronized keyword as a method modifier, or to start a synchronized block of code.
To synchronize a block of code (in other words, a scope smaller than the whole method), you must specify an argument that is the object whose lock you want to synchronize on.
While only one thread can be accessing synchronized code of a particular instance, multiple threads can still access the same object's unsynchronized code.
When a thread goes to sleep, its locks will be unavailable to other threads.
static methods can be synchronized, using the lock from the java.lang.Class instance representing that class.

Sleep, Yield, and Join

2009-08-21T03:18:00.000-07:00

Sleeping is used to delay execution for a period of time, and no locks are released when a thread goes to sleep.
A sleeping thread is guaranteed to sleep for at least the time specified in the argument to the sleep() method (unless it's interrupted), but there is no guarantee as to when the newly awakened thread will actually return to running.
The sleep() method is a static method that sleeps the currently executing thread's state. One thread cannot tell another thread to sleep.
The setPriority() method is used on Thread objects to give threads a priority of between 1 (low) and 10 (high), although priorities are not guaranteed, and not all JVMs recognize 10 distinct priority levels—some levels may be treated as effectively equal.
If not explicitly set, a thread's priority will have the same priority as the priority of the thread that created it.
The yield() method may cause a running thread to back out if there are runnable threads of the same priority. There is no guarantee that this will happen, and there is no guarantee that when the thread backs out there will be a different thread selected to run. A thread might yield and then immediately reenter the running state.
The closest thing to a guarantee is that at any given time, when a thread is running it will usually not have a lower priority than any thread in therunnable state. If a low-priority thread is running when a high-priority thread enters runnable, the JVM will usually preempt the running low-priority thread and put the high-priority thread in.
When one thread calls the join() method of another thread, the currently running thread will wait until the thread it joins with has completed.

Transitioning Between Thread States, Thread States

2009-08-21T03:16:00.000-07:00

Once a new thread is started, it will always enter the runnable state.
The thread scheduler can move a thread back and forth between the runnable state and the running state.
For a typical single-processor machine, only one thread can be running at a time, although many threads may be in the runnable state.
There is no guarantee that the order in which threads were started determines the order in which they'll run.
There's no guarantee that threads will take turns in any fair way. It's up to the thread scheduler, as determined by the particular virtual machine implementation. If you want a guarantee that your threads will take turns regardless of the underlying JVM, you can use the sleep() method. This prevents one thread from hogging the running process while another thread starves. (In most cases, though, yield() works well enough to encourage
your threads to play together nicely.)
A running thread may enter a blocked/waiting state by a wait(), sleep(), or join() call.
A running thread may enter a blocked/waiting state because it can't acquire the lock for a synchronized block of code.
When the sleep or wait is over, or an object's lock becomes available, thethread can only reenter the runnable state. It will go directly from waiting to running (well, for all practical purposes anyway).
A dead thread cannot be started again

Defining, Instantiating, Starting Threads

2009-08-21T03:10:00.000-07:00

Threads can be created by extending Thread and overriding the public void run() method.
Thread objects can also be created by calling the Thread constructor that takes a Runnable argument. The Runnable object is said to be the target of the thread.
You can call start() on a Thread object only once. If start() is called more than once on a Thread object, it will throw a RuntimeException.
It is legal to create many Thread objects using the same Runnable object as the target.
When a Thread object is created, it does not become a thread of execution until its start() method is invoked. When a Thread object exists but hasn't been started, it is in the new state and is not considered alive.

Utility Classes: Collections and Arrays

2009-08-21T03:07:00.000-07:00

Both of these java.util classes provide
A sort() method. Sort using a Comparator or sort using natural order.
A binarySearch() method. Search a pre-sorted array or List.
Arrays.asList() creates a List from an array and links them together.
Collections.reverse() reverses the order of elements in a List.
Collections.reverseOrder() returns a Comparator that sorts in reverse.
Lists and Sets have a toArray() method to create arrays

Sorting and Searching Arrays and Lists

2009-08-21T03:06:00.000-07:00

Sorting can be in natural order, or via a Comparable or many Comparators.
Implement Comparable using compareTo(); provides only one sort order.
Create many Comparators to sort a class many ways; implement compare().
To be sorted and searched, a List's elements must be comparable.
To be searched, an array or List must first be sorted

Key Attributes of Common Collection Classes

2009-08-21T03:04:00.000-07:00

ArrayList: Fast iteration and fast random access.
Vector: It's like a slower ArrayList, but it has synchronized methods.
LinkedList: Good for adding elements to the ends, i.e., stacks and queues.
HashSet: Fast access, assures no duplicates, provides no ordering.
LinkedHashSet: No duplicates; iterates by insertion order.
TreeSet: No duplicates; iterates in sorted order.
HashMap: Fastest updates (key/value pairs); allows one null key,many null values.
Hashtable: Like a slower HashMap (as with Vector, due to its synchronized methods). No null values or null keys allowed.
LinkedHashMap: Faster iterations; iterates by insertion order or last accessed;allows one null key, many null values.
TreeMap: A sorted map.
PriorityQueue: A to-do list ordered by the elements' priority.

Collections

2009-08-21T02:45:00.000-07:00

Common collection activities include adding objects, removing objects, verifying object inclusion, retrieving objects, and iterating.
Three meanings for "collection":
* collection: Represents the data structure in which objects are stored
* Collection: java.util interface from which Set and List extend
* Collections: A class that holds static collection utility methods

Four basic flavors of collections include Lists, Sets, Maps, Queues:
* Lists of things Ordered, duplicates allowed, with an index.
* Sets of things May or may not be ordered and/or sorted; duplicates
not allowed.
* Maps of things with keys May or may not be ordered and/or sorted;duplicate keys are not allowed.
* Queues of things to process Ordered by FIFO or by priority.

Four basic sub-flavors of collections Sorted, Unsorted, Ordered, Unordered.
* Ordered Iterating through a collection in a specific, non-random order.
* Sorted Iterating through a collection in a sorted order.
* Sorting can be alphabetic, numeric, or programmer-defined

Overriding hashCode() and equals()

2009-08-21T02:37:00.000-07:00

* equals(), hashCode(), and toString() are public.
* Override toString() so that System.out.println() or other methods can see something useful, like your object's state.
* Use == to determine if two reference variables refer to the same object.
* Use equals() to determine if two objects are meaningfully equivalent.
* If you don't override equals(), your objects won't be useful hashing keys.
* If you don't override equals(), different objects can't be considered equal.
* Strings and wrappers override equals() and make good hashing keys.
* When overriding equals(), use the instanceof operator to be sure you're evaluating an appropriate class.
* When overriding equals(), compare the objects' significant attributes.
* Highlights of the equals() contract:
Reflexive: x.equals(x) is true.
Symmetric: If x.equals(y) is true, then y.equals(x) must be true.
Transitive: If x.equals(y) is true, and y.equals(z) is true,then z.equals(x) is true.
Consistent: Multiple calls to x.equals(y) will return the same result.
Null: If x is not null, then x.equals(null) is false.
If x.equals(y) is true, then x.hashCode() == y.hashCode() is true.
If you override equals(), override hashCode().

*HashMap, HashSet, Hashtable, LinkedHashMap, & LinkedHashSet use hashing.
* An efficient hashCode() override distributes keys evenly across its buckets.
* An overridden equals() must be at least as precise as its hashCode() mate.
* To reiterate: if two objects are equal, their hashcodes must be equal.
* It's legal for a hashCode() method to return the same value for all instances
(although in practice it's very inefficient).

Highlights of the hashCode() contract:
* Consistent: multiple calls to x.hashCode() return the same integer.
* If x.equals(y) is true, x.hashCode() == y.hashCode() is true.
q If x.equals(y) is false, then x.hashCode() == y.hashCode() can be either true or false, but false will tend to create better efficiency.
* transient variables aren't appropriate for equals() and hashCode().

Serialization

2009-08-21T02:14:00.000-07:00

The classes you need to understand are all in the java.io package; they include: ObjectOutputStream and ObjectInputStream primarily, and FileOutputStream and FileInputStream because you will use them to create the low-level streams that the ObjectXxxStream classes will use.
* A class must implement the Serializable interface before its objects can be
serialized.
* The ObjectOutputStream.writeObject() method serializes objects, and the ObjectInputStream.readObject() method deserializes objects.
* If you mark an instance variable transient, it will not be serialized even thought the rest of the object's state will be.
* You can supplement a class's automatic serialization process by implementing the writeObject() and readObject() methods. If you do this, embedding calls to defaultWriteObject() and defaultReadObject(), respectively, will handle the part of serialization that happens normally.
* If a superclass implements Serializable, then its subclasses do automatically.
* If a superclass doesn't implement Serializable, then when a subclass object is deserialized, the superclass constructor will run.

Using String, StringBuffer, and StringBuilder

2009-08-21T02:12:00.000-07:00

String objects are immutable, and String reference variables are not.
If you create a new String without assigning it, it will be lost to your program.
If you redirect a String reference to a new String, the old String can be lost.
String methods use zero-based indexes, except for the second argument of substring().
The String class is final—its methods can't be overridden.
When the JVM finds a String literal, it is added to the String literal pool.
Strings have a method: length(), arrays have an attribute named length.
The StringBuffer's API is the same as the new StringBuilder's API, except that StringBuilder's methods are not synchronized for thread safety.
StringBuilder methods should run faster than StringBuffer methods.
All of the following bullets apply to both StringBuffer and StringBuilder:
* They are mutable—they can change without creating a new object.
* StringBuffer methods act on the invoking object, and objects can change without an explicit assignment in the statement.
* StringBuffer equals() is not overridden; it doesn't compare values.
* Remember that chained methods are evaluated from left to right.
* String methods to remember: charAt(), concat(), equalsIgnoreCase(), length(), replace(), substring(), toLowerCase(), toString(), toUpperCase(), and trim().
* Stringbuffer methods to remember: append(), delete(), insert(), reverse(), and toString()

Handling Exceptions, Exception Handling, Exceptions

2009-08-21T02:03:00.000-07:00

Exceptions come in two flavors: checked and unchecked.

Checked exceptions include all subtypes of Exception, excluding classes that extend RuntimeException.

Checked exceptions are subject to the handle or declare rule; any methodthat might throw a checked exception (including methods that invoke methods that can throw a checked exception) must either declare the exception using throws, or handle the exception with an appropriate try/catch.
Subtypes of Error or RuntimeException are unchecked, so the compiler doesn't enforce the handle or declare rule. You're free to handle them, or to declare them, but the compiler doesn't care one way or the other.
If you use an optional finally block, it will always be invoked, regardless of whether an exception in the corresponding try is thrown or not, and regardless of whether a thrown exception is caught or not.
The only exception to the finally-will-always-be-called rule is that a finally will not be invoked if the JVM shuts down. That could happen if code from the try or catch blocks calls System.exit().
Just because finally is invoked does not mean it will complete. Code in the finally block could itself raise an exception or issue a System.exit().
Uncaught exceptions propagate back through the call stack, starting from the method where the exception is thrown and ending with either the first method that has a corresponding catch for that exception type or a JVM shutdown (which happens if the exception gets to main(), and main() is "ducking" the exception by declaring it).
You can create your own exceptions, normally by extending Exception or one of its subtypes. Your exception will then be considered a checked exception, and the compiler will enforce the handle or declare rule for that exception.
All catch blocks must be ordered from most specific to most general.
If you have a catch clause for both IOException and Exception, you must put the catch for IOException first in your code. Otherwise, the IOException would be caught by catch(Exception e), because a catch argument can catch the specified exception or any of its subtypes! The compiler will stop you from defining catch clauses that can never be reached.
Some exceptions are created by programmers, some by the JVM.

Unchecked exceptions :

represent defects in the program (bugs) - often invalid arguments passed to a non-private method. To quote from The Java Programming Language, by Gosling, Arnold, and Holmes : "Unchecked runtime exceptions represent conditions that, generally speaking, reflect errors in your program's logic and cannot be reasonably recovered from at run time."
are subclasses of RuntimeException, and are usually implemented using IllegalArgumentException, NullPointerException, or IllegalStateException
a method is not obliged to establish a policy for the unchecked exceptions thrown by its implementation (and they almost always do not do so)

Checked exceptions :

represent invalid conditions in areas outside the immediate control of the program (invalid user input, database problems, network outages, absent files)
are subclasses of Exception
a method is obliged to establish a policy for all checked exceptions thrown by its implementation (either pass the checked exception further up the stack, or handle it somehow)

Try, Catch , Finally

2009-08-21T00:55:00.000-07:00

It is illegal to use a try clause without either a catch clause or a finally
clause. A try clause by itself will result in a compiler error. Any catch clauses must
immediately follow the try block. Any finally clause must immediately follow the last
catch clause (or it must immediately follow the try block if there is no catch). It is legal
to omit either the catch clause or the finally clause, but not both

Initialization Blocks

2009-08-21T00:45:00.000-07:00

Static initialization blocks run once, when the class is first loaded.
Instance initialization blocks run every time a new instance is created. They run after all super-constructors and before the constructor's code has run.
If multiple init blocks exist in a class, they follow the rules stated above, AND they run in the order in which they appear in the source file

Passing Variables into Methods

2009-08-21T00:43:00.000-07:00

Methods can take primitives and/or object references as arguments.
Method arguments are always copies.
Method arguments are never actual objects (they can be references to objects).
A primitive argument is an unattached copy of the original primitive.
A reference argument is another copy of a reference to the original object

Using a Variable or Array Element That Is Uninitialized and Unassigned

2009-08-21T00:42:00.000-07:00

When an array of objects is instantiated, objects within the array are not instantiated automatically, but all the references get the default value of null.
When an array of primitives is instantiated, elements get default values.
Instance variables are always initialized with a default value.
qLocal/automatic/method variables are never given a default value. If you attempt to use one before initializing it, you'll get a compiler error

Object Creation

2009-08-21T00:38:00.001-07:00

When creating a new object, e.g., Button b = new Button();, three
things happen:
Make a reference variable named b, of type Button
Create a new Button object
Assign the Button object to the reference variable b

Scope

2009-08-21T00:36:00.000-07:00

Scope refers to the lifetime of a variable.
There are four basic scopes:
Static variables live basically as long as their class lives.
Instance variables live as long as their object lives.
Local variables live as long as their method is on the stack; however, if their method invokes another method, they are temporarily unavailable.
Block variables (e.g.., in a for or an if) live until the block completes

Stack and Heap

2009-08-21T00:32:00.000-07:00

Local variables (method variables) live on the stack.
Objects and their instance variables live on the heap

Coupling and Cohesion, Coupling, Cohesion

2009-08-20T23:36:00.003-07:00

Coupling refers to the degree to which one class knows about or uses members of another class.
Loose coupling is the desirable state of having classes that are well encapsulated, minimize references to each other, and limit the breadth of API usage.
Tight coupling is the undesirable state of having classes that break the rules of loose coupling.
Cohesion refers to the degree in which a class has a single, well-defined role or responsibility.
High cohesion is the desirable state of a class whose members support a single, well-focused role or responsibility.
Low cohesion is the undesirable state of a class whose members support multiple, unfocused roles or responsibilities.

Statics

2009-08-20T23:36:00.001-07:00

Use static methods to implement behaviors that are not affected by the state of any instances.
Use static variables to hold data that is class specific as opposed to instance specific—there will be only one copy of a static variable.
All static members belong to the class, not to any instance.
A static method can't access an instance variable directly.
Use the dot operator to access static members, but remember that using a reference variable with the dot operator is really a syntax trick, and the compiler will substitute the class name for the reference variable, for instance:
d.doStuff();
becomes:
Dog.doStuff();
static methods can't be overridden, but they can be redefined.

Constructors and Instantiation

2009-08-20T23:35:00.000-07:00

You cannot create a new object without invoking a constructor.
Each superclass in an object's inheritance tree will have a constructor called.
Every class, even an abstract class, has at least one constructor.
Constructors must have the same name as the class.
Constructors don't have a return type. If the code you're looking at has a return type, it's a method with the same name as the class, and a constructor.
Typical constructor execution occurs as follows:
The constructor calls its superclass constructor, which calls its superclass constructor, and so on all the way up to the Object constructor.
The Object constructor executes and then returns to the calling constructor, which runs to completion and then returns to its calling
constructor, and so on back down to the completion of the constructor of the actual instance being created.
Constructors can use any access modifier (even private!).
The compiler will create a default constructor if you don't create any constructors in your class.
The default constructor is a no-arg constructor with a no-arg call to super().
The first statement of every constructor must be a call to either this(), (an overloaded constructor), or super().
The compiler will add a call to super() if you do not, unless you have already put in a call to this().
Instance members are accessible only after the super constructor runs.
Abstract classes have constructors that are called when a concrete subclass is instantiated.
Interfaces do not have constructors.
If your superclass does not have a no-arg constructor, you must create a constructor and insert a call to super() with arguments matching those
of the superclass constructor.
Constructors are never inherited, thus they cannot be overridden.
A constructor can be directly invoked only by another constructor (using a call to super() or this()).
Issues with calls to this():
May appear only as the first statement in a constructor.
The argument list determines which overloaded constructor is called.
Constructors can call constructors can call constructors, and so on, but sooner or later one of them better call super() or the stack will explode.
Calls to this() and super() cannot be in the same constructor. You can have one or the other, but never both

Return Types

2009-08-20T23:34:00.002-07:00

Overloaded methods can change return types; overridden methods cannot, except in the case of covariant returns.
Object reference return types can accept null as a return value.
An array is a legal return type, both to declare and return as a value.
For methods with primitive return types, any value that can be implicitly converted to the return type can be returned.
Nothing can be returned from a void, but you can return nothing. You're allowed to simply say return, in any method with a void return type, to bust out of a method early. But you can't return nothing from a method with a non-void return type.
Methods with an object reference return type, can return a subtype.
Methods with an interface return type, can return any implementer

Implementing an Interface

2009-08-20T23:34:00.001-07:00

When you implement an interface, you are fulfilling its contract.
You implement an interface by properly and concretely overriding all of the methods defined by the interface.
A single class can implement many interfaces.

Reference Variable Casting, Upcasting, DowncastingReference Variable Casting

2009-08-20T23:33:00.001-07:00

There are two types of reference variable casting: downcasting and upcasting.
Downcasting: If you have a reference variable that refers to a subtype object,you can assign it to a reference variable of the subtype. You must make an explicit cast to do this, and the result is that you can access the subtype's members with this new reference variable.
Upcasting: You can assign a reference variable to a supertype reference variable explicitly or implicitly. This is an inherently safe operation because the assignment restricts the access capabilities of the new variable

Overriding and Overloading, Overloading, Overriding

2009-08-20T23:30:00.002-07:00

Methods can be overridden or overloaded; constructors can be overloaded but not overridden.
Abstract methods must be overridden by the first concrete (nonabstract) subclass.
With respect to the method it overrides, the overriding method
Must have the same argument list
Must have the same return type, except that as of Java 5, the return type can be a subclass—this is known as a covariant return.
Must not have a more restrictive access modifier
May have a less restrictive access modifier
Must not throw new or broader checked exceptions
May throw fewer or narrower checked exceptions, or any unchecked exception.
final methods cannot be overridden.
Only inherited methods may be overridden, and remember that private methods are not inherited.
A subclass uses super.overriddenMethodName() to call the superclass version of an overridden method.

Overloading means reusing amethod name, but with different arguments.
Overloaded methods
Must have different argument lists
May have different return types, if argument lists are also different
May have different access modifiers
May throw different exceptions
Methods from a superclass can be overloaded in a subclass.
Polymorphism applies to overriding, not to overloading
Object type (not the reference variable's type), determines which overridden method is used at runtime.
Reference type determines which overloaded method will be used at compile time.

Polymorphism

2009-08-20T23:30:00.001-07:00

A reference variable is always of a single, unchangeable type, but it can refer to a subtype object.
A single object can be referred to by reference variables of many different types— as long as they are the same type or a supertype of the object.
The reference variable's type (not the object's type), determines which methods can be called!
Polymorphic method invocations apply only to overridden instance methods.

Inheritance

2009-08-20T23:28:00.002-07:00

Inheritance is a mechanism that allows a class to be a subclass of a superclass,and thereby inherit variables and methods of the superclass.
Inheritance is a key concept that underlies IS-A, polymorphism, overriding, overloading, and casting.
All classes (except class Object), are subclasses of type Object, and therefore they inherit Object's methods.

Encapsulation, IS-A, HAS-A

2009-08-20T23:28:00.001-07:00

Encapsulation helps hide implementation behind an interface (or API).
Encapsulated code has two features:
Instance variables are kept protected (usually with the private modifier).
Getter and setter methods provide access to instance variables.
IS-A refers to inheritance.
IS-A is expressed with the keyword extends.
IS-A, "inherits from," and "is a subtype of" are all equivalent expressions.
HAS-A means an instance of one class "has a" reference to an instance of another class.

Declarations and Access Control

2009-08-20T04:19:00.000-07:00

Identifiers
Identifiers can begin with a letter, an underscore, or a currency character.
After the first character, identifiers can also include digits.
Identifiers can be of any length.
JavaBeans methods must be named using camelCase, and depending on the method's purpose, must start with set, get, is, add, or remove.

Declaration Rules
A source code file can have only one public class.
If the source file contains a public class, the filename must match the public class name.
A file can have only one package statement, but multiple imports.
The package statement (if any) must be the first (non-comment) line in a source file.
The import statements (if any) must come after the package and before the class declaration.
If there is no package statement, import statements must be the first (noncomment) statements in the source file, package and import statements apply to all classes in the file.
A file can have more than one nonpublic class.
Files with no public classes have no naming restrictions.

Class Access Modifiers
There are three access modifiers: public, protected, and private.
There are four access levels: public, protected, default, and private.
Classes can have only public or default access.
A class with default access can be seen only by classes within the same package.
A class with public access can be seen by all classes from all packages.
Class visibility revolves around whether code in one class can
Create an instance of another class
Extend (or subclass), another class
Access methods and variables of another class

Class Modifiers (Nonaccess)
Classes can also be modified with final, abstract, or strictfp.
A class cannot be both final and abstract.
A final class cannot be subclassed.
An abstract class cannot be instantiated.
A single abstract method in a class means the whole class must be abstract.
An abstract class can have both abstract and nonabstract methods.
The first concrete class to extend an abstract class must implement all of its abstract methods.

Interface Implementation
Interfaces are contracts for what a class can do, but they say nothing about
the way in which the class must do it.
Interfaces can be implemented by any class, from any inheritance tree.
An interface is like a 100-percent abstract class, and is implicitly abstract whether you type the abstract modifier in the declaration or not.
An interface can have only abstract methods, no concrete methods allowed.
Interface methods are by default public and abstract—explicit declaration of these modifiers is optional.
Interfaces can have constants, which are always implicitly public,static, and final.
Interface constant declarations of public, static, and final are optional in any combination.
A legal nonabstract implementing class has the following properties:
It provides concrete implementations for the interface's methods.
It must follow all legal override rules for the methods it implements.
It must not declare any new checked exceptions for an implementation method.
It must not declare any checked exceptions that are broader than the exceptions declared in the interface method.
It may declare runtime exceptions on any interface method implementation regardless of the interface declaration.
It must maintain the exact signature (allowing for covariant returns)
and return type of the methods it implements (but does not have to declare the exceptions of the interface).
A class implementing an interface can itself be abstract.
An abstract implementing class does not have to implement the interface methods (but the first concrete subclass must).
A class can extend only one class (no multiple inheritance), but it can implement many interfaces.
Interfaces can extend one or more other interfaces.
Interfaces cannot extend a class, or implement a class or interface.

Member Access Modifiers
Methods and instance (nonlocal) variables are known as "members."
Members can use all four access levels: public, protected, default, private.
Member access comes in two forms:
Code in one class can access a member of another class.
A subclass can inherit a member of its superclass.
If a class cannot be accessed, its members cannot be accessed.
Determine class visibility before determining member visibility.
public members can be accessed by all other classes, even in other packages.
If a superclass member is public, the subclass inherits it—regardless of package.
Members accessed without the dot operator (.) must belong to the same class.
this. always refers to the currently executing object.
this.aMethod() is the same as just invoking aMethod().
private members can be accessed only by code in the same class.
private members are not visible to subclasses, so private members cannot be inherited.
Default and protected members differ only when subclasses are involved:
Default members can be accessed only by classes in the same package.
protected members can be accessed by other classes in the same package, plus subclasses regardless of package.
protected = package plus kids (kids meaning subclasses).
For subclasses outside the package, the protected member can be accessed only through inheritance; a subclass outside the package cannot
access a protected member by using a reference to a superclass instance (in other words, inheritance is the only mechanism for a subclass
outside the package to access a protected member of its superclass).
A protected member inherited by a subclass from another package is not accessible to any other class in the subclass package, except for the
subclass' own subclasses.

Local Variables
Local (method, automatic, or stack) variable declarations cannot have access modifiers.
final is the only modifier available to local variables.
Local variables don't get default values, so they must be initialized before use.

Other Modifiers—Members
final methods cannot be overridden in a subclass.
abstract methods are declared, with a signature, a return type, and an optional throws clause, but are not implemented.
abstract methods end in a semicolon—no curly braces.
Three ways to spot a non-abstract method:
The method is not marked abstract.
The method has curly braces.
The method has code between the curly braces.
The first nonabstract (concrete) class to extend an abstract class must implement all of the abstract class' abstract methods.
The synchronized modifier applies only to methods and code blocks.
synchronized methods can have any access control and can also be marked final.
abstract methods must be implemented by a subclass, so they must be inheritable. For that reason:
abstract methods cannot be private.
abstract methods cannot be final.
The native modifier applies only to methods.
The strictfp modifier applies only to classes and methods.

Methods with var-args
As of Java 5, methods can declare a parameter that accepts from zero to many arguments, a so-called var-arg method.
A var-arg parameter is declared with the syntax type... name; for instance:
doStuff(int... x) { }
A var-arg method can have only one var-arg parameter.
In methods with normal parameters and a var-arg, the var-arg must come last.

Variable Declarations
Instance variables can
Have any access control
Be marked final or transient
Instance variables can't be abstract, synchronized, native, or strictfp.
It is legal to declare a local variable with the same name as an instance variable; this is called "shadowing."
final variables have the following properties:
final variables cannot be reinitialized once assigned a value.
final reference variables cannot refer to a different object once the object has been assigned to the final variable.
final reference variables must be initialized before the constructor completes.
There is no such thing as a final object. An object reference marked final does not mean the object itself is immutable.
The transient modifier applies only to instance variables.
The volatile modifier applies only to instance variables.

Array Declarations
Arrays can hold primitives or objects, but the array itself is always an object.
When you declare an array, the brackets can be to the left or right of the variable name.
It is never legal to include the size of an array in the declaration.
An array of objects can hold any object that passes the IS-A (or instanceof)
test for the declared type of the array. For example, if Horse extends Animal, then a Horse object can go into an Animal array.

Static Variables and Methods
They are not tied to any particular instance of a class.
No classes instances are needed in order to use static members of the class.
There is only one copy of a static variable / class and all instances share it.
static methods do not have direct access to non-static members.

Enums
An enum specifies a list of constant values that can be assigned to a
particular type.
An enum is NOT a String or an int; an enum constant's type is the enum
type. For example, WINTER, SPRING, SUMMER, and FALL are of the
enum type Season.
An enum can be declared outside or inside a class, but NOT in a method.
An enum declared outside a class must NOT be marked static, final,abstract, protected, or private.
Enums can contain constructors, methods, variables, and constant class bodies.
enum constants can send arguments to the enum constructor, using the syntax BIG(8), where the int literal 8 is passed to the enum constructor.
enum constructors can have arguments, and can be overloaded.
enum constructors can NEVER be invoked directly in code. They are always called automatically when an enum is initialized.
The semicolon at the end of an enum declaration is optional. These are legal:
enum Foo { ONE, TWO, THREE}
enum Foo { ONE, TWO, THREE};

Basic jar tool commands

2009-08-20T04:11:00.000-07:00

To create a JAR jar -cf MyJar.jar MyClass.class

To extract the contents of a JAR jar -xf MyJar.jar

To view the contents of a JAR jar -tf MyJar.jar

To create a JAR with your own manifest jar -cmf myManifest.mf MyJar.jar MyClass.class

To create a JAR that contains all files within a directory
jar -cf MyJar.jar suncertify/db

static variable

2009-08-20T04:08:00.000-07:00

Also called a class variable. A static variable, much like a static
method, may be accessed from a class directly, even though the class has not been
instantiated. The value of a static variable will be the same in every instance of the
class.

static methods

2009-08-20T04:02:00.001-07:00

The static keyword declares a method that belongs to an entire class (as opposed to belonging to an instance). A class method may be accessed directly from a class, without instantiating the class first

static nested classes

2009-08-20T04:01:00.001-07:00

Static nested classes are the simplest form of inner classes.
They behave much like top-level classes except that they are defined within the scope
of another class, namely the enclosing class. Static nested classes have no implicit
references to instances of the enclosing class and can access only static members and
methods of the enclosing class. Static nested classes are often used to implement
small helper classes such as iterators

SortedMap

2009-08-20T04:00:00.000-07:00

A data structure that is similar to map except the objects are stored in ascending order according to their keys. Like map, there can be no duplicate keys and the objects themselves may be duplicated. One very important difference with SortedMap objects is that the key may not be a null value

Runtime exceptions

2009-08-20T03:59:00.000-07:00

A runtime exception is an exception that does not need to be handled in your program. Usually, runtime exceptions indicate a program bug. These are referred to as unchecked exceptions, since the Java compiler does not force the program to handle them

Overridden methods

2009-08-20T03:58:00.002-07:00

Methods in the parent and subclasses with the same name, parameter list, and return type are overridden

Overloaded methods

2009-08-20T03:58:00.001-07:00

Methods are overloaded when there are multiple methods in the same class with the same names but with different parameter lists

notify() method

2009-08-20T03:57:00.000-07:00

The methods wait() and notify() are instance methods of an object. In the same way that every object has a lock, every object has a list of threads that are waiting for a signal related to the object. A thread gets on this list by executing the wait() method of the object. From that moment, it does not execute any further instructions until some other thread calls the notify() method of the same object.

Local variable

2009-08-20T03:56:00.000-07:00

A local variable is a variable declared within a method. These are also known as automatic variables. Local variables, including primitives, must be initialized before you attempt to use them (though not necessarily on the same line of code).

Local inner classes

2009-08-20T03:55:00.002-07:00

You can define inner classes within the scope of a method, or even smaller blocks within a method. We call this a local inner class, and they are often also anonymous classes. Local inner classes cannot use local variables of the method unless those variables are marked final

java.lang package

2009-08-20T03:55:00.001-07:00

The java.lang package defines classes used by all Java programs. The package defines class wrappers for all primitive types such as Boolean, Byte, Character, Double, Float, Integer, Long, and Short, as well as String, Thread, and Object. Unlike classes in any other package, classes in the java.lang package may be referred to by just their class name, without having to use an import statement

Java Virtual Machine (JVM)

2009-08-20T03:54:00.000-07:00

A program that interprets and executes Java bytecode (in most cases, the bytecode that was generated by a Java compiler). The Java VM provides a variety of resources to the applications it is executing, including memory management, network access, hardware abstraction, and so on. Because it provides a consistent environment for Java applications to run in, the Java VM is
the heart of the “write once run anywhere” strategy that has made Java so popular

Iterator

2009-08-20T03:52:00.000-07:00

An iterator provides the necessary behavior to get to each element in a collection without exposing the collection itself. In classes containing and manipulating collections, it is good practice to return an iterator instead of the collection containing the elements you want to iterate over. This shields clients from internal changes to the data structures used in your classes

Interface

2009-08-20T03:51:00.002-07:00

An interface defines a group of methods, or a public interface, that must be implemented by any class that implements the interface. An interface allows an object to be treated as a type declared by the interface implemented

instanceof operator

2009-08-20T03:51:00.001-07:00

The instanceof comparison operator is available for object variables. The purpose of this operator is to determine whether an object is of a given class or interface type (or any of the subtypes of that type).
This comparison may not be made on primitive types and will result in a compile-time
error if it is attempted

Instance variable

2009-08-20T03:32:00.000-07:00

An instance variable is belongs to an individual object. Instance variables may be accessed from other methods in the class, or from methods in other classes (depending on the access control). Instance variables may not be accessed from static methods, however, because a static method could be invoked when no instances of the class exist. Logically, if no instances exist, then the instance variable will also not exist, and it would be impossible to access the instance variable.

Inner classes

2009-08-20T03:31:00.001-07:00

Inner classes are a type of class and follow most of the same rules as a normal class. The main difference is an inner class is declared within the curly braces of a class or even within a method. Inner classes are also classes defined at a scope smaller than a package. See also Anonymous inner classes; Local inner classes;
Member inner classes. Static inner classes are not actually inner classes, but are considered top-level nested classes.

Inheritance

2009-08-20T03:30:00.000-07:00

Inheritance is an object-oriented concept that provides for the reuse and modification of an existing type in such a way that many types can be manipulated as a single type. In Java, inheritance is achieved with the extends keyword.

Identifiers

2009-08-20T03:29:00.001-07:00

Identifiers are names that we assign to classes, methods, and variables.
Java is a case-sensitive language, which means identifiers must have consistent capitalization throughout. Identifiers can have letters and numbers, but a number may not begin the identifier name. Most symbols are not allowed, but the dollar sign ($) and underscore (_) symbols are valid. See also Reference variable

Heap

2009-08-20T03:28:00.003-07:00

Java manages memory in a structure called a heap. Every object that Java creates is allocated in the heap, which is created at the beginning of the application and managed automatically by Java

HashMap class

2009-08-20T03:28:00.001-07:00

The HashMap class is roughly equivalent to Hashtable, except that it is not synchronized and it permits null values (and one null key) to be stored

Finalizer

2009-08-20T03:24:00.000-07:00

Every class has a special method, called a finalizer, which is called before an object is reclaimed by the Java VM garbage collector. The JVM calls the finalizer for you as appropriate; you never call a finalizer directly. Think of the finalizer as a friendly warning from the virtual machine. Your finalizer should perform two tasks: performing whatever cleanup is appropriate to the object, and
calling the superclass finalizer. Finalizers are not guaranteed to be called just because an object becomes eligible for garbage collection, or before a program shuts down,
so you should not rely on them.

final variables

2009-08-20T03:23:00.000-07:00

The final keyword applied to a variable makes it impossible to reinitialize a variable once it has been assigned a value. For primitives, this means the value may not be altered once it is initialized. For objects, the data within the object may be modified, but the reference variable may not be changed to reference a different object or null.

final method

2009-08-20T03:22:00.002-07:00

The final keyword applied to a method prevents the method from being overridden by a subclass

final class

2009-08-20T03:22:00.001-07:00

The final keyword restricts a class from being extended by another class. If you try to extend a final class, the Java compiler will give an error

Extensibility

2009-08-20T03:21:00.002-07:00

Extensibility is a term that describes a design or code that can easily be enhanced without being rewritten

Exception handling

2009-08-20T03:21:00.001-07:00

Exception handling allows developers to easily detect errors without writing special code to test return values. Better, it lets us handle these errors in code that is nicely separated from the code that generated them and handle an entire class of errors with the same code, and it allows us to let a method defer handling its errors to a previously called method. Exception handling works by
transferring execution of a program to an exception handler when an error, or exception, occurs

Exception

2009-08-20T03:19:00.000-07:00

Exception has two common meanings in Java. First, an Exception is an object type. Second, an exception is shorthand for “exceptional condition,” which is an occurrence that alters the normal flow of an application

Encapsulation

2009-08-20T03:17:00.001-07:00

Encapsulation is the process of grouping methods and data
together and hiding them behind a public interface. A class demonstrates good
encapsulation by protecting variables with private or protected access, while
providing more publicly accessible setter and/or getter methods

do-while loop

2009-08-20T03:16:00.001-07:00

The do-while loop is slightly different from the while statement in that the program execution cycle will always enter the body of a do-while at least once. It does adhere to the rule that you do not need brackets around the body if it contains only one statement

Default access

2009-08-20T03:11:00.001-07:00

A class with default access needs no modifier preceding it in the declaration. Default access allows other classes within the same package to have visibility to this class

Declaration

2009-08-20T03:10:00.000-07:00

A declaration is a statement that declares a class, interface, method, package, or variable in a source file. A declaration can also explicitly initialize a variable by giving it a value

Continue Statement

2009-08-20T02:57:00.000-07:00

The continue statement causes the current iteration of the innermost loop to cease and the next iteration of the same loop to start if the condition of the loop is met. In the case of using a continue statement with a for loop, you need to consider the effects that the continue has on the loop iterator
(the iteration expression will run immediately after the continue statement).

Example: http://java.sun.com/docs/books/tutorial/java/nutsandbolts/branch.html

Constructor

2009-08-20T02:55:00.000-07:00

A method-like block of code that is called when the object is created (instantiated) Typically, constructors initialize data members and acquire whatever resources the object may require. It is the code that runs before the object can be referenced.

Collection framework

2009-08-20T02:54:00.000-07:00

Three elements (interfaces, implementations, and algorithms) create what is known as the collection framework, and include Sets (which contain no duplicates), Lists (which can be accessed by an index position), and Maps (which can be accessed by a unique identifier)

Collection interface

2009-08-20T02:53:00.002-07:00

The collection interface defines the public interface that is common to Set and List collection classes. Map classes (such as HashMap and Hashtable) do not implement Collection, but are still considered part of the collection framework.

Collection

2009-08-20T02:53:00.001-07:00

A collection is an object used to store other objects. Collections are also commonly referred to as containers. Two common examples of collections are HashMap and ArrayList

Class members

2009-08-20T02:52:00.001-07:00

Class members are things that belong to a class including methods (static and nonstatic), variables (static and nonstatic), and nested classes (static and nonstatic). Class members can have any of the four access control levels (public, protected, default (package), and private).

Casting

2009-08-20T02:44:00.000-07:00

Casting is the conversion of one type to another type. Typically, casting is used to convert an object reference to either a subtype (for example, casting an Animal reference to a Horse), but casting can also be used on primitive types to convert a larger type to a smaller type, such as from a long to an int.

example:

int i = 5;
short s = (short)i;

------------
We create a superclass called Shape, with a number of subclasses (e.g.
Circle, Square, Triangle, etc).

These classes can be treated as types; you can create instances and store their references in variables, e.g.:

Shape shape = new Shape();
Circle circle = new Circle();

However, that's not the end of the story when you use inheritance. You could also do something like this:
Shape shape = new Circle();

Blocked state

2009-08-20T02:43:00.001-07:00

A thread that is waiting for a resource, such as a lock, to become available is said to be in a blocked state. Blocked threads consume no processor resources.

Automatic variables

2009-08-20T02:42:00.001-07:00

Also called method local or stack variables. Automatic variables are variables that are declared within a method and discarded when the method has completed.

Array

2009-08-20T02:41:00.000-07:00

Arrays are homogeneous data structures implemented in Java as objects. Arrays store one or more of a specific type and provide indexed access to the store

Anonymous inner classes

2009-08-20T02:37:00.000-07:00

Anonymous inner classes are local inner classes that do not have a class name. You create an anonymous inner class by creating an instance of a new unnamed class that is either a subclass of a named class type or an implementer of a named interface type.

Example of inner classes:
http://java.sun.com/docs/books/tutorial/java/javaOO/innerclasses.html

Can a abstract class have a constructor ?When would the constructor in the abstract class be called ?

2009-08-20T02:33:00.000-07:00

All the classes including the abstract classes can have constructors.Abstract class constructors will be called when its concrete subclass will be instantiated.

Abstract method

2009-08-20T02:32:00.001-07:00

An abstract method is a method declaration that contains no functional code. The reason for using an abstract method is to ensure that subclasses of this class will include an implementation of this method. Any concrete class (that is, a class that is not abstract, and therefore capable of being instantiated) must implement all abstract methods it has inherited

Abstract class

2009-08-20T02:31:00.001-07:00

An abstract class is a type of class that is not allowed to be instantiated. The only reason it exists is to be extended. Abstract classes contain methods and variables common to all the subclasses, but the abstract class itself is of a type that will not be used directly. Even a single abstract method requires that a class be marked abstract

Superclass

2009-08-20T02:28:00.000-07:00

In object technology, a high-level class that passes attributes and methods (data and processing) down the hierarchy to subclasses. A superclass is a class from which one or more other classes are derived.

Switch Statement

2009-08-20T02:27:00.000-07:00

The expression in the switch statement can only evaluate to an integral primitive type that can be implicitly cast to an int. These types are byte, short, char, and int. Also, the switch can only check for an equality. This means that the other relational operators like the greater than sign are rendered unusable.

Synchronized methods

2009-08-20T02:26:00.000-07:00

Synchronized methods The synchronized keyword indicates that a method may be accessed by only one thread at a time.

Transient Keyword

2009-08-20T02:25:00.002-07:00

The transient keyword indicates which variables are not to have their data written to an ObjectStream.

Visibility

2009-08-20T02:25:00.001-07:00

Visibility is the accessibility of methods and instance variables to other classes and packages. When implementing a class, you determine your methods’ and instance variables’ visibility keywords as public, protected, package, or default.

Thread

2009-08-20T02:23:00.000-07:00

An independent line of execution. The same method may be used in multiple threads. As a thread executes instructions, any variables that it declares within the method (the so-called automatic variables) are stored in a private area of memory, which other threads cannot access. This allows any other thread to execute the same method on the same object at the same time without having its automatic variables unexpectedly modified.

Map Iterator

2009-08-18T05:27:00.000-07:00

Iterator iterator = mapObject.entrySet() .iterator();
while (iterator.hasNext()) {

Map.Entry> pairs = (Map.Entry>) iterator
.next();
String key = pairs.getKey();
List = pairs.getValue();

Ways to create a thread

2009-07-15T22:37:00.000-07:00

class FooRunnable implements Runnable {
public void run() {
for(int x =1; x < 6; x++) {
System.out.println("Runnable running");
}
}
}
public class TestThreads {
public static void main (String [] args) {
FooRunnable r = new FooRunnable();
Thread t = new Thread(r);
t.start();
}
}

How to use Comparable Interface

2009-07-15T22:27:00.000-07:00

Reference : http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Comparable.html
This interface imposes a total ordering on the objects of each class that implements it. This ordering is referred to as the class's natural ordering, and the class's compareTo method is referred to as its natural comparison method.
Lists (and arrays) of objects that implement this interface can be sorted automatically by Collections.sort (and Arrays.sort). Objects that implement this interface can be used as keys in a sorted map or elements in a sorted set, without the need to specify a comparator.

Reference : http://www.java-tips.org/java-se-tips/java.lang/how-to-use-comparable-interface.html

List of objects that implement this interface can be sorted automatically by sort method of the list interface. This interface has compareTo() method that is used by the sort() method of the list.

In this code Employee class is implementing Comparable interface and have method compareTO(). ComparableDemo.java is showing the use of this interface. This class first makes a list of objects of type Employee and call sort method of java.util.Collections, which internally uses compareTo() method of Employee class and sort the list accordingly.

Employee.java
public class Employee implements Comparable {

int EmpID;
String Ename;
double Sal;
static int i;

public Employee() {
EmpID = i++;
Ename = "dont know";
Sal = 0.0;
}

public Employee(String ename, double sal) {
EmpID = i++;
Ename = ename;
Sal = sal;
}

public String toString() {
return "EmpID " + EmpID + "\n" + "Ename " + Ename + "\n" + "Sal" + Sal;
}

public int compareTo(Object o1) {
if (this.Sal == ((Employee) o1).Sal)
return 0;
else if ((this.Sal) > ((Employee) o1).Sal)
return 1;
else
return -1;
}
}

ComparableDemo.java
import java.util.*;

public class ComparableDemo{

public static void main(String[] args) {

List ts1 = new ArrayList();
ts1.add(new Employee ("Tom",40000.00));
ts1.add(new Employee ("Harry",20000.00));
ts1.add(new Employee ("Maggie",50000.00));
ts1.add(new Employee ("Chris",70000.00));
Collections.sort(ts1);
Iterator itr = ts1.iterator();

while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");

}

}
}

Synchronize arraylist

2009-07-15T22:17:00.000-07:00

Method 1) ArrayList al=new ArrayList();
al.add("1");
al.add("1");
al.add("2");
//we can make the synchronized

Collections.synchronized(al);

Method 2)
List list = Collections.synchronizedList(new ArrayList(...));

synchronized(list) {
Iterator i = list.iterator(); // Must be in synchronized block
while (i.hasNext())
foo(i.next());
}

Collection

2009-07-15T22:10:00.001-07:00

public interface Collection
extends Iterable

A collection represents a group of objects, known as its elements. Some collections allow duplicate elements and others do not. Some are ordered and others unordered.Implementations of more specific sub interfaces like Set and List are provided. This interface is typically used to pass collections around and manipulate them where maximum generality is desired.
Bags or multisets (unordered collections that may contain duplicate elements) should implement this interface directly.

Many methods in Collections Framework interfaces are defined in terms of the equals method. For example, the specification for the contains(Object o) method says: "returns true if and only if this collection contains at least one element e such that (o==null ? e==null : o.equals(e))." This specification should not be construed to imply that invoking Collection.contains with a non-null argument o will cause o.equals(e) to be invoked for any element e. Implementations are free to implement optimizations whereby the equals invocation is avoided, for example, by first comparing the hash codes of the two elements. (The Object.hashCode() specification guarantees that two objects with unequal hash codes cannot be equal.) More generally, implementations of the various Collections Framework interfaces are free to take advantage of the specified behavior of underlying Object methods wherever the implementor deems it appropriate.

EJB VS Hibernate

2009-07-15T02:59:00.000-07:00

The similarity is that with both you can persist a class in a DB.
EJBs are supposed to be components, in the sense that they're not just one class, but a set of classes, descriptors (thats anXML and/or annotations in EJB 3) and usage and management contracts. All of this in order to allow a container (JBoss,Weblogic, etc.) to provide services to those components, and to be able to reuse and distribute this components.
This
services are, among others, transactions, concurrent access control, security, instance pooling, etcetera.
Hibernat is "just" an ORM (Object/Relational Mapping) tool. Quick and dirty, this means you can store an object tree belonging to an class hierarchy in a relational DB without writing a single SQL query. Quite cool, IMO. But no transaction control, no instance pooling, no concurrency control, and certainly no security.
It states that the EJB expert group has decided to use Hibernate as the persistence mechanism in EJB 3.0.

JMS Sample Code

2009-07-15T02:38:00.001-07:00

import java.util.Properties;
import java.util.ResourceBundle;

import javax.naming.*;
import javax.jms.JMSException;
import javax.jms.Queue;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Destination;
import javax.jms.MessageProducer;

public class JMSClientJNDIImpl {

private static ConnectionFactory connectionFactory = null;
private static Destination destination = null;

protected JMSClientJNDIImpl() {

}

/**
* SingletonHolder is loaded on the first execution of
* Singleton.getInstance() or the first access to SingletonHolder.INSTANCE ,
* not before.
*/

private static class SingletonHolder {

private final static JMSClientJNDIImpl INSTANCE = new JMSClientJNDIImpl();

static {
Context jndiContext = null;

try {

jndiContext = new InitialContext();

/*
* Look up connection factory and destination. If either does not exist, exit.
* If you look up a TopicConnectionFactory or a QueueConnectionFactory,
* program behavior is the same.
*/
String destinationName = getBundle().getString("jms.connection.factory");
connectionFactory = (ConnectionFactory) jndiContext.lookup("jms/MyConnectionFactory");
destination = (Destination) jndiContext.lookup(destinationName);

} catch (NamingException e) {
e.printStackTrace();

} catch (Exception e) {
e.printStackTrace();

}
}

}

//returns instance of JMSClientJNDIImpl
public static JMSClientJNDIImpl getInstance() {
return SingletonHolder.INSTANCE;
}

/**
* @param transactionID
* @param workFlowID
* @param messageTitle
* @param timestamp
* @param transformFlag
*/
public void transactionMessagesLogging(String transactionID,
String xmlData, String messageTitle, String timestamp,
Boolean transformFlag) throws Exception {
try {
StringBuffer loggingMessage = new StringBuffer();
createAndSendMessage(msg);

} catch (JMSException e) {

} catch (Exception e) {
e.printStackTrace();

}

}

/**
* this method uses the connection to create a session and messages to the queue
* @param transactionID
* @param xmlData
* @param messageTitle
* @param timestamp
* @param transformFlag
* @param loggingMessage
* @throws JMSException
* @throws Exception
*/
private void createAndSendMessage(String msg) throws JMSException, Exception {

Connection connection = null;
MessageProducer producer = null;
Session session = null;

try {
/*
* Create connection.
* Create session from connection; false means session is
* not transacted.
* Create producer and text message.
* Send messages, varying text slightly.
* Send end-of-messages message.
* Finally, close connection.
*/
connection = connectionFactory.createConnection();

session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
producer = session.createProducer(destination);

//creating the text message
TextMessage transactionMessage = session.createTextMessage();
loggingMessage.append(msg.trim());
transactionMessage.setText(loggingMessage.toString());
producer.send(transactionMessage);

/*
* Send a non-text control message indicating end of
* messages.
*/
producer.send(session.createMessage());

} catch (JMSException e) {
e.printStackTrace();

} catch (Exception e) {
e.printStackTrace();

} finally {
try {
// closing resources
if (session != null) {
session.close();
}
if (connection != null) {
connection.close();
}
} catch (Exception e) {

}
}
}

//read values from properties file
private static ResourceBundle getBundle() throws Exception {
MessageReader reader = MessageReader.getInstance();
ResourceBundle bundle = reader.getReader("ApplicationResources");
return bundle;
}

}

JMS Messaging

2009-07-15T02:26:00.000-07:00

Messaging is a form of loosely coupled distributed communication, where in this context the term 'communication' can be understood as an exchange of messages between software components. Message-oriented technologies attempt to relax tightly coupled communication (such as TCP network sockets, RMI) by the introduction of an intermediary component, which in this case would be a queue. The latter approach allows software components to communicate 'indirectly' with each other. Benefits of this include message senders not needing to have precise knowledge of their receivers, since communication is performed using this queue. This is the first of two types: point to point and publish and subscribe.

JMS provider
An implementation of the JMS interface for a Message Oriented Middleware (MOM). Providers are implemented as either a Java JMS implementation or an adapter to a non-Java MOM.
JMS client
An application or process that produces and/or receives messages.
JMS producer
A JMS client that creates and sends messages.
JMS consumer
A JMS client that receives messages.
JMS message
An object that contains the data being transferred between JMS clients.
JMS queue
A staging area that contains messages that have been sent and are waiting to be read. As the name queue suggests, the messages are delivered in the order sent. A message is removed from the queue once it has been read.
JMS topic
A distribution mechanism for publishing messages that are delivered to multiple subscribers.

The JMS API supports two models:
* point-to-point or queuing model
* publish and subscribe model

In the point-to-point or queuing model, a sender posts messages to a particular queue and a receiver reads messages from the queue. Here, the sender knows the destination of the message and posts the message directly to the receiver's queue. It is characterized by the following:
* Only one consumer gets the message
* The producer does not have to be running at the time the consumer consumes the message, nor does the consumer need to be running at the time the message is sent
* Every message successfully processed is acknowledged by the consumer

The publish/subscribe model supports publishing messages to a particular message topic. Subscribers may register interest in receiving messages on a particular message topic. In this model, neither the publisher nor the subscriber know about each other. A good metaphor for it is anonymous bulletin board. The following are characteristics of this model:
* Multiple consumers can get the message
* There is a timing dependency between publishers and subscribers. The publisher has to create a subscription in order for clients to be able to subscribe. The subscriber has to remain continuously active to receive messages, unless it has established a durable subscription. In that case, messages published while the subscriber is not connected will be redistributed whenever it reconnects.

Using Java, JMS provides a way of separating the application from the transport layer of providing data. The same Java classes can be used to communicate with different JMS providers by using the JNDI information for the desired provider. The classes first use a connection factory to connect to the queue or topic, and then use populate and send or publish the messages. On the receiving side, the clients then receive or subscribe to the messages.

The JMS API is provided in the Java package javax.jms.

ConnectionFactory interface
An administered object that a client uses to create a connection to the JMS provider. JMS clients access the connection factory through portable interfaces so the code does not need to be changed if the underlying implementation changes. Administrators configure the connection factory in the Java Naming and Directory Interface (JNDI) namespace so that JMS clients can look them up. In version 1.0, Depending on the type of message, users will use either a queue connection factory or topic connection factory. In JMS version 1.1 these factories are merged into a single factory.

Connection interface
Once a connection factory is obtained, a connection to a JMS provider can be created. A connection represents a communication link between the application and the messaging server. Depending on the connection type, connections allow users to create sessions for sending and receiving messages from a queue or topic.

Destination interface
An administered object that encapsulates the identity of a message destination, which is where messages are delivered and consumed. It is either a queue or a topic. The JMS administrator creates these objects, and users discover them using JNDI. Like the connection factory, the administrator can create two types of destinations: queues for Point-to-Point and topics for Publish/Subscribe.

MessageConsumer interface
An object created by a session. It receives messages sent to a destination. The consumer can receive messages synchronously (blocking) or asynchronously (non-blocking) for both queue and topic-type messaging.

MessageProducer interface
An object created by a session that sends messages to a destination. The user can create a sender to a specific destination or create a generic sender that specifies the destination at the time the message is sent.

Message interface
An object that is sent between consumers and producers; that is, from one application to another. A message has three main parts:

1. A message header (required): Contains operational settings to identify and route messages.
2. A set of message properties (optional): Contains additional properties to support compatibility with other providers or users. It can be used to create custom fields or filters (selectors).
3. A message body (optional): Allows users to create five types of messages (text message, map message, bytes message, stream message, and object message).

The message interface is extremely flexible and provides numerous ways to customize the contents of a message..

Session interface
Represents a single-threaded context for sending and receiving messages. A session is single-threaded so that messages are serialized, meaning that messages are received one-by-one in the order sent. The benefit of a session is that it supports transactions. If the user selects transaction support, the session context holds a group of messages until the transaction is committed, then delivers the messages. Before committing the transaction, the user can cancel the messages using a rollback operation. A session allows users to create message producers to send messages, and message consumers to receive messages.

Synchronous vs Asynchronous

2009-07-15T02:16:00.001-07:00

Synchronous vs Asynchronous

The send, receive, and reply operations may be synchronous or asynchronous. A synchronous operation blocks a process till the operation completes. An asynchronous operation is non-blocking and only initiates the operation. The caller could discover completion by some other mechanism.

The notion of synchronous operations requires an understanding of what it means for an operation to complete. In the case of remote assignment, both the send and receive complete when the message has been delivered to the receiver. In the case of remote procedure call, the send, receive, and reply complete when the result has been delivered to the sender, assuming there is a return value. Otherwise, the send and receive complete when the procedure finishes execution.

Asynchronous message passing allows more parallelism. Since a process does not block, it can do some computation while the message is in transit. In the case of receive, this means a process can express its interest in receving messages on multiple ports siumtaneously. In a synchronous system, such parallelism can be achieved by forking a separate process for each concurrent operation, but this approach incurs the cost of extra process management. T

Asynchronous message passing introduces several problems. What happens if a message cannot be delivered? The sender may neve wait for delivery of the message, and thus never hear about the error. Similarly, a mechanism is needed to notify an asynchronous receiver that a message has arrived. The operation invoker could learn about completion/errors by polling, getting a software interrupt, or by waiting explicitly for completion later using a special sycnhronous wait call. An asynchronous operation needs to return a call/transaction id if the application needs to be later notified about the operation. At notification time, this id would be placed in some global location or passed as an argument to a handler or wait call.

Another problem related to asynchronous message passing has to do with buffering. If messages sent asynchronously are buffered in a space managed by the OS, then a process may fill this space by flooding the system with a large number of messages.