scriptSplash

Java Interview Questions - MultiThreading

noreply@blogger.com (Unknown) — Tue, 14 Aug 2012 18:50:00 +0000

This set of Java Interview Questions covers MultiThreading topics like Threads, Synchronization, DeadLock, Thread Pool and more.

You can find the previous set of Interview Questions from here:

1. What is the difference between processes and threads?

A process is an execution of a program but a thread is a single execution sequence within the process. A process can contain multiple threads. A thread is sometimes called a lightweight process.
A JVM runs in a single process and threads in a JVM share the heap belonging to that process. That is why several threads may access the same object. Threads share the heap and have their own stack space. This is how one thread’s invocation of a method and its local variables are kept thread safe from other threads. But the heap is not thread-safe and must be synchronized for thread safety.

2. Explain different ways of creating a thread? Which one is preferred?

Threads can be used by either

Extending the Thread class.

class Counter extends Thread {
    
    //method where the thread execution will start
    public void run(){
        //logic to execute in a thread   
    }
 
    //let’s see how to start the threads
    public static void main(String[] args){
       Thread t1 = new Counter();
       Thread t2 = new Counter();
       t1.start();  //start the first thread.
       t2.start(); //this starts the 2nd thread.
    }
}

Implementing the Runnable interface.

class Counter extends Base implements Runnable{
   
    //method where the thread execution will start
    public void run(){
        //logic to execute in a thread   
    }
 
    //let us see how to start the threads
    public static void main(String[] args){
         Thread t1 = new Thread(new Counter());
         Thread t2 = new Thread(new Counter());
         t1.start();  //start the first thread.
         t2.start();  //this starts the 2nd thread.
    }
}

The Runnable interface is preferred, as it does not require your object to inherit a thread because when you need multiple inheritance, only interfaces can help you.

3. Briefly explain high-level thread states?

A Thread can have the below states:

Runnable: A thread becomes runnable when you call the start( ), but does not necessarily start running immediately. It will be pooled waiting for its turn to be picked for execution by the thread scheduler based on thread priorities.
Running: The processor is actively executing the thread code. It runs until it becomes blocked, or voluntarily gives up its turn with this static method Thread.yield( ). Because of context switching overhead, yield( ) should not be used very frequently
Waiting: A thread is in a blocked state while it waits for some external processing such as file I/O to finish.A call to currObject.wait( ) method causes the current thread to wait until some other thread invokes currObject.notify( ) or the currObject.notifyAll( ) is executed.
Sleeping: Java threads are forcibly put to sleep (suspended) with this overloaded method: Thread.sleep(milliseconds), Thread.sleep(milliseconds, nanoseconds);
Blocked :Will move to runnable after chnage in I/O condition or when lock is acquired.
Dead: The thread is finished working.

4. What is multithreading and what are the methods for inter-thread communication?

Multithreading is the mechanism in which more than one thread run independent of each other within the process. wait (), notify () and notifyAll() methods can be used for inter-thread communication and these methods are in Object class.

wait() : When a thread executes a call to wait() method, it surrenders the object lock and enters into a waiting state.

notify() or notifyAll() : To remove a thread from the waiting state, some other thread must make a call to notify() or notifyAll() method on the same object.

5. What's the difference between the methods sleep() and wait()?

The code sleep(1000); puts thread aside for exactly one second whereas the code wait(1000), causes a wait of up to one second.
A thread could stop waiting earlier if it receives the notify() or notifyAll() call.
The method wait() is defined in the class Object and the method sleep() is defined in the class Thread.

6. Why wait, notify, and notifyall methods are defined in the Object class, and not in the Thread class?

Every Java Object has a monitor associated with it. The threads using that object can lock or unlock the monitor associated with the object. Wait and notify/notifyAll methods are responsible for acquiring and relinquishing the lock associated with the particular object. Calling wait causes the current thread to wait to acquire the lock of the Object, and calling notify/notifyAll relinquishes the lock and notify the threads waiting for that lock.

7. What do you understand by Synchronization?

Synchronization is a process of controlling the access of shared resources by the multiple threads in such a manner that only one thread can access one resource at a time. In non synchronized multithreaded application, it is possible for one thread to modify a shared object while another thread is in the process of using or updating the object's value. Synchronization prevents such type of data corruption.

E.g. Synchronizing a function:

public synchronized void Method1 () {
    // Appropriate method-related code. 
}

E.g. Synchronizing a block of code inside a function:

public myFunction (){
    synchronized (this) { 
    // Synchronized code here.
  }
}

8. What are the disadvantages of synchronization?

The disadvantage of synchronize is it will end up in slowing down the program. Also if not handled properly it will end up in dead lock.

9. Why would you use a synchronized block vs. synchronized method?

Synchronized blocks place locks for shorter periods than synchronized methods.

10. When you will synchronize a piece of your code?

When you expect your code will be accessed by different threads and these threads may change a particular data causing data corruption.

11. What is a ThreadLocal class?

ThreadLocal is a handy class for simplifying development of thread-safe concurrent programs by making the object stored in this class not sharable between threads.
Below are some key points about ThreadLocal variables :

A thread-local variable effectively provides a separate copy of its value for each thread that uses it.
ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread
In case when multiple threads access a ThreadLocal instance, separate copy of Threadlocal variable is maintained for each thread.
Common use is seen in DAO pattern where the DAO class can be singleton but the Database connection can be maintained separately for each thread. (Per Thread Singleton)

12. What is deadlock?

When two threads are waiting each other and can’t precede the program is said to be deadlock. Deadlock may occur when two threads, each having a lock on the same resource, attempt to acquire a lock on the other's resource. Each thread would wait indefinitely for the other resource to release the lock, unless one of the user processes is terminated.
The thread deadlock can occur in conditions such as:

two threads calling Thread.join() on each other.
two threads use nested synchronized blocks to lock two objects and blocks lock the same objects in different order.

13. What is daemon thread and which method is used to create the daemon thread?

Daemon thread is a low priority thread which runs intermittently in the back ground doing the garbage collection operation for the java runtime system. setDaemon method is used to create a daemon thread.

14. What is immutable object? How does it help in writing concurrent application?

An object is considered immutable if its state cannot change after it is constructed. Immutable objects are particularly useful in concurrent applications, since they cannot change state, they cannot be corrupted by thread interference or observed in an inconsistent state. Examples of immutable objects from the JDK include String and Integer.
Immutable objects greatly simplify your multi threaded program, since they are

Simple to construct, test, and use.
Automatically thread-safe and have no synchronization issues.

To create a object immutable You need to make the class final and all its member final so that once objects gets crated no one can modify its state. You can achieve same functionality by making member as non final but private and not modifying them except in constructor.

15. What is Starvation? and What is a Livelock?

Starvation and livelock are much less common a problem than deadlock, but are still problems that every designer of concurrent software is likely to encounter.

LiveLock : Livelock occurs when all threads are blocked, or are otherwise unable to proceed due to unavailability of required resources, and the non-existence of any unblocked thread to make those resources available. In terms of Java API, thread livelock can occur in following conditions:
1. When all the threads in a program execute Object.wait(0) on an object with zero parameter. The program is live-locked and cannot proceed until one or more threads call Object.notify() or Object.notifyAll() on the relevant objects. Because all the threads are blocked, neither call can be made.
2. When all the threads in a program are stuck in infinite loops.

Starvation : Starvation describes a situation where a thread is unable to gain regular access to shared resources and is unable to make progress. This happens when shared resources are made unavailable for long periods by "greedy" threads. In Java, thread starvation can be caused by setting thread priorities inappropriately. A lower-priority thread can be starved by higher-priority threads if the higher-priority threads do not yield control of the CPU from time to time.

16. What is thread pool? Why should we use thread pools?

A thread pool is a collection of threads on which task can be scheduled. Instead of creating a new thread for each task, you can have one of the threads from the thread pool pulled out of the pool and assigned to the task. When the thread is finished with the task, it adds itself back to the pool and waits for another assignment.
One common type of thread pool is the fixed thread pool. This type of pool always has a specified number of threads running; if a thread is somehow terminated while it is still in use, it is automatically replaced with a new thread.
Below are key reasons to use a Thread Pool :

Using thread pools minimizes the JVM overhead due to thread creation.
You have control over the maximum number of tasks that are being processed in parallel (= number of threads in the pool).

Java Interview Questions - Exception

noreply@blogger.com (Unknown) — Sat, 11 Aug 2012 16:11:00 +0000

Here is a set of Java Interview Questions which focuses on Exceptions and the Exception Handling framework. You can find the previous set of Interview Questions from here:

1. What is an exception?

An exception is an event, which occurs during the execution of a program, that disrupts the normal flow of the program's instructions.

2. How does exception handling work in Java?

It separates the working/functional code from the error-handling code by way of try-catch clauses.
It allows a clean path for error propagation. If the called method encounters a situation it can’t manage, it can throw an exception and let the calling method deal with it.
By enlisting the compiler to ensure that "exceptional" situations are anticipated and accounted for, it enforces powerful coding.

3. What are the different ways to generate an Exception?

There are two different ways to generate an Exception:

Exceptions can be generated by the Java run-time system. Exceptions thrown by Java relate to fundamental errors that violate the rules of the Java language or the constraints of the Java execution environment.
Exceptions can be manually generated by your code.Manually generated exceptions are typically used to report some error condition to the caller of a method.

4. What are the two types of Exception in Java?

Exceptions are of two types: Compiler-enforced exceptions, or checked exceptions and Runtime exceptions, or unchecked exceptions.

Compiler-enforced (checked) exceptions are instances of the Exception class or one of its subclasses — excluding the RuntimeException branch. The compiler expects all checked exceptions to be appropriately handled. For example, if a file is to be opened, but the file cannot be found, an exception occurs. These exceptions cannot simply be ignored at the time of compilation.
Runtime exception represent unexpected exceptional conditions which can be handled but not necessarily recovered from. As opposed to checked exceptions, runtime exceptions are ignored at the time of compilation.

5. Explain the User-defined or Custom Exceptions?

User defined Exceptions are the separate Exception classes defined by the user for specific purpose. An user defined exception can be created by simply sub-classing it to the Exception class. This allows custom exceptions to be generated (using throw) and caught in the same way as normal exceptions.
Example:

class myCustomException extends Exception {
       // The class simply has to exist to be an exception
}

6. Does it matter in what order catch statements for FileNotFoundException and IOException are written?

Yes, it does. The FileNoFoundException is inherited from the IOException. Exception's subclasses have to be caught first.

7. What is error?

An Error indicates that a non-recoverable condition has occurred that should not be caught. Error, a subclass of Throwable, is intended for drastic problems, such as OutOfMemoryError, which would be reported by the JVM itself.

8. What is the difference between exception and error?

The exception class defines mild error conditions that your program encounters. Exceptions can occur when trying to open the file which does not exist, when the network connection is disrupted, or when operands being manipulated are out of prescribed ranges.
The error class defines serious error conditions that you should not attempt to recover from. In most cases it is advisable to let the program terminate when such an error is encountered.

9. What is the super class of java.lang.Exception

java.lang.Throwable, the parent class of all exception related classes.

10. Explain the significance of try-catch blocks?

Whenever the exception occurs in Java, we need a way to tell the JVM what code to execute. To do this, we use the try and catch keywords. The try is used to define a block of code in which exceptions may occur. One or more catch clauses match a specific exception to a block of code that handles it.
Eg:

try {
   // try block for code for which we want to catch exceptions.
} catch (Exception e) {
   // catch block to handle the exception.
}

11. What is the use of finally block?

The finally block encloses code that is always executed at some point after the try block, whether an exception was thrown or not. This is right place to close files, release your network sockets, connections, and perform any other cleanup your code requires.
If the try block executes with no exceptions, the finally block is executed immediately after the try block completes. It there was an exception thrown, the finally block executes immediately after the proper catch block completes.

12. What if there is a break or return statement in try block followed by finally block?

If there is a return statement in the try block, the finally block executes right after the return statement encountered, and before the return executes.

13. Can we have the try block without catch block?

Yes, we can have the try block without catch block, but finally block should follow the try block.

14. What is the difference throw and throws?

throws: Used in a method's signature if a method is capable of causing an exception that it does not handle, so that callers of the method can guard themselves against that exception. If a method is declared as throwing a particular class of exceptions, then any other method that calls it must either have a try-catch clause to handle that exception or must be declared to throw that exception (or its superclass) itself.

public void someMethod(g) throws someException {
      // Method body
}

throw: Used to trigger an exception. The exception will be caught by the nearest try-catch clause that can catch that type of exception. The flow of execution stops immediately after the throw statement; any subsequent statements are not executed.

throw new someException("Catch this one !!");

Core Java Interview Questions - Part 3

noreply@blogger.com (Unknown) — Thu, 02 Aug 2012 19:16:00 +0000

Here is the Third set of Core Java Interview Questions. You can find the previous set of interview questions from below :

1. Where and how can you use a private constructor.

Private constructor can be used if you do not want any other class to instanstiate the object , the instantiation is done from a static public method. This method is used when dealing with the factory method pattern when the designer wants only one controller (fatory method ) to create the object.

2. Can a top level class be private or protected?

No. A top level class can not be private or protected. It can have either "public" or no modifier. If it does not have a modifier it is supposed to have a default access.If a top level class is declared as private the compiler will complain that the "modifier private is not allowed here". This means that a top level class can not be private. Same is the case with protected.

3. Differentiate between continue and break.

In break, control comes out of the loop whereas in continue control stops at “continue” statement. The remaining statements aren’t executed as control enters following loop.

4. What restrictions are placed on method overriding in Java Programming?

Overridden methods must have the same name, argument list, and return type. The overriding method may not limit the access of the method it overrides. The overriding method may not throw any exceptions that may not be thrown by the overridden method.

5. Why equals should be overridden?

Two objects are considered equal if referring to the same object as the equals method uses only the operator == to compare. Hence while using the object as keys, equals() method needs to be overridden. Similarly while using hashmaps or hashtables the method hashcode needs to be overridden as the object is placed in the hash using hashcode value.

6. Can we override a static method?

The static methods cannot be overridden. If a subclass defines a static method with the same signature as a static method in the superclass, the method in the subclass hides the one in the superclass.

7. What are Transient and Volatile Modifiers?

Transient: Transient keyword indicates that the value of this member variable does not have to be serialized with the object. When the class will be de-serialized, this variable will be initialized with a default value of its data type (i.e. zero for integers).
Volatile: Volatile modifier applies to variables only and it tells the compiler that the variable modified by volatile can be changed unexpectedly by other parts of the program.

8. What is Garbage Collection?

When an object is no longer referred to by any variable, java automatically reclaims memory used by that object. This is known as garbage collection.
Garbage collection is also called automatic memory management as JVM automatically removes the unused variables/objects (value is null) from the memory. User program can't directly free the object from memory, instead it is the job of the garbage collector to automatically free the objects that are no longer referenced by a program.

9. How you can force the garbage collection?

Garbage collection automatic process and can't be forced. You could request it by calling System.gc() or Runtime.gc(). JVM does not guarantee that GC will be started immediately and when all the objects will garbage collected.
Every class inherits finalize() method from java.lang.Object, the finalize() method is called by garbage collector when it determines no more references to the object exists. In Java, it is good idea to explicitly assign null into a variable when no more in use.

10. What are immutable objects in Java? Can we change the value of an immutable object?

An object is considered to be immutable if its value cannot change after it is created. Immutable objects are particularly very useful in multi-threaded applications. Since they cannot change state, they won’t get corrupted by thread interference or observed in an inconsistent state. Objects of java.lang.Integer and java.lang.String classes are the examples of immutable objects. To create an immutable object You need to make the class final and all its members private or final, so that once objects gets created no one can modify its state.

11. What do you understand by numeric promotion?

The Numeric promotion is the conversion of a smaller numeric type to a larger numeric type, so that integer and floating-point operations may take place. In the numerical promotion process the byte, char, and short values are converted to int values. The int values are also converted to long values, if necessary. The long and float values are converted to double values, as required.

12. What is an applet?

Applet is a dynamic and interactive program that runs inside a web page displayed by a java capable browser. Applet needs no explicit installation on local machine and runs itself automatically in a java-enabled browser.

13. What is the lifecycle of an applet?

init() method - Can be called when an applet is first loaded
start() method - Can be called each time an applet is started.
paint() method - Can be called when the applet is minimized or maximized.
stop() method - Can be used when the browser moves off the applet’s page.
destroy() method - Can be called when the browser is finished with the applet.

14. What is JVM (Java Virtual Machine)?

JVM stands for Java Virtual Machine. JVM is a software implementation which stands on the top of the real hardware platform and operating system. It provides abstraction between the compiled java program and the hardware and operating system. So the compiled program does not have to worry about what hardware and operating system he has to run in, it’s all handled by the JVM and thus attaining portability. All Java programs are compiled in to bytecodes. JVM can only understand and execute Java bytecodes.

15. Explain the advantages and disadvantages of JAVA.

JAVA offers a number of advantages to developers.

Java is simple: Java was designed to be easy to use and learn than other programming languages. Java is much simpler than C++ as it uses automatic memory allocation and garbage collection where else C++ requires the programmer to allocate memory and to collect garbage.
Java is object-oriented: Programming in Java is centered on creating objects, manipulating objects, and making objects work together. This allows you to create modular programs and reusable code.
Java is platform-independent: Java programs are compiled into Java Virtual Machine code called bytecode. The bytecode is machine independent and is able to run on any machine that has a Java interpreter. With Java, the program need only be compiled once, and the bytecode generated by the Java compiler can run on any platform.
Java is distributed: Distributed computing involves several computers on a network working together. Java is designed to make distributed computing easy with the networking capability that is inherently integrated into it.
Java is secure: Java is one of the first programming languages to consider security as part of its design. The Java language, compiler, interpreter, and runtime environment were each developed with security in mind.
Java is robust: Java puts a lot of emphasis on early checking for possible errors, as Java compilers are able to detect many problems that would first show up during execution time in other languages.
Java is multithreaded: Multithreaded is the capability for a program to perform several tasks simultaneously within a program. In Java, multithreaded programming has been smoothly integrated into it.

Disadvantages of JAVA :

Performance: Java can be perceived as significantly slower and more memory-consuming than natively compiled languages such as C or C++.
Single-paradigm language: Java is predominantly a single-paradigm language. However, with the addition of static imports in Java 5.0 the procedural paradigm is better accommodated than in earlier versions of Java.

Please do comment if you find any discrepancies or want to suggest new questions.

Core Java Interview Questions - Part 2

noreply@blogger.com (Unknown) — Thu, 02 Aug 2012 17:43:00 +0000

Here is the Second set of Core Java Interview Questions. You can find the previous set of interview questions from below :

1. What would you use to compare two String variables - the operator == or the method equals()?

I'd use the method equals() to compare the values of the Strings and the == to check if two variables point at the same instance of a String object.

2. What does the "static" keyword mean in front of a variable? A method? A class? Curly braces {}?

static variable: means a class level variable
static method: Can be invoked even before a single instance of a class is created. It is not allowed to access the not static members of the class.
static class: no such thing.
static free floating block: is executed at the time the class is loaded. There can be multiple such blocks. This may be useful to load native libraries when using native methods.

3. What does the "final" keyword mean in front of a variable? A method? A class?

FINAL for a variable : value is constant
FINAL for a method : final method cannot be overridden or hidden by new access specifications.
FINAL for a class : cannot be derived, The best example of a final class is the String class.

4. What is difference between final, finalize() and finally?

final : final keyword can be used for class, method and variables. A final class cannot be subclassed and it prevents other programmers from subclassing a secure class to invoke insecure methods. A final method can’t be overridden. A final variable can’t change from its initialized value.
finalize() : finalize() method is used just before an object is destroyed and can be called just prior to garbage collection.
finally : finally, a key word used in exception handling, creates a block of code that will be executed after a try/catch block has completed and before the code following the try/catch block. The finally block will execute whether or not an exception is thrown. For example, if a method opens a file upon exit, then you will not want the code that closes the file to be bypassed by the exception-handling mechanism. This finally keyword is designed to address this contingency.

5. What is casting?

Casting is used to convert the value of one type to another. There are two types of casting in Java, these are Implicit casting and explicit casting. Casting operation is used to convert between types and the instanceof operator is used to check for type information at run time.

6. What are the types of casting?

There are two types of casting in Java, these are Implicit casting and explicit casting.
Implicit casting is the process of simply assigning one entity to another without any transformation guidance to the compiler. This type of casting is not permitted in all kinds of transformations and may not workout for all application scenarios.
Example:

int i = 4000;
long h = i; //Implicit casting

Explicit casting in the process in which the compiler are specifically informed to about transforming the object.
Example:

long ln = 700.20;
t = (int) ln; //Explicit casting

7. What do you understand by downcasting?

The process of Downcasting refers to the casting from a general to a more specific type, i.e. casting down the hierarchy.

8. What modifiers may be used with top-level class?

public, abstract and final can be used for top-level class.

9. What are inner class and anonymous class?

Inner class : classes defined in other classes, including those defined in methods are called inner classes. An inner class can have any accessibility including private.
Anonymous class : Anonymous class is a class defined inside a method without a name and is instantiated and declared in the same place and cannot have explicit constructors.

10. Describe the wrapper classes in Java.

Wrapper class is wrapper around a primitive data type. An instance of a wrapper class contains, or wraps, a primitive value of the corresponding type.
eg: boolean - java.lang.Boolean
int - java.lang.Integer
void - java.lang.Void

11. What is the difference between StringBuffer and String class?

A StringBuffer implements a mutable sequence of characters. A string buffer is like a String, but can be modified. At any point in time it contains some particular sequence of characters, but the length and content of the sequence can be changed through certain method calls.
The String class represents character strings. All string literals in Java programs are immutable and their values cannot be changed after they are created.

12. What is the difference between the boolean '&' operator and the '&&' operator?

If an expression involving the boolean & operator is evaluated, both operands are evaluated.
Whereas when an expression involving the && operator is evaluated, the first operand is evaluated. If the first operand returns a value of true then only the second operand is evaluated. If the first operand evaluates to false, the evaluation of the second operand is skipped.

13. Why there are no global variables in Java?

Global variables are globally accessible. Java does not support globally accessible variables due to following reasons:

The global variables breaks the referential transparency
Global variables creates collisions in namespace.

14. Why Java does not support pointers?

Because pointers are unsafe. Java uses reference types to hide pointers and programmers feel easier to deal with reference types without pointers.

15. How is it possible for two String objects with identical values not to be equal under the == operator?

The '==' operator compares two objects to determine if they are the same object in memory. It is possible for two String objects to have the same value, but located indifferent areas of memory.

Please do provide your valuable comments and suggestions. Thanks in Advance.

Java Interview Questions - Collections

noreply@blogger.com (Unknown) — Sun, 29 Jul 2012 06:18:00 +0000

Here is a set of Java Interview Questions which focuses on the Collections framework. You can find the previous set of Interview Questions from here:

1. What is Collection API?

The Collection API is a set of classes and interfaces that support operation on collections of objects. These classes and interfaces are more flexible, more powerful, and more regular than the vectors, arrays, and hashtables if effectively replaces.
Example of classes: HashSet, HashMap, ArrayList, LinkedList, TreeSet and TreeMap.
Example of interfaces: Collection, Set, List and Map.

2. What are the classes implementing List interface?

There are three classes that implement List interface:

ArrayList : It is a resizable array implementation. The size of the ArrayList can be increased dynamically also operations like add,remove and get can be formed once the object is created. It also ensures that the data is retrieved in the manner it was stored. The ArrayList is not thread-safe.
Vector: It is thread-safe implementation of ArrayList. The methods are wrapped around a synchronized block.
LinkedList: LinkedList implements Queue interface and provide FIFO(First In First Out) operation for add operation. It is faster than ArrayList for insertion and deletion of elements from the middle of a list.

3. Which all classes implement Set interface?

A Set is a collection that contains no duplicate elements. HashSet, SortedSet and TreeSet are the commonly used classes which implements Set interface.

SortedSet - It is an interface which extends Set. A the name suggest , the interface allows the data to be iterated in the ascending order or sorted on the basis of Comparator or Comparable interface. All elements inserted into the interface must implement Comparable or Comparator interface.
TreeSet - It is the implementation of SortedSet interface.This implementation provides guaranteed log(n) time cost for the basic operations (add, remove and contains). The class is not synchronized.
HashSet: This class implements the Set interface, backed by a hash table (actually a HashMap instance). It makes no guarantees as to the iteration order of the set; in particular, it does not guarantee that the order will remain constant over time.

4. What is difference between List and a Set?

List can contain duplicate values but Set allows only unique elements.
List allows retrieval of data to be in same order in the way it is inserted but Set doesnt ensures the sequence in which data can be retrieved.

5. What is difference between Arrays and ArrayList ?

Arrays are created of fix size whereas ArrayList is of not fix size. i.e. the size of array cannot be incremented or decremented. But with arrayList the size is variable.
Once the array is created elements cannot be added or deleted from it. But with ArrayList the elements can be added and deleted at runtime.
ArrayList is one dimensional but array can be multidimensional.
To create an array the size should be known or initalized to some value. If not initialized carefully there could me memory wastage. But arrayList is all about dynamic creation and there is no wastage of memory.

6. What are the main differences between a Vector and an ArrayList?

Synchronization - Java Vector class is internally synchronized and ArrayList is not synchronized. Thus whenever there is a possibility of multiple threads accessing the same instance, one should use Vector. While if not multiple threads are going to access the same instance then use ArrayList. Non synchronized data structure (ArrayList) will give better performance than the synchronized one (Vector).
Data growth - Internally, both the ArrayList and Vector hold onto their contents using an Array. When an element is inserted into an ArrayList or a Vector, the object will need to expand its internal array if it runs out of room. A Vector defaults to doubling the size of its array, while the ArrayList increases its array size by 50 percent.

7. Which implementation of the List interface provides for the fastest insertion of a new element into the middle of the list?

The LinkedList allows for fastest insertions and deletions into the middle of a list. The LinkedList is implemented using a doubly linked list; thus an insertion requires only the updating of the links at the point of insertion.Whereas ArrayList and Vector both use an array to store the elements of the list. When an element is inserted into the middle of the list, then the elements that follow the insertion point must be shifted to make room for the new element.

8. What is difference between HashMap and HashTable?

Both collections implements Map. Both collections store value as key-value pairs. The key differences between the two are

Hashmap is not synchronized in nature but HashTable is.
Iterator in the HashMap is fail-safe while the enumerator for the HashTable isn't.
HashMap permits null values and only one null key, while HashTable doesn't allow key or value as null.

9. Is Iterator a Class or Interface? What is its use?

Iterator is an interface which is used to step through the elements of a Collection.

10. If any ArrayList is used only for reading which way will be the faster, For loop or Iterator?

Using a for loop is faster than using iterator. A for loop allows access of the element directly on the basis of index. The cursor of the datastructure can directly go to the 'n' location and get the element. It does not traverse through n-1 elements. Wheras in Iterator based access, the cursor has to traverse through each element to get the desired element.So to reach the 'n'th element it need to traverse through n-1 elements.

11. When should be an Iterator preferred over a For loop?

For loop does not allow the updation in the array(add or remove operation) inside the loop whereas Iterator does. Also Iterator can be used where the data type of the collection is not known.

12. How do you traverse through a collection using its Iterator?

To use an iterator to traverse through the contents of a collection, follow these steps:

Obtain an iterator to the start of the collection by calling the collection’s iterator() method.
Set up a loop that makes a call to hasNext(). Have the loop iterate as long as hasNext() returns true.
Within the loop, obtain each element by calling next().

13. How can Arraylist be synchronized without using Vector?

Arraylist can be synchronized using:

Collection.synchronizedList(List list)

14. What is identityHashMap?

The IdentityHashMap uses == for equality checking instead of equals(). This can be used for both performance reasons, if you know that two different elements will never be equals and for preventing spoofing, where an object tries to imitate another.

15. What are the main algorithms (methods) that the Collections framework provide?

Most polymorphic algorithms in the Collections class apply specifically to List. Below listed are the commonly used algorithms :

sort — sorts a List using a merge sort algorithm, which provides a fast, stable sort. (A stable sort is one that does not reorder equal elements.)
shuffle — randomly permutes the elements in a List.
reverse — reverses the order of the elements in a List.
rotate — rotates all the elements in a List by a specified distance.
swap — swaps the elements at specified positions in a List.
replaceAll — replaces all occurrences of one specified value with another.
binarySearch — searches for an element in an ordered List using the binary search algorithm.

Java Interview Questions - OOP

noreply@blogger.com (Unknown) — Tue, 24 Jul 2012 11:21:00 +0000

Here is the Second set of Java Interview Questions which focuses on the Object Oriented Programming principles. Please comment if you want to add any other question to this list.

1. What is OOP?

OOP is the common abbreviation for Object-Oriented Programming. Object oriented programming organizes a program around its data, i. e. , objects and a set of well defined interfaces to that data. An object-oriented program can be characterized as data controlling access to code.
There are four main principals of oops which are called Abstraction, Polymorphism, Inheritance and Encapsulation.

2. What is the difference between procedural and object-oriented programs?

In procedural program, programming logic follows certain procedures and the instructions are executed one after another. In OOP program, unit of program is object, which is nothing but combination of data and code.
In procedural program, data is exposed to the whole program whereas in OOPs program, it is accessible with in the object and which in turn assures the security of the code.

3. What is Abstraction?

Abstraction is the process of generalization by reducing the information content of an entity, typically to retain only information which is relevant for a particular purpose. For example, an Employee has various attributes like name, skin color, age, hair color, etc. But we consider only those attributes of employees which are required and relevant to program a system.
In general, abstraction is the process of focusing on important thing without including background details in program.

4. Explain the Encapsulation principle.

Encapsulation is a process of binding or wrapping the data and the codes that operates on the data into a single entity. This keeps the data safe from outside interface and misuse. One way to think about encapsulation is as a protective wrapper that prevents code and data from being arbitrarily accessed by other code defined outside the wrapper.

5. Explain the Inheritance principle.

Inheritance is the process by which one object acquires the properties of another object. The advantages of inheritance are reusability of code and accessibility of variables and methods of the super class by subclasses.

6. Explain the Polymorphism principle.

The meaning of Polymorphism is something like one name many forms. Polymorphism enables one entity to be used as as general category for different types of actions. The specific action is determined by the exact nature of the situation. The concept of polymorphism can be explained as "one interface, multiple methods".
From a practical programming viewpoint, polymorphism exists in three distinct forms in Java:

Method overloading
Method overriding through inheritance
Method overriding through the Java interface

7. What is the advantage of OOP?

The Major advantages of OOP are:

Simplicity: software objects model real world objects, so the complexity is reduced and the program structure is very clear.
Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system.
Modifiability: it is easy to make minor changes in the data representation or the procedures in an OO program. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods.
Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
Maintainability: objects can be maintained separately, making locating and fixing problems easier.
Re-usability: objects can be reused in different programs.

8. What is the Difference between Class and Object?

A Class is actually a blueprint or a template to create an Object. Whereas an Object is a an actual instance of a Class. For example Employee is a class, while John is a real employee which is an Object of Employee Class.

9. What is method overloading and method overriding?

Method overloading: When a method in a class having the same method name with different arguments is said to be method overloading.
Method overriding : When a method in a class having the same method name with same arguments is said to be method overriding.

10. What is difference between overloading and overriding?

In overloading, there is a relationship between methods available in the same class whereas in overriding, there is relationship between a superclass method and subclass method.
Overloading does not block inheritance from the superclass whereas overriding blocks inheritance from the superclass.
In overloading, separate methods share the same name whereas in overriding, subclass method replaces the superclass.
Overloading must have different method signatures whereas overriding must have same signature.

11. What is message passing in object oriented programming?

Message passing is a method by which an object sends data to another object or requests other object to invoke method. This is also known as interfacing. It acts like a messenger from one object to other object to convey specific instructions.

12. What are data members and member functions?

Classes use the concept of abstraction and are defined as a list of abstract attributes such as size, weight, and cost and uses functions to operate on these attributes.
The attributes are sometimes called as data members because they hold information. The functions that operate on these data are called as methods or member functions.
Eg: int a,b; // a,b are data members
Void getdata ( ) ; // member function

13. Write the process of programming in an object-oriented language?

Create classes that define objects and their behavior.
Creating objects from class definition.
Establishing communication among objects.

14. What is an Abstract class?

Abstract class defines an abstract concept which can not be instantiated and comparing o interface it can have some implementation while interfaces can not. Below are some points for abstract class:-
We can not create object of abstract class it can only be inherited in a below class.
Normally abstract classes have base implementation and then child classes derive from the abstract class to make the class concrete.

15. What are Abstract methods?

Abstract class can contain abstract methods. Abstract methods do not have implementation. Abstract methods should be implemented in the subclasses which inherit them. So if an abstract class has an abstract method class inheriting the abstract class should implement the method or else java compiler will through an error. In this way, an abstract class can define a complete programming interface thereby providing its subclasses with the method declarations for all of the methods necessary to implement that programming interface. Abstract methods are defined using "abstract" keyword. Below is a sample code snippet.

abstract class MyGraphics {
   abstract void draw();
}

Any class inheriting from 'MyGraphics' class should implement the 'draw' method or else the java compiler will throw an error. So if we do not implement a abstract method the program will not compile.

16. What is the difference between Abstract classes and Interfaces?

Difference between Abstract class and Interface is as follows:-

Abstract class can only be inherited while interfaces can not be it has to be implemented.
Interface cannot implement any methods, whereas an abstract class can have implementation.
Class can implement many interfaces but can have only one super class.
Interface is not part of the class hierarchy while Abstract class comes in through inheritance.
Unrelated classes can implement the same interface.

17. What is difference between Static and Non-Static fields of a class?

Non-Static values are also called as instance variables. Each object of the class has its own copy of Non-Static instance variables. So when a new object is created of the same class it will have completely its own copy of instance variables.
Static values have only one copy of instance variables and will be shared among all the objects of the class.

18. What are inner classes and what is the practical implementation of inner classes?

Inner classes are nested inside other class. They have access to outer class fields and methods even if the fields of outer class are defined as private.
Normally inner classes are used for data structures or some kind of helper classes.

19. What is a constructor in class?

Constructor has the same name as the class in which it resides and looks from syntax point of view it looks similar to a method. Constructor is automatically called immediately after the object is created, before the new operator completes. Constructors have no return type, not even void. This is because the implicit return type of a class' constructor is the class type itself. It is the constructor's job to initialize the internal state of an object so that the code creating an instance will have a fully initialized, usable object immediately.

20. Can constructors be parameterized?

Yes we can have parameterized constructor which can also be termed as constructor overloading. Below is a code snippet which shows two constructors for MathsPI class one default (parameter-less) and other with parameter.

class MathsPI {
   double PI;
   // This is the constructor for the maths constant class.
   MathsPI() {
      PI = 3.14;
   }
   MathsPI(int pi) {
      PI = pi;
   }
}

21. What are access modifiers?

Access modifiers decide whether a method or a data variable can be accessed by another method in another class or subclass.
four types of access modifiers:

Public - Can be accessed by any other class anywhere.
Protected - Can be accessed by classes inside the package or by subclasses ( that means classes who inherit from this class).
Private - Can be accessed only within the class. Even methods in subclasses in the same package do not have access.
Default - (Its private access by default) accessible to classes in the same package but not by classes in other packages, even if these are subclasses.

22. What is runtime polymorphism or dynamic method dispatch?

In Java, runtime polymorphism or dynamic method dispatch is a process in which a call to an overridden method is resolved at runtime rather than at compile-time. In this process, an overridden method is called through the reference variable of a superclass. The determination of the method to be called is based on the object being referred to by the reference variable.

23. What is Dynamic Binding?

Binding refers to the linking of a procedure call to the code to be executed in response to the call. Dynamic binding (also known as late binding) means that the code associated with a given procedure call is not known until the time of the call at run-time. It is associated with polymorphism and inheritance.

24. How do you prevent a method from being overridden?

To prevent a specific method from being overridden in a subclass, use the final modifier on the method declaration, which means "this is the final implementation of this method", the end of its inheritance hierarchy.

25. Do interfaces have member variables?

Interfaces may have member variables, but these are implicitly public, static, and final- in other words, interfaces can declare only constants, not instance variables that are available to all implementations and may be used as key references for method arguments.

Core Java Interview Questions - Part 1

noreply@blogger.com (Unknown) — Mon, 23 Jul 2012 18:00:00 +0000

Had an interview the other day for a java opening and just compiled a list of frequently asked Java Interview questions for different specializations. Thought of sharing the lists for the benefit of all those who are attending or planning for a Java Interview.

This post focuses on Interview questions for the Java Fundamentals i.e the core functionality. If you feel that some important questions are missed or you want suggest a different answer to any Interview question, do comment and I will be glad to update on it.

1. What are Class, Constructor and Primitive data types?

Class is a template for multiple objects with similar features and it is a blue print for objects. It defines a type of object according to the data the object can hold and the operations the object can perform.
Constructor is a special kind of method that determines how an object is initialized when created.
Primitive data types are 8 types and they are: byte, short, int, long, float, double, boolean, char.

2. What is an Object and describe what happens when an object is created in Java?

Object is an instance of a class and it is a software unit that combines a structured set of data with a set of operations for inspecting and manipulating that data. When an object is created using new operator, memory is allocated to it.
Several things happen in a particular order to ensure the object is constructed properly:

Memory is allocated from heap to hold all instance variables and implementation-specific data of the object and its superclasses. Implementation-specific data includes pointers to class and method data.
The instance variables of the objects are initialized to their default values.
The constructor for the most derived class is invoked. The first thing a constructor does is call the constructor for its uppercase. This process continues until the constructor for java.lang.Object is called, as java.lang.Object is the base class for all objects in java.
Before the body of the constructor is executed, all instance variable initializers and initialization blocks are executed. Then the body of the constructor is executed. Thus, the constructor for the base class completes first and constructor for the most derived class completes last.

3. What is the difference between constructor and method?

Constructor will be automatically invoked when an object is created whereas method has to be called explicitly.

4. What are methods and how are they defined?

Methods are functions that operate on instances of classes in which they are defined. Objects can communicate with each other using methods and can call methods in other classes.
Method definition has four parts. They are :

name of the method
type of object or primitive type the method returns
a list of parameters
body of the method.

A method’s signature is a combination of the first three parts mentioned above.

5. How many ways can an argument be passed to a subroutine and explain them?

An argument can be passed in two ways. They are passing by value and passing by reference.
Passing by value: This method copies the value of an argument into the formal parameter of the subroutine.
Passing by reference: In this method, a reference to an argument (not the value of the argument) is passed to the parameter.

6. What is the difference between this() and super()?

this() can be used to invoke a constructor of the same class. Use this() to call a constructor from another constructor.
super() can be used to invoke a super class constructor. Use the following syntax: super.myMethod(); To call a constructor of the superclass, just write super(); in the first line of the subclass's constructor.

7. Explain the usage of Java packages.

This is a way to organize files when a project consists of multiple modules. It also helps resolve naming conflicts when different packages have classes with the same names. Packages access level also allows you to protect data from being used by the non-authorized classes.

8. If a class is located in a package, what do you need to change in the OS environment to be able to use it?

You need to add a directory or a jar file that contains the package directories to the CLASSPATH environment variable.
Let's say a class Employee belongs to a package com.xyz.hr; and is located in the file c:\dev\com\xyz\hr\Employee.java. In this case, you'd need to add c:\dev to the variable CLASSPATH. If this class contains the method main(), you could test it from a command prompt window as follows:
c:\>java com.xyz.hr.Employee

9. What's the difference between constructors and normal methods?

Constructors must have the same name as the class and can not return a value. They are only called once while regular methods could be called many times and it can return a value or can be void.

10. What is the difference between superclass and subclass?

A super class is a class that is inherited whereas sub class is a class that does the inheriting.

11. What does the "abstract" keyword mean in front of a method? A class?

If a method has a abstract keyword in front of it,it is called abstract method. Abstract method has no body.It has only arguments and return type.Abstract methods act as placeholder methods that are implemented in the subclasses.
Abstract classes can’t be instantiated.If a class is declared as abstract,no objects of that class can be created.If a class contains any abstract method it must be declared as abstract.

12. How to define an Abstract class?

A class containing abstract method is called Abstract class. An Abstract class can't be instantiated.
Example of Abstract class:

abstract class testAbstractClass { 
    protected String myString; 
    public String getMyString() { 
    return myString; 
} 
public abstract string anyAbstractFunction();
}

13. How to define an Interface?

In Java Interface defines the methods but does not implement them. Interface can include constants. A class that implements the interfaces is bound to implement all the methods defined in Interface.
Example of Interface:

public interface sampleInterface {
    public void functionOne();
    public long CONSTANT_ONE = 1000;
}

14. What are the advantages of interface?

Interfaces are useful for:

Declaring methods that one or more classes are expected to implement
Capturing similarities between unrelated classes without forcing a class relationship.
Determining an object’s programming interface without revealing the actual body of the class.

15. What's the difference between an interface and an abstract class? Also discuss the similarities. (Very Important)

Abstract class is a class which contain one or more abstract methods, which has to be implemented by sub classes. Interface is a Java Object containing method declaration and doesn't contain implementation. The classes which have implementing the Interfaces must provide the method definition for all the methods

Abstract classes are useful in a situation that Some general methods should be implemented and specialization behavior should be implemented by child classes. Interfaces are useful in a situation that all properties should be implemented.

Differences:

Interfaces provide a form of multiple inheritance. A class can extend only one other class.
Interfaces are limited to public methods and constants with no implementation. Abstract classes can have a partial implementation, protected parts, static methods, etc.
A Class may implement several interfaces. But in case of abstract class, a class may extend only one abstract class.
Interfaces are slow as it requires extra indirection to to find corresponding method in in the actual class. Abstract classes are fast.

Similarities:

Neither Abstract classes or Interface can be instantiated.

You can find the next set of Core Java Interview Questions from below :

Core Java Interview Questions - Part 2

The Best Free jQuery Plugins

noreply@blogger.com (Unknown) — Sat, 21 Jul 2012 17:28:00 +0000

To be successful as a blogger, you definitely need a helping hand with some of the best free jQuery plugins which can help you leverage your efforts. I have listed here some best free jQuery plugins of different functions like slider, layout, form validation, table, etc. Please feel free to suggest any new ones in the comment section.

MotionCaptcha - Innovative Captcha Tool

MotionCAPTCHA is a jQuery CAPTCHA plugin, based on the HTML5 Canvas Harmony procedural drawing tool, requiring users to sketch the shape they see in the canvas in order to submit a form.

Power PWChecker - jQuery password strength checker

Power PWChecker is a free jQuery plugin which ensures secure passwords for users. This simple jQuery plugin can be integrated seamlessly with any online form (sign up form/ user registration form) to check password strength and give users clues for creating strong and secure passwords.

tablesorter - Sortable Table

tablesorter is a jQuery plugin for turning a standard HTML table with THEAD and TBODY tags into a sortable table without page refreshes. tablesorter can successfully parse and sort many types of data including linked data in a cell. It has many useful features including Multi-column sorting and Multi-type sorting.

FancyBox - Image Gallery Box

FancyBox is a tool for displaying images, html content and multi-media in a Mac-style "lightbox" that floats overtop of web page. It can display images, HTML elements, SWF movies, Iframes and also Ajax requests. It is customizable through settings and CSS and supports various fancy transitions.

Akordeon - Stylish jQuery Accordion Plugin

Akordeon is a stylish jQuery plugin for adding efficient accordion style menu to a web page. The idea behind Akordeon is to provide a lightweight and customizable interface for collapsible panels that can hold any kind of data in a limited space.

Nivo Slider - Awesome jQuery slider

The Nivo Slider is world renowned as the most beautiful and easy to use slider on the market. Completely free and totally open source, there literally is no better way to make your website look totally stunning.

Snippet - jQuery Syntax Highlighter

Snippet is a jQuery syntax highlighting plugin built on top of the SHJS script found on SourceForge. Snippet provides a quick and easy way of highlighting source code passages in HTML documents.

jQZoom - Javascript image magnifier

JQZoom is a javascript image magnifier built at the top of the popular jQuery javascript framework. jQzoom is a great and a really easy to use script to magnify what you want. It works on all modern browsers.

jqFloat - Floating Effect with jQuery

jqFloat.js is a jQuery plugin that able to make any HTML objects appear to be “floating” on your web page. It helps create simple floating animation and make your websites come alive with these little “floating” object.

Uploadify - Multiple File Upload jQuery Plugin

Uploadify is a jQuery plugin that integrates a fully-customizable multiple file upload utility on your website. It uses a mixture of JavaScript, ActionScript, and any server-side language to dynamically create an instance over any DOM element on a page.

IdealForms - jQuery Form Plugin

Ideal Forms is the ultimate framework for building and validating responsive HTML5 forms. It is fully responsive, has keyboard support, input customization, custom datepicker and 'On the spot' validation.

Minimit - jQuery Gallery Plugin

Minimit Gallery is the most custom slider plugin you’ll ever find. It’s tested for and supports Css3 transition and transform, drags, scrollers, and touch interactions.It is tested on IE7+, Firefox 3.5+, Safari 3+, Opera 9+, Chrome, Iphone, Ipad, Android.

Recurly - jQuery Forms With Fully Customizable CSS

Recurly.js is a Javascript library designed to be easily embedded and customized to match your website. The library performs in-line validation, real-time total calculations, and gracefully handles errors. Your customer stays on your website while their billing information is securely sent to Recurly for approval.

Flexslider - Fully responsive jQuery slider plugin.

FlexSlider is a fully responsive jQuery slider plugin. FlexSlider has been verified in Safari 4+, Chrome 4+, Firefox 3.6+, Opera 10+, and IE7+. iOS and Android devices are supported as well.

Create a JDT Project in Eclipse

noreply@blogger.com (Unknown) — Tue, 10 Jul 2012 17:31:00 +0000

JDT stands for Java development tools, the sub-project of the Eclipse project that develops tools for programming in Java. This includes a Java compiler, incremental builder, editors, wizards, content assist, and all the other features of a first class Java IDE.
The JDT Core component is the plug-in that defines the core Java elements and API. This Core component can be included inside our own plugin and can be used to search, compile and manipulate Java code outside an IDE. This is because the JDT/Core infrastructure has no built-in JDK version dependencies, and it also does not depend on any particular Java UI.

Below are some of the activities that can be performed by using the JDT Core plug-in :

Programmatically manipulate Java resources, such as creating projects, generating Java source code, performing builds, or detecting problems in code.
Searching the workspace's Java model for Java elements that match a particular description.
Generating Abstract Syntax Trees (AST) that can be used for examining the structure of a compilation unit down to the statement level.
Formatting of compilation units, types, statements, expressions, etc.

JDT is supported by 3 pillars: Java Model, Search Engine, and AST. More info about JDT can be found from here. Here is couple of nice presentations which briefly describes all JDT fundamentals and features - JDT Fundamentals 2010 and JDT Fundamentals. JDT allows you to access Java Code using AST (Abstract Syntax Tree). AST is a Document Object Model for Java, where each code element is represented as AST Nodes. It gives you a detailed tree structureof the Java source code. Some of the ASTNodes are MethodDeclaration, FieldDeclaration, MethodInvocation, VariableDeclarationStatement, ExpressionStatement etc. In this post we will be using this AST functionality to retrieve information from a Java Source File.

At first we need to create a plug-in project which uses JDT Core plugin. Instructions on creating a plug-in project in eclipse can be found from here. Name the new project JDT_Basic. Now to use the JDT core functionality we need to add it as a plug-in to our project. We can do this from the 'Dependencies' tab (view this tab by opening the plugin.xml file). Click on the 'Add' button and add the 'org.eclipse.jdt.core' plug-in. This way we have included the JDT Core plug-in our project and thus will be able to use the AST functionalities.

For running this plugin project we will be using the 'applications' extension. For this, double click on the plugin.xml file and open the 'Extensions' tab. Remove the 'actionSets' extension and add the 'applications' extension (org.eclipse.core.runtime.applications). Expand the extension in the window and create a new run by right clicking and choosing New > run. Specify the class as 'jdt_basic.JDTClass' and click on the 'class' label to create the Class.

        This class will be used to invoke our JDT application. The 'start' method of the application class denotes the starting point of the plug-in application, whereas the 'stop' method is invoked at the end of the application. Using this application class we will try to implement a simple activity, to list all the methods in a Java file.

        Here is how we are going to accomplish this. At first we will read the content of the Java file using a String Buffer. Using this content(source) we will create a CompilationUnit for the Java file. This CompilationUnit gives you an AST representation of the Java File. To traverse the various AST nodes of this CompilationUnit you can use the ASTVisitor pattern. In this example we will list out the Class methods by traversing the MethodDeclaration node.

        Here is the code for the JDTClass. Each step in the code has documented with comments for clear understanding. If you have any questions or queries, please comment. I will be more than happy to help you out.

package jdt_basic;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import org.eclipse.equinox.app.IApplication;
import org.eclipse.equinox.app.IApplicationContext;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.MethodDeclaration;

/** 
 * This class provides basic JDT functionality.
*/
public class JDTClass implements IApplication {
    
    /** 
     * The starting point of the plug-in application.
     * Visit the Code specified as path and list the methods inside the class.
     */
    @Override
    public Object start(IApplicationContext context) throws Exception {

        // Get the source code of the java class file - change path to your file's path.
        final StringBuffer sourceCode = getSource("d:\\HelloWorld.java");
        // Define a new ASTParser.
        ASTParser parser = ASTParser.newParser(AST.JLS3);
        // Parse the class as a compilation unit.
        parser.setKind(ASTParser.K_COMPILATION_UNIT);
        // Supply the class code as character array.
        parser.setSource(sourceCode.toString().toCharArray());
        parser.setResolveBindings(true);
        // Get the compiled class as a compilation unit  
        final CompilationUnit compiledClassUnit = (CompilationUnit) parser.createAST(null);
        // Instantiate a new ASTVisitor class that will determine which nodes are visited during an AST traversal
        compiledClassUnit.accept(new ASTVisitor() {
            @Override
            // Visit the MethodDeclaration node - denotes the declaration of methods in a class
            public boolean visit(MethodDeclaration node) {
                // Show the visited method in console.
                System.out.println("Method " + node.getName().getFullyQualifiedName() + " is visited");
                return true;
            }
        });
        return IApplication.EXIT_OK;
    }
    
    /**
     * Returns the source code of the java class file as string buffer.
     * @param path the path of the Java class file
     * @return StringBuffer string buffer containing the source code
     */
    private static StringBuffer getSource(String path) {

        // Define string buffer for holding the source
        final StringBuffer buffer = new StringBuffer();
        try {
            // Read the file line by line and append to string buffer.
            File javaFile = new File(path);
            BufferedReader in = new BufferedReader(new FileReader(javaFile)); 
            String line = null;
            while (null != (line = in.readLine())) {
                buffer.append(line).append("\n");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return buffer;
    }

    /** 
     * The end point of the plug-in application.
     */
    public void stop() {
        // TODO Auto-generated method stub
    }
}

Chained DropDown in Javascript using XML

noreply@blogger.com (Unknown) — Wed, 04 Jul 2012 15:16:00 +0000

Sample Chained HTML DropDown

In our previous post we have learned about how to create Chained Drop-downs using javascript. In that example, the values for the 2nd drop-down were being hard-coded in the javascript itself. Though this approach is fairly easy to implement, it doen't offer a fully dynamic approach. If we need to add/delete options or update any exisitng options, then we need to alter the javascript code each time. Also a person who has less or no previous experience with Javascript may not be able to use or modify that logic.

This problem can be solved by externalizing your data from the code, say, in form of an XML. In order to change the drop-down values you just need to add, delete or modify the values in the XML file. In this post we will discuss how to implement such a dynamic Chained DropDown using javascript.

We will create the two drop-downs, a 'Company' drop-down which lists mobile companies and 'Model' drop-down which list out models for the selected company.

<select id="Company" >
 <option value=""></option>
 <option value="Samsung">Samsung</option>
 <option value="Apple">Apple</option>
 <option value="Nokia">Nokia</option>
</select>

<select id="Model"> </select>

XML stands for Extensible Markup Language. It is classified as an extensible language because it allows its users to define their own tags. The XML file which has our data has a 'device' tag containing a 'name' attribute which holds the Company name. The model tag is contained inside a device tag and holds information about the Model name. Here is the content of the 'info.xml' file which holds the data for this example.

<?xml version="1.0" ?> 
<data>
    <device name="Nokia">
        <model>Lumia</model>
        <model>PureView</model>
    </device>
    <device name="Samsung">
        <model>Galaxy S2</model>
        <model>Galaxy S3</model>
    </device>
    <device name="Apple">
        <model>iPhone4</model>
        <model>iPhone5</model>
    </device>
</data>

Now we need to import this data from the XML file. To manipulate an XML document in javascript, we need an XML parser. Today all browsers come with in-built parsers that can parse the XML document. The parser loads the document into your computer’s memory and once loaded, its data can be manipulated using the DOM(Document Object Model). We are using a cross-browser function to import the XML as there is significant difference in implementation of Microsoft Browser based XML parser and the Mozilla browsers (Firefox, Chrome, Safari) based XML parser.

/* Cross-Browser Import of XML document into a XML Document. */
function importXML(xmlfile) {
    var xmlDoc;
    if (typeof window.ActiveXObject != 'undefined') {
        //code for IE
        xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
        xmlDoc.async = false;
        xmlDoc.load(xmlfile);
        } else {
            try {
                // code for IE7+, Firefox, Chrome, Opera, Safari
                xmlhttp=new XMLHttpRequest();
                xmlhttp.open("GET", xmlfile, false);
                xmlhttp.setRequestHeader('Content-Type', 'text/xml');
                xmlhttp.send();
                xmlDoc=xmlhttp.responseXML;
            } catch (Exception) {
                alert("Your browser is not supported. Try firefox !!");
            }
        }
    return xmlDoc;
}

The loadXMLOption method retrieves the options for the model combobox from the XML file. This is to be called when user selects an option in the 'Company' drop-down. It first loads the XML file by using the 'importXML' method we have previously written. From the XML document object, we retrieve all the tags with tag name as 'device'. We then loop through each 'device' tag and check if its 'name' attribute's value is same as the one we have selected in the 'Company' drop-down. If found similar, we then retrieve all the 'model' tags under that specific 'device' tag and add each tag's node value as option to the 'Model' drop-down.

/* Get the options for the model combobox from the XML. */
function loadXMLOption() {
    // Load the xml file
    var xmlDoc=importXML("info.xml");
    xmlObj=xmlDoc.documentElement;
    // Get all Elements with Tag name 'device'
    DeviceObj = xmlObj.getElementsByTagName("device");
    for(var i=0; i < DeviceObj.length; i++) {
        // Loop through each device tag and check if its name is equal to the selected device value
        if (document.getElementById('Company').value == DeviceObj[i].getAttribute("name")) {  
            // If matching device found get the model tags under that device
            modelObj = DeviceObj[i].getElementsByTagName("model");
            document.getElementById('Model').options.length = 0;
            // Create options for the Model comboBox.
            for(var j=0; j < modelObj.length; j++) {
                var opt = document.createElement('option');
                opt.value = modelObj[j].firstChild.nodeValue;
                opt.text = modelObj[j].firstChild.nodeValue;
                document.getElementById('Model').options.add(opt);
            }
        }
    }
}

Now call this method on the onChange event of the company drop-down.

<select id="Company" onchange="loadXMLOption();">

Thats it and now we have a truly dynamic Chained Drop-downs. You can change or add the model values in the XML file. If you want an easy way to develop chained drop-down without involving XML, you can try this post.
You can get the entire code from below. Comments and suggestions are welcome.

<html>
<head>

<script language="javascript">
/* Cross-Browser Import of XML document into a XML Document. */
function importXML(xmlfile) {
    var xmlDoc;
    if (typeof window.ActiveXObject != 'undefined') {
        //code for IE
        xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
        xmlDoc.async = false;
        xmlDoc.load(xmlfile);
        } else {
            try {
                // code for IE7+, Firefox, Chrome, Opera, Safari
                xmlhttp=new XMLHttpRequest();
                xmlhttp.open("GET", xmlfile, false);
                xmlhttp.setRequestHeader('Content-Type', 'text/xml');
                xmlhttp.send();
                xmlDoc=xmlhttp.responseXML;
            } catch (Exception) {
                alert("Your browser is not supported. Try firefox !!");
            }
        }
    return xmlDoc;
}

/* Get the options for the model combobox from the XML. */
function loadXMLOption() {
    // Load the xml file
    var xmlDoc=importXML("info.xml");
    xmlObj=xmlDoc.documentElement;
    // Get all Elements with Tag name 'device'
    DeviceObj = xmlObj.getElementsByTagName("device");
    for(var i=0; i < DeviceObj.length; i++) {
        // Loop through each device tag and check if its name is equal to the selected device value
        if (document.getElementById('Company').value == DeviceObj[i].getAttribute("name")) {  
            // If matching device found get the model tags under that device
            modelObj = DeviceObj[i].getElementsByTagName("model");
            document.getElementById('Model').options.length = 0;
            // Create options for the Model comboBox.
            for(var j=0; j < modelObj.length; j++) {
                var opt = document.createElement('option');
                opt.value = modelObj[j].firstChild.nodeValue;
                opt.text = modelObj[j].firstChild.nodeValue;
                document.getElementById('Model').options.add(opt);
            }
        }
    }
}
</script>

</head>
<body>

<h2>Chained Drop-Down - using XML</h2>

Device : <select id="Company" onchange="loadXMLOption();">
  <option value=""></option> 
  <option value="Samsung">Samsung</option>
  <option value="Apple">Apple</option> 
  <option value="Nokia">Nokia</option>
</select>

Model : <select id="Model"> </select>

</body>
</html>

Chained DropDown in Javascript

noreply@blogger.com (Unknown) — Tue, 03 Jul 2012 14:55:00 +0000

You might have seen chained drop-downs in some sites, where changing a value in one drop-down causes new values to be populated in another drop-down. This chain effect can be simply implemented using Javascript.

At first, we will create the two drop-downs for which we are implementing the chained effect. We will provide the options in the 1st drop-down. No options need to be given for the 2nd drop-down and it values will be populated dynamically based upon the value of the 1st drop-down. We have named the first drop-down 'Company' which lists some mobile companies. The second drop-down 'Model' will list out few models for the selected company.

<select id="Company" >
 <option value=""></option>
 <option value="Samsung">Samsung</option>
 <option value="Apple">Apple</option>
 <option value="Nokia">Nokia</option>
</select>

<select id="Model"> </select>

Now on to the coding part. The configureDropDown method is fired on the change of value in the Company drop-down and populates the values in the 'Model' drop-down. We will first define the arrays containing the value of models for each company. Now we will check the value of the Company drop-down and based on it get the values for the Model drop-down.

/* Configure the DropDown ddl2 based on the value selected in DropDown ddl1. */
function configureDropDown(ddl1,ddl2) {

 // Arrays holding the value for ddl2 (model comboBox).
 var Nokia = new Array('Lumia', 'PureView');
 var Samsung = new Array('Galaxy S3', 'Galaxy S2');
 var Apple = new Array('iPhone4', 'iPhone5');
  
 // Check the value in ddl1 (Company comboBox).
 switch (ddl1.value) {
  case 'Samsung':
   getOptionsFromArray(Samsung, document.getElementById(ddl2));
   break;
  case 'Apple':
   getOptionsFromArray(Apple, document.getElementById(ddl2));
   break;
  case 'Nokia':                 
   getOptionsFromArray(Nokia, document.getElementById(ddl2));
   break;
  default:
   document.getElementById(ddl2).options.length = 0;
   break; 
 }
}

The getOptionsFromArray method retrieves the options for the model combobox from the respective array. The method loops through the entire array and adds the array values as options to the drop-down.

// Get the options for the model combobox from the respective array. 
function getOptionsFromArray(selectArray, select) {
 select.options.length = 0;
 // Create option for the comboBox.
 for (i = 0; i < selectArray.length; i++) {
        var opt = document.createElement('option');
  opt.value = selectArray[i];
  opt.text = selectArray[i];
  select.options.add(opt);
 }
}

Now call this method on the onChange event of the company drop-down.

<select id="Company" onchange="configureDropDown(this,'Model')">

This finishes our tutorial. We now have a 'Model' drop-down whose values changes depending on the value of Company drop-down. You can get the entire code from below.

<html>
<head>
<script type="text/javascript">

     /* Configure the DropDown ddl2 based on the value selected in DropDown ddl1. */
     function configureDropDown(ddl1,ddl2) {

 // Arrays holding the value for ddl2 (model comboBox).
 var Nokia = new Array('Lumia', 'PureView');
 var Samsung = new Array('Galaxy S3', 'Galaxy S2');
 var Apple = new Array('iPhone4', 'iPhone5');
  
 // Check the value in ddl1 (Company comboBox).
 switch (ddl1.value) {
      case 'Samsung':
           getOptionsFromArray(Samsung, document.getElementById(ddl2));
           break;
      case 'Apple':
           getOptionsFromArray(Apple, document.getElementById(ddl2));
           break;
      case 'Nokia':                 
           getOptionsFromArray(Nokia, document.getElementById(ddl2));
           break;
      default:
           document.getElementById(ddl2).options.length = 0;
           break; 
 }
    }
 
     // Get the options for the model combobox from the respective array. 
     function getOptionsFromArray(selectArray, select) {
 select.options.length = 0;
 // Create option for the comboBox.
 for (i = 0; i < selectArray.length; i++) {
        var opt = document.createElement('option');
      opt.value = selectArray[i];
      opt.text = selectArray[i];
      select.options.add(opt);
 }
     }
</script>
</head>
<body>

<h2>Chained Drop-Downs</h2><br/>

<select id="Company" onchange="configureDropDown(this,'Model')">
 <option value=""></option> 
 <option value="Samsung">Samsung</option>
 <option value="Apple">Apple</option> 
 <option value="Nokia">Nokia</option>
</select>  
<br/>

<select id="Model"> </select>

</body>
</html>

Your comments and suggestions are welcome.

Create Plug-in project in Eclipse

noreply@blogger.com (Unknown) — Wed, 27 Jun 2012 19:42:00 +0000

In this post we will learn how to create a plug-in project in Eclipse using the plug-in development environment (PDE).

At its simplest, a plug-in project requires a MANIFEST.MF file describing the plugin and its dependencies and, if extending the workbench a plugin.xml file identifying the extension points being implemented, and a set of Java classes implementing those extension points.

1. The first step involves opening your Eclipse workspace and creating a new Plug-in project.You can do it from Select File->New->Project. Then in the opening dialog box select the Plug-in Project wizard. Then Click Next.

2. Enter the project name of your choice. Leave the other options as default and click Next.

3. Again no changes to the default options and click Next.

4. In the next dialog select the Hello World template and press the Finish button. This should automatically open the Plug-in Development perspective.

5. Your new plugin project is created with the Plug-in Development perspective. This is how our plug-in project will look in the Package Explorer.

Now lets discuss about the plug-in related files we see in our Project explorer. If you have created a java project before then you would be knowing about the build.properties file. For those who are not familair with java project, the build.properties file declares the libraries where the plug-in code is packaged. At runtime, the class loader searches these libraries when loading the plug-in's classes.

The manifest file describes the content of the plug-in to the Eclipse runtime. In addition to basic plug-in information such as plug-in identifier, version, etc., this file contains four main sections: Dependencies, Extensions, Runtime and Extension Points section.

Dependencies section lists all the plug-ins required by the plug-in. A plug-in must list as dependencies all the plug-ins needed for its code to compile and all the plug-ins contributing extension points that it is using.

The Extensions section declares all the functionalities that this plug-in contributes to the platform by extending other plug-ins' extension points.

The plugin.xml specifies the extension. It is the central place for configuring the plugin being developed. This sample plugin’s extension point is org.eclipse.ui.actionSets.

Your plugin is created and you are ready to go. Now you only need to add the code to implement the extension points.

In our coming tutorial we will learn how to create a working JDT plugin project using Eclipse.
Comments and Suggestions are appreciated.

Calendar using Javascript (with css)

noreply@blogger.com (Unknown) — Fri, 22 Jun 2012 19:55:00 +0000

This post discusses on how to make a simple, elegant monthly calendar using javascript. You can change the appearance of the calendar by simply changing the CSS to suit your needs. The calendar displays the current days of the month and highlights the current day.

This is how our calendar will look after we complete this post. You can easily change the calendar appearance by modifying this css, everything from calendar dimensions, colors, spacing, down to the font used to highlight the current day. My aim is to present an basic understanding of date manipulations and thus this post will not cover the advanced options like moving between next and previous months.

Now lets move onto the javascript code details.
First we will define some constant variables which we will require in our code.

// Array to store month names
var months = new Array('January',' February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'); 

// Array to store month days
var monthDays = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);

// Array to store week names
var weekDay = new Array('Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa', 'Su');

Next we will get the current date properties by instantiating a 'Date' object. The below code gets the current date, month, year and the number of days for current month.

var date = new Date();

var day = date.getDate();
var month = date.getMonth();
var year = date.getFullYear();
var days_in_this_month = monthDays[month];

Then get the week-day for the 1st day of the month. We will require this to add blank columns at the beginning in our calendar table.

var first_week_day = new Date(year, month, 1).getDay();

Now as we have set up all the variables, on to the code for displaying the calendar. The comments in the code will help you understand the logic of each statement.

// Define the variable which holds the calendar table
  var calendar_html = '<table class="calendarTable">';

  // Create row for displaying current month and year
  calendar_html += '<tr><td class="monthHead" colspan="7">' + months[month] + ' ' + year + '</td></tr>';
  calendar_html += '<tr>';

  // Create row to display the week days (Monday - Sunday)
  for(week_day= 0; week_day < 7; week_day++) {
        calendar_html += '<td class="weekDay">' + weekDay[week_day] + '</td>';
  }
  calendar_html += '</tr><tr>';

  // Fill first row of the month with empty cells until the month starts.
  for(week_day = 0; week_day < first_week_day; week_day++) {
        calendar_html += '<td> </td>';
  }

  // Populate the days in the month
  week_day = first_week_day;
  for(day_counter = 1; day_counter <= days_in_this_month; day_counter++) {

        week_day %= 7;
        // Check if week ends, if yes move to next row
        if(week_day == 0)
              calendar_html += '</tr><tr>';

        // Show the current day in bold.
        if(day == day_counter)
          calendar_html += '<td class="currentDay">' + day_counter + '</td>';
        else
          calendar_html += '<td class="monthDay"> ' + day_counter + ' </td>';

        week_day++;
  }
  
  // Close the Calendar table
  calendar_html += '</tr>';
  calendar_html += '</table>';

  // Display the calendar.
  document.write(calendar_html);

Now on to styling the calendar. The following css styles will give a simple style to your calendar. You can easily change the calendar appearance by modifying this css, everything from calendar dimensions, colors, down to the font used to highlight the current day.

.calendarTable {
    background-color:#eee;
    color:#333;
    border: 1px solid #bbb;
}
.calendarTable td {
    text-align: center;
    padding: 2px 4px 2px 4px;
}
.calendarTable td.monthHead {
    font-weight: bold;
    border: 1px solid #bbb;
    background-color:#ddd;
}
.calendarTable td.weekDay {
    font-weight: bold;
}
.calendarTable td.monthDay {
    border: 1px solid #ddd;
}
.calendarTable td.currentDay {
    font-weight: bold;
    color:#ad5;
    border: 1px solid #aaa;
}

We have finished designing our basic calendar. If you have any question let me know in the comments. You can find the entire code along with html below.

<html>
<title>www.scriptSplash.com => javaScript - Basic Calendar</title>
<head>
<style type="text/css">
.calendarTable {
    background-color:#eee;
    color:#333;
    border: 1px solid #bbb;
}
.calendarTable td {
    text-align: center;
    padding: 2px 4px 2px 4px;
}
.calendarTable td.monthHead {
    font-weight: bold;
    border: 1px solid #bbb;
    background-color:#ddd;
}
.calendarTable td.weekDay {
    font-weight: bold;
}
.calendarTable td.monthDay {
    border: 1px solid #ddd;
}
.calendarTable td.currentDay {
    font-weight: bold;
    color:#ad5;
    border: 1px solid #aaa;
}
</style>
<script type="text/javascript" language="javascript">
/** Function to display a Calendar based on javascript. **/
function calendar() {
  // Get the current date parameters.
  var date = new Date();
  var day = date.getDate();
  var month = date.getMonth();
  var year = date.getFullYear();
  
  var months = new Array('January','February','March','April','May','June','July','August','September','October','November','December');
  var monthDays = new Array(31,28,31,30,31,30,31,31,30,31,30,31);
  var weekDay = new Array('Mo','Tu','We','Th','Fr','Sa','Su');
  var days_in_this_month = monthDays[month];

  // Create the basic Calendar structure.
  var calendar_html = '<table class="calendarTable">';
  calendar_html += '<tr><td class="monthHead" colspan="7">' + months[month] + ' ' + year + '</td></tr>';
  calendar_html += '<tr>';
  var first_week_day = new Date(year, month, 1).getDay();
  for(week_day= 0; week_day < 7; week_day++) {
    calendar_html += '<td class="weekDay">' + weekDay[week_day] + '</td>';
  }
  calendar_html += '</tr><tr>';

  // Fill the first week of the month with the appropriate number of blanks.
  for(week_day = 0; week_day < first_week_day; week_day++) {
    calendar_html += '<td> </td>';
  }
  week_day = first_week_day;
  for(day_counter = 1; day_counter <= days_in_this_month; day_counter++) {
    week_day %= 7;
    if(week_day == 0)
      calendar_html += '</tr><tr>';
    // Do something different for the current day.
    if(day == day_counter) {
      calendar_html += '<td class="currentDay">' + day_counter + '</td>';
    } else {
      calendar_html += '<td class="monthDay"> ' + day_counter + ' </td>';
 }
    week_day++;
  }
  calendar_html += '</tr>';
  calendar_html += '</table>';
  // Display the calendar.
  document.write(calendar_html);
}
</script>
</head>
<body>
  <h2> Basic Calendar </h2>
  <br/>
  <script type="text/javascript">calendar();</script>
</body>
</html>

Scroll to Top effect using jQuery

noreply@blogger.com (Unknown) — Tue, 19 Jun 2012 16:46:00 +0000

Many of us have been using jQuery lately, but as it goes i was very much contend with using javascript, much because of learning another language. Then i had to use jQuery for one of my company projects, and alas i hoped that i had learned jQuery much earlier.

jQuery is a simple and tiny javascript framework which provides you with custom functions which may take days to code in native javascript. Here is one of the easy and small example of jQuery that i learned during the project. This will give you an insight of how much simpler jQuery is. You can freely download jQuery from here.

In informational sites you might have seen a 'Top' link which actually moves you to the top of the web page. This link actually links to the '#top' html anchor which signifies the top of the body. Though helpful it is a bit old and abrupt. How about we replace it with a animated scroll to top button?

Using the old approach, you can place the below code in your body tag.

<a href="#top"><img src="top.jpg" alt="back to top"/></a>

Clicking on this link will take you to the top of the page. (Make sure the page spans more than the browser window, so that the scrolls are enabled and you can see the result. Also place the link somewhere at the end of the page.)

You can use this sample image.

Now we will do with jQuery with an added scrolling effect. First create a div (somewhere at the end of page) and place the image in this div. Clcking on this image will scroll you to the top of the page.

<div id="topArrow"> <img src="top.jpg" alt="scroll to top" /> </div>

Now the jquery part,

$(document).ready(function() {
    // function for scrolling the body to top.
    $('#topArrow').click(function () {

        // animate the page to scroll to top when the link is clicked
        $('body,html').animate({
            scrollTop: 0
        }, 1000);
        return false;
    });
});

When the 'topArrow' div is clicked, it will animate the body by scrolling it to the top. We use jQuery's 'animate' function for this. The first parameter to animate method denotes the properties or simply the type of animation (we can also have fade, opacity,left etc). The second parameter denotes duration of animation. Other optional parameters include ease and function to call once the animation is complete. Detailed info for 'animate' function can be found from here.

If you want to the arrow link to be always displayed at the bottom of the page, rather than placing it in the page, the following css enables you to do so.

/* Style for the arrow link */
#topArrow {
 position:fixed;
 bottom:0%;
 left:75%;
 display: block;
 padding:20px;
}

The position:fixed css attribute let the image to stay fixed at the bottom the page.

Note: In some IE versions the position:fixed attribute doesn't work properly and the link will remain at top of the page. Place the below Doctype declaration on the top of the page code (above html tag), to resolve this problem.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

If you are not into coding or want a simpler solution you can try the UItoTop jQuery Plugin. It’s easy to setup with only one line of code, and it works cross-browser nicely.

You can download the code for this post from here.
Thats all for this post. Will be back with more interesting jQuery snippets.

Auto Refresh in Javascript

noreply@blogger.com (Unknown) — Fri, 15 Jun 2012 17:34:00 +0000

There are times when we will need a page to be automatically refreshed. This is mainly seen in pages where the data varies with time and needs to be constantly updated over the timeframe. Eg: Live Score Cards, Live Election results etc. There are two ways by which we can perform a HTML Page refresh.

i) Using the HTML META tag in the header of the page
ii) Using Javascript - Location.reload

Using Meta Header Tag

This way is useful when the user has disabled javascript on his browser. You need to place the below code inside your webpage’s Head tag.

<head>
<meta http-equiv="refresh" content="60" />
</head>

The value of the content attribute determines the time interval (in seconds) for the page refresh. The above code will automatically refresh the page in 1 minute (60 seconds).

Using Javascript

The Location.reload method forces a reload of the window's current document, i.e. the one contained in the Location.href property. The below javscript function will automatically reload the page after the given time period. In the below function the refresh interval (in milliseconds) is passed as the method argument.

function autoRefresh(refreshPeriod) {
    setTimeout("window.location.reload();",refreshPeriod);
}

The function then needs to be called from the HTML Body tag’s onLoad event.

<body onload="autoRefresh(60000);">

  This will cause the page to be refreshed every 1 minute (60000 milliseconds = 60 seconds) after it have been loaded.

  The location.reload method behaves in exactly the same way as the browser's reload button which, by default reloads from the cache. If, however, the user wants to reload the document from the server (for fetching an updated version), he can do so by supplying 'true' as the parameter to the reload method. Thus location.reload(true) will force the page to be loaded from server rather than from the cache.

  Having an automatic page refresh might be quite annoying sometimes, as reloading a content rich page might consume considerable bandwidth for the user, thus resulting in a bad interaction experience with the website. This can be avoided by having a User interactive refresh rather than an auto refresh. This can be done by calling the location.reload method on a Link.

<a href=" window.location.reload();"> Refresh this page </a>

Or you can do this using a button click.

<input type="button" value="Reload Page" onClick="window.location.reload();">

This will cause the page to be reloaded instantly. The link will cause the page to be reloaded from the cache, while click on the button will cause the page to be reloaded from server.

There is also another way in javascript to refresh a page using window.location

<input type="button" value="Reload Page" onClick=" window.location = document.URL;">

The minus with this approach is that, this will not reload the page if there is a hash (#) in the URL.

Meta Refresh vs. Javascript Refresh

Meta refresh usage is discouraged by the W3C over other methods. Therefore you should use JavaScript as your primary means for automatic page refreshes and a META tag as your fallback.
Below are the drawbacks of using Meta tag for refresh:

If a page redirects too quickly (less than 2-3 seconds), using the "Back" button on the next page may cause some browsers to move back to the redirecting page, whereupon the redirect will occur again. This is bad for usability, as this may cause a reader to be "stuck" on the last website.
A reader may or may not want to be redirected to a different page, which can lead to user dissatisfaction or raise concerns about security

You can find the entire code along with html from below.

<html>
<head>
<noscript>
    <meta http-equiv="refresh" content="60" />
</noscript>
<script type="text/javascript" language="javascript">
  /** Function to refresh the page at specified interval. **/
  function autoRefresh(refreshPeriod) {
      setTimeout("window.location.reload();",refreshPeriod);
  }
</script>
</head>
<body onload="autoRefresh(10000);">
  <h2> Auto Refresh </h2>
  This page autorefreshes in 10 seconds. <br/>
  You can also perform a manual refresh by clicking any of the link/button below.
  <br/><br/>
  <a href="javascript:window.location.reload();"> Refresh this page - Cached </a>
  <br/><br/>
  <input type="button" value="Reload Page - Server" onClick="window.location.reload(true);">
  <br/><br/>
  <input type="button" value="Reload Page" onClick=" window.location = document.URL;">
  <br/><br/>
</body>
</html>

Password Strength Checker using Javascript

noreply@blogger.com (Unknown) — Tue, 29 May 2012 19:16:00 +0000

You must have seen in sites like Gmail, when we fill the SignUp or Registration form, the strength of our password is shown as we enter our password. This functionality is very useful in helping us determine our password’s strength and thus securing our account more strongly against any password hacking attacks.

In this post we shall discuss how to make such a Password Strength Checker using javascript. The following checks are done to assess the strength of the password:

If password has more than 6 characters
If password has both lower and uppercase characters
If password has a number
If password has at least one special character
If password has more than 12 characters

A password conforming to all these conditions can be termed as the strongest password. The Password Strength Checker dose not perform any password validations, and only checks the strength of the password.

The form for the example consists of a password field and a div field which shows the strength of the password.

<form>
      Password: <input type="password" name="pword" id="pword" />
      <div id="passwordStrength" class="default" > Enter your password </div>
</form>

The javascript method for analyzing the password strength is given below :

function returnPasswordStrength(password) {

        var msg = new Array("Very Weak", "Weak", "Better", "Medium", "Strong", "Strongest");
        var strength   = 0;

        // If password has more than 6 characters add one to strength
        if (password.length > 6) strength++;

        //if password has both lower and uppercase characters add one to strength
        if ( ( password.match(/[a-z]/) ) && ( password.match(/[A-Z]/) ) ) strength++;

        //if password has at least one numeral add one to strength
        if (password.match(/\d+/)) strength++;

        //if password has at least one special character add one to strength
        if ( password.match(/.[!,@,#,$,%,^,&,*,?,_,~,-,(,),'\s']/) ) strength++;

        //If password has more than 12 characters add one to strength
        if (password.length > 12) strength++;

        document.getElementById("passwordStrength").innerHTML = msg[strength];
}

In the above code we will check whether the entered password satisfies each condition. For each satisfied condition the strength is increased by one. The ‘msg’ array stores the messages for each strength value. The message corresponding to the current strength is shown in the ‘passwordStrength’ div.

As the password strength needs to be checked after entering every character, the javascript function for assessing the strength needs to be called on KeyUp event of the password field.

<input type="password" name="pword" id="pword" onkeyup="returnPasswordStrength(this.value)" />

The background color of the div can also be changed be defining CSS classes for each strength value and applying them on KeyUp event.

document.getElementById("passwordStrength").className = "class"+strength;

You can download the entire code from here.
Please do enter your valuable comments and suggestions

Simple Ajax Request – Loading a Text File

noreply@blogger.com (Unknown) — Sun, 06 May 2012 14:52:00 +0000

        Before starting the tutorial just a look into “what is Ajax ?”. Ajax is nor a programming language neither it is a framework, instead it is a technique used to develop Rich Internet Applications, i.e. applications which are more faster, more graphical and more interactive. AJAX (Asynchronous Javascript and XML) is a combination of several existing technologies rather than being a single technology.

       Here are the basic technologies involved in Ajax applications:
• HTML is used to build Web forms and identify fields for use in the rest of your application.
• JavaScript code is the core code running Ajax applications and it helps facilitate communication with server applications.
• DHTML, or Dynamic HTML, is used to update your forms dynamically. You'll use div, span, and other dynamic HTML elements to mark up your HTML.
• Server Side Scripting is used to process the query passed by Javascript and returns the response XML.

       Thus with AJAX, a JavaScript can communicate directly with the server(with a XMLHttpRequest object) and transfer data with it asynchronously, i.e. without submitting or reloading the page.

       The XMLHttpRequest object is the key component to Ajax that makes it so useful. It provides a mechanism for the client (through Javascript) to send information to the server and receive a response as XML. The response XML can be processed in the background and used to dynamically update elements on the page. In effect, information flows, and screens are updated, more like in desktop applications than in old-fashioned web applications.

       Now lets move to the coding part. Basic AJAX is normally composed of three JavaScript functions:
1. A function that creates an XMLHttpRequest object
2. A function that calls the XMLHttpRequest object and submits it,
3. A function that handles the information sent back to the page.

       Lets look at the first function. We first declare a variable with name xmlHttp. Now depending upon the browser an ‘xmlHttpRequest’ object is created and assigned to this variable. If the browser is Internet Explorer, then we have to create a new ‘ActiveX Object’ and if the browser is Firefox,Opera etc, then we have to create a new ‘xmlHttpRequest’ which is a built in object. The function then returns the just constructed object.

function getXMLHttp() {
        var xmlhttp;
        if (window.ActiveXObject) {
                xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
        } else if (window.XMLHttpRequest) {
                xmlhttp = new XMLHttpRequest();
        } else {
                alert("Your browser does not support Ajax!");
        }
        return xmlhttp;
}

In the second function we use the first function to create an xmlHttpRequest object and open an HTTP connection using it. We pass three parameters in the xmlHttp.Open() function. First is the submit method (it can be POST or GET). Second is the URL ,which contains the serve side processing (here to make it simple we are using a text file) and which returns the result to the script as xml. Third is a boolean value which states whether the transfer is asynchronus(true) or synchronus(false). Next we call a function when the ready state changes(loaded, loading, not loaded). Next we send a null to the other page (may not be null for POST , but always null for GET).

function getTextInfo() {
   xmlhttp1=getXMLHttp();
   var url =”"demo1.txt” ;
   xmlhttp1.open("GET",url,true); 
   xmlhttp1.onreadystatechange = updateInfo;
   xmlhttp1.send(null); 
}

In the ‘readyStateChange’unction we first check whether the reponse is loaded (whether state is 4). The content of the text file is transferred as reponse text. We get the content into a variable and display it to a textarea/div.

function updateInfo() {
        if (xmlhttp1.readyState == 4) {
              var response = xmlhttp1.responseText;
              document.getElementById("showText").value = response;
        }
}

This sums up the tutorial. Hope this was useful for you.
Please enter your valuable comments and suggestions.
You can find the entire code along with html from below.

<html>
<html>
<title>ScriptSplash.com - Simple Ajax Request</title>
<head>
<script language="javascript">
/** Create a cross-browser XMLHttp Request object. **/
function getXMLHttp() {
    var xmlhttp;
    if (window.ActiveXObject) {
        xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
    } else if (window.XMLHttpRequest) {
       xmlhttp = new XMLHttpRequest();
    } else {
        alert("Your browser does not support XMLHTTP!");
    }
    return xmlhttp;
}
/** Get the content of a text file using Ajax. **/
function getTextInfo() {
    xmlhttp1=getXMLHttp();
    xmlhttp1.open("GET","AjaxTest.txt",true); 
    xmlhttp1.onreadystatechange = updateInfo;
    xmlhttp1.send(null); 
    return false;
}
/** Check for response and update the text-area. **/
function updateInfo() { 
    if(xmlhttp1.readyState == 4) { 
        response=xmlhttp1.responseText;
        document.getElementById("showText").value = response; 
    } 
}
</script>
</head>
<body>
  <h2>Get content of text file</h2>
  <h4>Click to get the content of a text file via AJAX</h4>
  <form>
  <textarea name="showText" id="showText" style="width:400px;height:400px;"></textarea><br/>
  <input type="button" value="Get Content" onClick="getTextInfo();">
  <form>
</body>
</html>

City World Clock - based on Timezone

noreply@blogger.com (Unknown) — Sun, 29 Apr 2012 13:00:00 +0000

This javascript code snippet allows you to display the time of a city, selected from a drop-down. It also loads the current time and location as the default time and location (based on computer’s timezone and entry in dropdown list). The script is mostly similar to the previous post.

Here also we have 2 divs for displaying time and date, and a select drop-down for selecting city. We are also using the ‘calculateZoneTime()’ function for calculating time. Also we have slightly modified ‘returnFormattedDate()’ and ‘returnFormattedTime()’ functions for formatting date and time respectively. The time is updated every second using the ‘init()’ function. The ‘init()’ function calls the ‘calculateZoneTime()’ function and repeats itself using the setInterval function.

An additional function is ‘calculateDefaultTimeZone()’ which is used for calculating the computer’s current timezone and setting the html select to that particular timezone on page load.

function calculateDefaultTimeZone() {

      var newDate = new Date();
      // finding current timezone – received in decimal format
      var timeOffset = (newDate.getTimezoneOffset()/60) * (-1);
      var timeZone1 = document.getElementById('selectTZ1');
      // converting decimal format to “hh:mm” format
      var formattedOffset = formatTimeOffset(timeOffset);
  
      if (timeZone1)  {
            // finding the current timezone in select drop-down
            for (var i = 0; i < timeZone1.options.length; i++) {
                  if (timeZone1.options[i].value == formattedOffset) {
                        timeZone1.selectedIndex = i;
                         break;
                  }
            }
      }
}

The ‘formatTimeOffset()’ function converts the calculated current time zone from a decimal format to a “+/-hh:mm” format. Here is the function code:

function formatTimeOffset(value) {
      var hours = parseInt(value);
      value -= parseInt(value);
      value *= 60;
      var mins = Math.abs(parseInt(value));
      var display_hours = hours; 
      var display_mins = (mins < 10) ? ("0" + mins) : mins;
      timeZoneString = display_hours + ":" + display_mins;
      return timeZoneString;
}

Please enter your valuable comments and suggestions.
You can find the entire code along with html from below.

<html>
<head>
<title> City clock </title>
<style>
  body {
      text-align : center;
  }
  select {
      width: 130px;
  }
  .mainDiv {
      width : 170px;
      height : 170px;
      background-color : #eeeeee; 
  }
  .subDiv {
      width : 130px;
  }
  #timeText1 {
      font-size: 17px;
      font-weight: bold;
      font-family: Trebuchet MS, Lucida Sans Unicode, Arial, sans-serif;
  }
  #dayText1 {
      font-size: 13px;
      font-weight: bold;
      font-family: Trebuchet MS, Lucida Sans Unicode, Arial, sans-serif;
  }
</style>
<script type="text/javascript" language="javascript">
/** Initialises the Clock and updates it every second. **/
function init() {
    try {
        clearInterval(myInterval);
    } catch(err){}
    calculateZoneTime(document.getElementById("selectTZ1").value,1);
    myInterval = setInterval("init()",1000);
}
/** Calculates the default time zone based on System Date. **/
function calculateDefaultTimeZone() {
    var newDate = new Date();
    var timeOffset = (newDate.getTimezoneOffset()/60) * (-1);
    var timeZone1 = document.getElementById('selectTZ1');
    var formattedOffset = formatTimeOffset(timeOffset);
    if (timeZone1) {
        for (var i = 0; i < timeZone1.options.length; i++) {
            if (timeZone1.options[i].value == formattedOffset) {
                timeZone1.selectedIndex = i;
                break;
            }
        }
    }
}
/** Format the time based upon the time-zone. **/
function formatTimeOffset(value) {
    var hours = parseInt(value);
    var mins = Math.abs((value - parseInt(value)) * 60);
    var display_mins = (mins < 10) ? ("0" + mins) : mins;
    var timeZoneString = hours + ":" + display_mins;
    return timeZoneString;
}
/** Populates the Time and Date based upon the current time-zone. **/
function calculateZoneTime(TimeZoneOffset,num) {
    var lDate = new Date();
    try {
        var timeArray = TimeZoneOffset.split(":");
        var hrs = parseInt(timeArray[0]);
        var mins = parseInt(timeArray[1])/60;
    } catch(err){}
    var ZoneOffset = (hrs > 0) ? (hrs + mins) : (hrs - mins);
    var ms = lDate.getTime() + (lDate.getTimezoneOffset() * 60000) + ZoneOffset * 3600000;
    var time =new Date(ms);
    var dayText = returnFormattedDate(time);
    var timeText =returnFormattedTime(time);
    document.getElementById("timeText"+num).innerHTML=timeText;
    document.getElementById("dayText"+num).innerHTML=dayText;
}
/** Returns the Time in HH:mm:ss PM/AM format. **/
function returnFormattedTime(dateObject) {
    var hrs = dateObject.getHours();
    var mins = dateObject.getMinutes();
    var seconds = dateObject.getSeconds();
    var meridian = "am";
    if (hrs == 12) {
        meridian = "pm";
    } else if(hrs == 0) {
        meridian = "am";
        hrs = 12;
    } else if(hrs > 12) {
        meridian = "pm";
        hrs = hrs - 12;
    }
    display_hours = (hrs < 10) ? ("0" + hrs) : hrs;
    display_mins = (mins < 10) ? ("0" + mins) : mins;
    display_seconds = (seconds < 10) ? ("0" + seconds) : seconds;
    return ( display_hours + " : " + display_mins +" : " + display_seconds +"" + meridian);
}
/** Returns the Date in Day,dd:MMM:yyyy format **/
function returnFormattedDate(dateObject) {
    var tdate = dateObject.getDate();
    var tmnth = dateObject.getMonth()
    var tyear = dateObject.getYear() ;
    var tday= dateObject.getDay();
    var mnthName = new Array("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec");
    var dayName = new Array("sun","Mon","Tue","Wed","Thu","Fri","Sat");
    return ( dayName[tday] + " , " + tdate + " " + mnthName[tmnth] + " " + tyear ); 
}
</script> 
</head>
<body onload="calculateDefaultTimeZone();init();">
<div align="center" class="mainDiv">
<h3><u><i> CITY CLOCK </i></u></h3>
<div id="div1" class="subdiv">
    <div name="timeText1" id="timeText1"></div><br/>
    <div name="dayText1" id="dayText1"></div><br/>
    <select name='selectTZ1' id='selectTZ1'>
        <option value='4:00'>Abu Dhabi</option>
        <option value='9:30'>Adelaide</option>
        <option value='1:00'>Amsterdam</option>
        <option value='2:00'>Athens</option>
        <option value='3:00'>Baghdad</option>
        <option value='7:00'>Bangkok</option>
        <option value='8:00'>Beijing</option>
        <option value='1:00'>Berlin</option>
        <option value='-3:00'>Brasilia</option>
        <option value='-3:00'>Beunos Aires</option>
        <option value='5:30'>Bangalore</option>
        <option value='1:00'>Budapest</option>
        <option value='1:00'>Brussels</option>
        <option value='2:00'>Cairo</option>
        <option value='2:00'>Cape Town</option>
        <option value='10:00'>Canberra</option>
        <option value='-6:00'>Chicago</option>
        <option value='1:00'>Copenhagen</option>
        <option value='5:30'>Colombo</option>
        <option value='5:30'>Chennai</option>
        <option value='3:00'>Doha</option>
        <option value='-6:00'>Dallas</option>
        <option value='3:00'>Dar es Salaam</option>
        <option value='6:00'>Dhaka</option>
        <option value='4:00'>Dubai</option>
        <option value='0:00'>Greenwich</option>
        <option value='2:00'>Harare</option>
        <option value='-5:00'>Havana</option>
        <option value='2:00'>Helsinki</option>
        <option value='8:00'>HongKong</option>
        <option value='5:00'>Islamabad</option>
        <option value='2:00'>Istanbul</option>
        <option value='7:00'>Jakarta</option>
        <option value='2:00'>Jerusalem</option>
        <option value='4:30'>Kabul</option>
        <option value='5:45'>Kathmandu</option>
        <option value='8:00'>Kuala lampur</option>
        <option value='5:00'>Karachi</option>
        <option value='1:00'>Lagos</option>
        <option value='0:00'>London</option>
        <option value='-8:00'>Los Angeles</option>
        <option value='5:30'>Mumbai</option>
        <option value='1:00'>Madrid</option>
        <option value='8:00'>Manila</option>
        <option value='-6:00'>Mexico city</option>
        <option value='3:00'>Moscow</option>
        <option value='4:00'>Muscat</option>
        <option value='3:00'>Nairobi</option>
        <option value='5:30'>New Delhi</option>
        <option value='-5:00'>New York</option>
        <option value='1:00'>Oslo</option>
        <option value='1:00'>Paris</option>
        <option value='8:00'>Perth</option>
        <option value='-7:00'>Phoenix</option>
        <option value='9:00'>Pyongyang</option>
        <option value='-3:00'>Rio de Janeiro</option>
        <option value='3:00'>Riyadh</option>
        <option value='1:00'>Rome</option>
        <option value='9:00'>Seoul</option>
        <option value='8:00'>Singapore</option>
        <option value='1:00'>Stockholm</option>
        <option value='10:00'>Sydney</option>
        <option value='8:00'>Taipei</option>
        <option value='3:30'>Tehran</option>
        <option value='9:00'>Tokyo</option>
        <option value='-5:00'>Toronto</option>
        <option value='1:00'>Vienna</option>
        <option value='1:00'>Vatican city</option>
        <option value='-5:00'>Washington DC</option>
        <option value='12:00'>Wellington</option>
        <option value='6:30'>Yangon</option>
    </select>
</div>
</div>
</body>
</html>

World Clock - based on Timezone

noreply@blogger.com (Unknown) — Sun, 22 Apr 2012 13:42:00 +0000

This javascript code allows you to display the time based on the user’s timezone. The script makes use of the inbuilt javascript ‘Date’ object and its functions. The clock displays time in the default 12 hour format, that can be changed to a 24 hours using a radio button. Also we are displaying the current day and date. The user can also change the timezone using a select box, and thus can view the current time in different timezones.

First lets have a look at the form. The form consists of two div elements, one for displaying time and the other for displaying day and date. There is a select element (selectTZ) which consists of all time-zones.

<div name="timeText" id="timeText"></div>
<div name="dayText" id="dayText"></div>
<select name='selectTZ' id='selectTZ'>
    <option value='0'>Select your Timezone</option>
    <option value='-12:00'>(-12:00) International Date Line West</option>
    <option value='-11:00'>(-11:00) Midway Island, Samoa</option>
          ……………….
</select>

Now lets start with the javascript code. First we have to retrieve the current date and time. The following line of code do this.

// create new date object
  var time =  new Date();
  // get the formatted date value 
  var dayText = returnFormattedDate(time);
  // get the formatted time value (hh:mm:ss or hh:mm:ss pm/am))
  var timeText =  returnFormattedTime(time);
  // passing formatted value to divs
  document.getElementById("timeText").innerText=timeText;     
  document.getElementById("dayText").innerText=dayText;

The ‘returnFormattedDate()’ and ‘returnFormattedTime()’ functions return the date and time respectively in a specific format. ‘returnFormattedDate()’ returns date in “Monday, 01 January 2010” format. Whereas, ‘returnFormattedTime()’ returns time in any of the two formats, “23:45:06” or “11:45:06 pm”.

The below function retrieves the current date and time based upon the selected time zone and places the formatted date and time on to the respective div elements.

function calculateZoneTime(SelectTimeZone) {
    // if timezone not selected
    if(SelectTimeZone=='0') {
        document.getElementById("timeText").innerText="00 : 00 : 00";
        document.getElementById("dayText").innerText= "please select a timezone";
        return true; 
    }
    // get current date object
    var zDate = new Date();
    //  retrieve offset of the selected timezone in decimal format 
    var ZoneOffset = retrieveOffset(SelectTimeZone);
    // adding the time difference to current time (in milliseconds)
    var ms = zDate.getTime() + (zDate.getTimezoneOffset() * 60000) + ZoneOffset * 3600000;
    // creating a date object using the calculated zone time
    var time =  new Date(ms);
    var dayText = returnFormattedDate(time);
    var timeText =  returnFormattedTime(time);
    document.getElementById("timeText").innerText=timeText;
    document.getElementById("dayText").innerText=dayText;
}

Here the function parameter ‘SelectTimeZone’ is the value of the time-zone that is selected in the ‘selectTZ’ select. The ‘retieveOffset()’ function converts the parameter value from the “4:30” format to a “4.5” format, so that it can be used for date calculations. This offset is then added to the current time, to get the time-zone specific time.

The code for ‘retieveOffset()’ is as follows:

function retrieveOffset(TimeZoneOffset) {
      try {
         // calculating the whole and decimal part of the offset 
         var timeArray = TimeZoneOffset.split(":");
         var hrs = parseInt(timeArray[0]);
         var mins = parseInt(timeArray[1])/60; 
      } catch(err){
         alert("error"); 
      }
      // adding or deleting the decimal part and whole part
      var offset = (hrs > 0) ? (hrs + mins) : (hrs - mins);
      return offset;  
}

Now we have to update the time every second. For this we have a ‘init()’ function. The function calls the ‘calculateZoneTime()’ function and repeats itself using the setInterval function.

function init() {
     try {
             // try to clear any interval previously set
              clearInterval(myInterval);
     } catch(err){}
     // calculate time based on select value
     calculateZoneTime(document.getElementById("selectTZ").value) ;
     // repeat the init function each sec (1000ms = 1 sec)
     myInterval = setInterval("init()",1000);    
}

This sums up the article. Hope this helps. This post is open for your queries and suggestions.
You can find the code (with HTML) in its entirety here. Also you can find an advanced version of the script that loads the current time zone as default on the clock, here.

Set as Homepage, Bookmark a page

noreply@blogger.com (Unknown) — Sun, 08 Apr 2012 14:47:00 +0000

The following javascript code snippet allows a user to add your page as homepage, and to bookmark (favorite) your page.

The following javascript function code allows you to add the current address location as the Homepage of your browser.

function setHome(){
      document.body.style.behavior='url(#default#homepage)';
      document.body.setHomePage(window.location.href);
}

The following javascript function code adds the current address location to your browser’s Bookmarks list, and the document title is set as the title (name) of the Bookmark.

function setBookmark() {
      var title = document.title;
      var address =  window.location.href;
      if(window.sidebar) {
            window.sidebar.addPanel(title,address);
      } else if(window.external) {
            window.external.AddFavorite(address,title);
      } else if(window.opera && window.print) { 
            var elem = document.createElement('a');
            elem.setAttribute('href',address);
            elem.setAttribute('title',title);
            elem.setAttribute('rel','sidebar');
            elem.click();
      }
}

The problem with the above codes is that the ‘Homepage’ code works only in Internet Explorer, and the ‘Bookmark’ code is somewhat erry in Firefox (bookmarked page opens in sidebar).
But there is another option available though not javascript. The addthis site provides you with a custom button that can be added to your site/blog, that not only allows to bookmark your page but also provides you with data related to how and where the content is being shared.

Show div once a day using Javascript

noreply@blogger.com (Unknown) — Fri, 30 Mar 2012 13:56:00 +0000

The following javascript snippet allows you to show a message to the user who visits the page for the first time, and hides the message if he makes subsequent visits to that page on that day. The script involves cookies and thus need to have cookie-enabled in the user browser.

First lets have a look at the form. The form consists of a single ‘div’ element. The message to be displayed has to be kept inside this div. It can be text or image or any other display content.

<form name="scriptDen">
<div id="myDiv"> Place Your Content Here </div>
</form>
</form>

Next we have to build the code for creating a cookie. This cookie has to be created when the user visits the page for the first time. The createCookie() function takes name of the cookie, its value and its expiry period(in days) as parameters. Since we are creating a cookie for a day, the expiry period will be one.

function createCookie(name,value,days) {
    // new Date object created
    var date = new Date();
    // adding days to current time
    date.setTime(date.getTime()+(days*24*60*60*1000));
    // converting to standard format
    var expires = date.toGMTString(); 
    // adding cookie name,value and expiry time
    document.cookie = name+"="+value+"; expires="+expires+"; path=/";
}

Now we need to read the cookies stored in the browser and look whether our cookie is present there or not. The readCookie() function returns true if the cookie stored by us is present and returns false if not.

function readCookie(name) {
    var flag = 0;
    // getting the browser cookie values into an array
    var dcmntCookie = document.cookie.split(';');
    // looping over the array to find our cookie
    for(var i=0;i < dcmntCookie.length;i++) {
        var ck = dcmntCookie[i];
        // loop for removing extra spaces from the beginning of each cookie
        while (ck.charAt(0)==' ') {
            ck = ck.substring(1,ck.length);
        }
        if(ck) {
            // splitting the cookie into its name and value
            cparts = ck.split('=');
            // setting the flag if a cookie with the name specified exists
            if (cparts[0]==name)
               flag=1;
        }              
    }    
    // returning true if cookie exists else returning false 
    if(flag) { 
        return true; 
    } else {
        return false; 
    }   
}

Now as we have created both the createCookie() and readCookie() function, we have to use them for serving our purpose, that is, to hide/display a div element. This is achieved using the checkCookie() function. It checks for the cookie with a given name specified. If the cookie exists then it hides the div. Else if the cookie is not present, a new cookie is created and added to the browser.

function checkCookie(name) {
    if (readCookie(name)) {
        // hide the div element using css style attribute
        document.getElementById('myDiv').style.display = "none";
        document.getElementById('myDiv').style.visibility = "hidden";
    }
    // create a new cookie if cookie already not present
    else createCookie(name,"cookie 4 the day",1); 
}

This sums up the article. Hope this was helpful. Please do enter your valuable comments and suggestions. You can find the entire code along with html from below.

<html>
<title>show Msg once a day</title>
<head>
<style>
#myDiv {
    border: 1px solid #999;
    width: 350 px;
    height: 100px;
    background: #ccc;
    text-align: center;
}
</style>
<script language="javascript" type="text/javascript">
/** Create a html cookie and set expiry as a day. **/
function createCookie(name,value,days) {
   var date = new Date();
   date.setTime(date.getTime()+(days*24*60*60*1000));
   var expires = date.toGMTString();
   document.cookie = name+"="+value+"; expires="+expires+"; path=/";
}
/** Check if already a cookie has been created. **/
function readCookie(name) {
    var flag = 0;
    var dcmntCookie = document.cookie.split(';');
    for(var i=0;i < dcmntCookie.length;i++) {
        var ck = dcmntCookie[i];
        while (ck.charAt(0)==' ') {
            ck = ck.substring(1,ck.length);
        }
        if(ck) {
            cparts = ck.split('=');
            if (cparts[0] == name) flag=1;
        }              
    }     
    if(flag) { 
        return true; 
    } else {
        return false; 
    }  
}
/** Check if cookie exists else create a new one. **/
function checkCookie(name) {
    if (readCookie(name)) {
        document.getElementById('myDiv').style.display = "none";
        document.getElementById('myDiv').style.visibility = "hidden";
    }
    else createCookie(name,"cookie 4 the day",1); 
}
</script>
</head>
<body onLoad="checkCookie('MyCookie')">
  <form name="scriptDen">
    <center><div id="myDiv"> Place Your Content Here </div></center>
  </form>
</body>
</html>

Passing only non-Empty fields on form submit

noreply@blogger.com (Unknown) — Sun, 11 Mar 2012 14:55:00 +0000

Sometimes you have a lot of text-fields and want only those fields to be sent to the server as parameters, which are not left blank (that is which are filled). This helps in decreasing the amount of data being sent to the server.

This is one way of how the above can be done. Lets first start with the basic HTML. The form (say testform) may consists of a number of text fields and a submit button. When the button named “Submit” is clicked, the javascript function “submitFunc()” is called.

<form name="testform">
      <input type="text" name="text1" id="text1"><br />
      <input type="text" name="text2" id="text2"><br />
      <input type="text" name="text3" id="text3"><br />
      <input type="button" onclick="submitFunc();" value="Submit">
<form>

Now about the “submitFunc()” function. This function checks each text field by calling the “loopRemove ()” function.

function submitFunc() {

      loopRemove("text",3);
      document.testform.action = "http://scriptden.blogspot.com";
      document.testform.submit();
}

The “loopRemove()” function loops over the fields, who have a similar name with two parts, one a string (say, ‘text’), suffixed by an integer part in increasing order starting with one (eg. ‘txtField1’,’txtField2’,…).It checks whether the given element’s field value is empty, and if found empty it removes the corresponding element by accessing the element’s parent node.

function loopRemove(startName,count) {
      for(var i=1;i<=count;i++) {
            if(document.getElementById(startName+i).value=="") { 
                  var t = document.getElementById(startName+i);
                  t.parentNode.removeChild(t); 
            }
      } 
}

The action path of the form is specified dynamically and the form is submit using the “form.submit()” function. The form thus submitted (with empty elements removed) will pass only the filled field’s values to the page/location specified in the action path.

document.testform.action = "http://scriptden.blogspot.com";
document.testform.submit();

This sums up the article. Hope this helps.
This post is open for your queries and suggestions.

You can download the entire script here.