Java Technical Articles

Difference between call and apply in javascript

noreply@blogger.com (Unknown) — Fri, 09 Nov 2012 01:23:00 +0000

The main difference is:
apply lets you invoke the function with arguments as an array.
call requires the parameters be listed explicitly.

syntax:
theFunction.apply(valueForThis, arrayOfArgs)
theFunction.call(valueForThis, arg1, arg2, ...)

Sample code:
function theFunction(name, profession) {
alert("My name is " + name + " and I am a " + profession + ".");
}

theFunction("John", "fireman");

theFunction.apply(undefined, ["Susan", "school teacher"]);

theFunction.call(undefined, "Claude", "mathematician");

How to find top three highest salary in emp table using sql

noreply@blogger.com (Unknown) — Mon, 16 Apr 2012 11:54:00 +0000

The top three highest salary in emp table using sql is

SELECT *FROM ( SELECT *FROM emp ORDER BY Salary desc ) WHERE rownum <= 3;

Java 1.5 Feature : Varargs

noreply@blogger.com (Unknown) — Mon, 16 Apr 2012 05:50:00 +0000

In past releases, a method that took an arbitrary number of values required you to create an array and put the values into the array prior to invoking the method.

It is still true that multiple arguments must be passed in an array, but the varargs feature automates and hides the process. Furthermore, it is upward compatible with preexisting APIs.

Public static String format(String pattern,
Object... arguments);
The three periods after the final parameter's type indicate that the final argument may be passed as an array or as a sequence of arguments. Varargs can be used only in the final argument position.

Much more simpler example here..

public class VarArgs {
public static void main(String[] args) {
String[] newArgs = {"a", "b", "c"};
vaMethod(newArgs);
}

public void vaMethod(String[] args) {
System.out.println("You gave me " + args.length + " args! Yay.");
}
}
You can declare it more easily, and not have to construct the array ahead of time:

public class VarArgs {
public static void main(String[] args) {
vaMethod("a", "b", "c");
}

public void vaMethod(String... args) {
System.out.println("You gave me " + args.length + " args! Yay.");
}
}

Java 1.5 Language Features

noreply@blogger.com (Unknown) — Mon, 16 Apr 2012 05:08:00 +0000

Generics

This long-awaited enhancement to the type system allows a type or method to operate on objects of various types while providing compile-time type safety. It adds compile-time type safety to the Collections Framework and eliminates the drudgery of casting. Refer to JSR 14.

Enhanced for Loop

This new language construct eliminates the drudgery and error-proneness of iterators and index variables when iterating over collections and arrays. Refer to JSR 201 .

Autoboxing/Unboxing

This facility eliminates the drudgery of manual conversion between primitive types (such as int) and wrapper types (such as Integer). Refer to JSR 201 .

Typesafe Enums

This flexible object-oriented enumerated type facility allows you to create enumerated types with arbitrary methods and fields. It provides all the benefits of the Typesafe Enum pattern ("Effective Java," Item 21) without the verbosity and the error-proneness. Refer to JSR 201.

Varargs

This facility eliminates the need for manually boxing up argument lists into an array when invoking methods that accept variable-length argument lists. Refer to JSR 201.

Static Import

This facility lets you avoid qualifying static members with class names without the shortcomings of the "Constant Interface antipattern." Refer to JSR 201.

Metadata (Annotations)

This language feature lets you avoid writing boilerplate code under many circumstances by enabling tools to generate it from annotations in the source code. This leads to a "declarative" programming style where the programmer says what should be done and tools emit the code to do it. Also it eliminates the need for maintaining "side files" that must be kept up to date with changes in source files. Instead the information can be maintained in the source file. Refer to JSR 175.

Client side web site performance

noreply@blogger.com (Unknown) — Fri, 13 Apr 2012 21:23:00 +0000

Smaller images,
Omitting quotes in HTML attributes (yes, people went that far!),
Using fixed width tables in IE 5
Balancing server response buffering vs creating the whole page first and then sending it all in one response, etc.

Putting images on different domains (though now other resources are worth considering too)
Compressing the server output using gzip (a bit hit and miss on earlier versions of IIS though)
Cache control using the Expires header
Use CSS (though in those days I used it mostly for font definitions and browser sniffing was needed to load different CSS files!)

Use GZip on all text-based output (which should be optimized anyway via web standards!)

Try to reduce the number of HTTP requests (e.g. combine CSS and JavaScript files during development or during the build process, use CSS sprites, if possible etc)
Help browsers ensure they can cache as many of your files as possible

Let browsers download your page resources in parallel even though HTTP 1.1 limits you to 2 concurrent requests from a domain (through sub-domains, minimizing or eliminating loading CSS and JavaScript in a way that blocks the browser, etc)

Disperse your content through things like content distribution and extra sub-domains (though be aware of extra DNS-lookups that might result)

Diffrence between High Level Desgin and Low Level Design

noreply@blogger.com (Unknown) — Fri, 13 Apr 2012 21:14:00 +0000

High level design means abstract view of the system.
Details are not shown.
High level design does contain class diagram at conceptual level no operations are defined.

Low level design uses class diagram at implementation level with most of the required detail.

The main difference is the amount of detail that you show.

What are Entity Relationship Diagrams

noreply@blogger.com (Unknown) — Fri, 13 Apr 2012 21:05:00 +0000

Entity Relationship Diagrams (ERDs) illustrate the logical structure of databases.

Entity Relationship Diagram Notations

Entity
An entity is an object or concept about which you want to store information.

Weak Entity
A weak entity is an entity that must defined by a foreign key relationship with another entity as it cannot be uniquely identified by its own attributes alone.

Key attribute
A key attribute is the unique, distinguishing characteristic of the entity. For example, an employee's social security number might be the employee's key attribute.

Multivalued attribute
A multivalued attribute can have more than one value. For example, an employee entity can have multiple skill values.

Derived attribute
A derived attribute is based on another attribute. For example, an employee's monthly salary is based on the employee's annual salary.

Relationships
Relationships illustrate how two entities share information in the database structure.

Cardinality
Cardinality specifies how many instances of an entity relate to one instance of another entity.

Ordinality is also closely linked to cardinality. While cardinality specifies the occurences of a relationship, ordinality describes the relationship as either mandatory or optional. In other words, cardinality specifies the maximum number of relationships and ordinality specifies the absolute minimum number of relationships.

Recursive relationship
In some cases, entities can be self-linked. For example, employees can supervise other employees.

What is Scalability Testing

noreply@blogger.com (Unknown) — Fri, 13 Apr 2012 11:41:00 +0000

Definition

A test designed to prove that both the functionality and the performance of a system will scale up to meet specified requirements.

Comment

Generally, load and stress tests should continue to the point where the system fails and its scalability is proven.

Measurements should be taken during the load and stress testing activities to ensure that the most information possible is available to make a decision on the scalability of the system. The more information that is available, the less risk there is of an unexpected event happening in the future that could turn out to be costly

Difference between Layer and Tier

noreply@blogger.com (Unknown) — Fri, 13 Apr 2012 11:35:00 +0000

Layer and Tier are really two very different things:

Layers are a means of logical separation, and are an architectural pattern to separate concerns. Typical layers are the storage / data layer, the data access layer, a business logic layer, and a presentation layer. When deploying an application, these layers might exist either on one machine, or on multiple machines.

When architecting the layers of an application, one must consider various factors:

What is this layer responsible for?
Will this layer translate to a tier at any point?
Are other applications expected to communicate with this layer?
What are the dependencies for this layer?
Tiers are the physical separation of an application. Typically, a regular web application will have a data tier which maps to the database, a business and presentation tier (potentially together) that map to the underlying business logic and web pages respectively, and a front-end tier that maps to the browser. There are scenarios wherein the business and presentation layers are split, so the business layer components reside on a separate node, and the web application itself resides on another node. Tiers necessarily imply layers, but not vice versa.

While layer decisions are driven primarily by separation of concerns, a tiering decision is driven differently. In fact decisions around tiers need to be well thought-out, especially since physical tiers may result in a performance degrade, due to network latency, and marshalling / unmarshalling overheads. For the most part, having the data sit in a separate tier on a database server is fairly well accepted, but the decision of whether or not to separate web pages into a tier separate from business logic components is a question that is often debated. A few points that support this separation are:

If the web server is expected to serve up a large amount of static content, it is more feasible to scale out the web servers independent of the business logic processing, and hence keep them on separate tiers.
If the processing of the businss logic requires a significant amount of processing, and this acts as a bottleneck for the rest of the web page processing, then it is more feasible to scale out the application servers independent of the web servers, and hence keep them on separate tiers.
If the functionality encapsulated by the business logic components is expected to be consumed by clients other than the presentation layer, then it is better to have these hosted on a separate tier, and front-end it with a web service / WCF facade.
If there is a need to have more security for the business functionality, then it is better to host the businss logic components in a separate tier, and separate it from the web server using a firewall.
If, on the other hand, the intent is only to scale out, without a deep need to scale out business and presentation tiers independently, then keeping them in one tier is better: Consider the case when I have five machines, and I use all five to host both my presentation and business tiers. In comparison, if I use two of these for my presentation tier, and three for my business tier, then I still have the same compute power, but now have to contend with the additional overhead of marshal/unmarshal, and latency. I’m hence better off with the single tier in such a case.

All said though, while a physical separation improves scale-out capability and security, it does impose overheads due to the network. The design for tiers needs to take into account the communication between tiers – too chatty, and performance degrades rapidly. The choice of protocol is equally important – the protocol of communication should be the most lightweight, and be as native as possible – so if both the web pages and the business logic components are built on the .Net stack, then a NetTcp binding is more suitable than a Http-based binding.

Decorator Design Pattern in Java

noreply@blogger.com (Unknown) — Fri, 13 Apr 2012 02:10:00 +0000

In this pattern(Decorator Design pattern), a decorator object is wrapped around the original object. This is typically achieved having the original object as a member of the decorator, the decorator object also provides a way to implement the new functionality. The decorator must conform to the interface of the original object (the object being decorated).

The definition of Decorator Design pattern is :

Attach additional responsibilities to an object dynamically. Decorators
provide a flexible alternative to subclassing for extending functionality.

Where to implement-

For example I have an Interface and its implementation class, and if i want to provide an extra functionality with out effecting the original interface and implementation class.

Also we should able to withdraw the extra functionality or responsibility that we are providing dynamically.

For Example: The java.util.Collections.unmodifiableCollection(Collection) removies the ability to change a given collection by wrapping it with a decorator that throws an UnSupportedException when you try to modify the Collection.

example..

Have an interface IComponent, with one method getDetails();
Also I have an implementation class Component for IComponent

If I have to provide extra functionality with out effecting the above 2 I can do the following..

Extend the IComponent With IDecorator interface which has the extra method declared doSomething()

that is

public interface IDecorator extends IComponent {
public void doSomething();
}

and provide the implementation to the IDecorator which has two methods getDetails, doSomething.

public class Decorator implements IDecorator {

IComponent component;

public Decorator(IComponent component) {
super();
this.component = component;
}

public void doSomething() {
System.out.println("Decorator does some stuff too");

}

public void getDetails() {
component.getDetails();
doSomething();

}

}

Here, with the same getDetails() of IComponent, we are achieving the extra functionality.

Here is the client class

public class Client {
public static void main(String[] args) {
IComponent comp = new Component();
IDecorator decorator = new Decorator(comp);
decorator.doStuff();
}

}

Difference between Comparable and Comparator?

noreply@blogger.com (Unknown) — Fri, 13 Apr 2012 01:58:00 +0000

Comparable-

A comparable object is capable of comparing itself with another object. The class itself must implements the java.lang.Comparable interface in order to be able to compare its instances.

Comparator-

A comparator object is capable of comparing two different objects. The class is not comparing its instances, but some other class’s instances. This comparator class must implement the java.util.Comparator interface.

Usage-

There are two interfaces in Java to support these concepts, and each of these has one method to be implemented by user.
Those are;

java.lang.Comparable: int compareTo(Object o1)
This method compares this object with o1 object. Returned int value has the following meanings.
positive – this object is greater than o1
zero – this object equals to o1
negative – this object is less than o1

java.util.Comparator: int compare(Object o1, Objecto2)
This method compares o1 and o2 objects. Returned int value has the following meanings.
positive – o1 is greater than o2
zero – o1 equals to o2
negative – o1 is less than o2

java.util.Collections.sort(List) and java.util.Arrays.sort(Object[]) methods can be used to sort using natural ordering of objects.
java.util.Collections.sort(List, Comparator) and java.util.Arrays.sort(Object[], Comparator) methods can be used if a Comparator is available for comparison.

HTML5 <article> Tag

noreply@blogger.com (Unknown) — Thu, 23 Feb 2012 14:42:00 +0000

The <article> tag specifies independent, self-contained content.

An article should make sense on its own and it should be possible to distribute it independently from the rest of the site.

Examples of possible articles:

forum post
newspaper article
blog entry
user comment

Example:

<article>
This is a test article.
</article>

All the latest browsers support this property.

CSS3 Text Overflow(text-overflow) Property with example

noreply@blogger.com (Unknown) — Sat, 03 Dec 2011 03:32:00 +0000

The text-overflow property specifies what should happen when text overflows the containing element.

syntax of this property is

text-overflow: clip|ellipsis|string;

All the latest browsers support this property.

The possible values are

clip : Clips the text
ellipsis : Render an ellipsis ("...") to represent clipped text
string : Render the given string to represent clipped text

JavaScript syntax of this property is object.style.textOverflow="ellipses"

Example for text-overflow property..

.mydiv{
text-overflow:ellipsis;
width:12em;
border:1px solid #000000;
overflow:hidden;
white-space:nowrap;
}

If you apply this to the following div

<div class="test" class="mydiv">Long text that will not fit in the box</div>

It looks like as follows..

Long text that will no...

CSS3 Other text effects Properties..

CSS3 Word Wrap(word-wrap) property with example

noreply@blogger.com (Unknown) — Sat, 03 Dec 2011 03:10:00 +0000

The word-wrap property allows to force the text to wrap.
That is, even it also split it in the middle of a word for wrapping.

syntax of this property is

word-wrap: normal|break-word;

All the latest browsers support this property.

The possible values are

normal : Break words only at allowed break points
break-word : Allows unbreakable words to be broken

JavaScript syntax of this property is object.style.wordWrap="break-word"

Example for text-shadow property..

p.test {word-wrap:break-word;}

CSS3 Other text effects Properties..

CSS3 Text Shadow(text-shadow) Property with example

noreply@blogger.com (Unknown) — Sat, 03 Dec 2011 02:46:00 +0000

The text-shadow property applies shadow to the text.

We need to supply the following data when using this property..

horizontal shadow
vertical shadow
blur distance, this is an optional one
color of the shadow, this is an optional one

JavaScript syntax for this property is object.style.textShadow="4px 5px 3px #33ff01"

Firefox, Chrome, Opera and Safari supports this property.
But Internet Explorer does not yet support the text-shadow property.

Example for text-shadow property..

h2
{
text-shadow: 15px 5px 5px #FF6600;
}

CSS3 Other text effects Properties..

What are CSS3 Text Effects Properties?

noreply@blogger.com (Unknown) — Sat, 03 Dec 2011 02:17:00 +0000

The CSS3 text effects that work on the most of the latest browsers are

Internet Explorer does not yet support the text-shadow property.

Firefox, Chrome, Safari, and Opera support the text-shadow property.

All the above browsers support the word-wrap property.

All the above browsers support the text-overflow property.

Some of the other CSS3 text effects properties, which don't have the browser support are..

hanging-punctuation
punctuation-trim
text-align-last
text-emphasis
text-justify
text-outline
text-wrap
word-break

CSS3 Mian Page

CSS3 background-clip Property with example

noreply@blogger.com (Unknown) — Fri, 02 Dec 2011 18:38:00 +0000

This is used to specify the painting area of the background, this is more similar to the "background-origin", but the "background-origin" should be used when we use image as the background and the "background-origin" positions the image at the specified location..

Where as the "background-clip" should be used when we use color as the background, and it specifies the painting area.

The possible values for this property are..

border-box : The background is clipped to the border box
padding-box: The background is clipped to the padding box
content-box: The background is clipped to the content box

The background-clip property is supported IE9+, Firefox 4+, Opera, and Chrome.

Safari supports an alternative, the -webkit-background-clip property.

Example for background-clip property..

/*for border-box*/
#div1
{
padding:25px;
border:5px dotted #000000;
background-color:green;
background-clip:border-box;
}

/*for padding-box*/
#div1
{
padding:25px;
border:5px dotted #000000;
background-color:green;
background-clip:padding-box;
}

/*for content-box*/
#div1
{
padding:25px;
border:5px dotted #000000;
background-color:green;
background-clip:content-box;
}

CSS3 Other Background Properties..

CSS3 enhancements to the background-image property with example

noreply@blogger.com (Unknown) — Fri, 02 Dec 2011 18:23:00 +0000

There are also some changes to the existing "background-image" property, now it allows us to set multiple background images.

As this is allowing multiple images as the background-image, if the upper one is transparent, we can also see the second image which is there behind.

Internet Explorer 9, Firefox 4, Chrome, Safari 5 and Opera support these new background properties.

Example for background-image property..

div
{
background-image:url(upper_img.gif),url(back_img.gif);
}

CSS3 Other Background Properties..

CSS3 background-origin property with example

noreply@blogger.com (Unknown) — Fri, 02 Dec 2011 18:06:00 +0000

The "background-origin" property specifies the positioning area of the background images.

Internet Explorer 9, Firefox 4, Chrome, Safari 5 and Opera support these new background properties.

Firefox 3.6 and earlier does not support the background-origin property.

Safari 4 requires the prefix -webkit- to support the new background properties.

The background image can be placed within the content-box, padding-box, or border-box area.
Example for background-origin property..

/*Position the background image within the padding-box..*/

.test
{
background:url(img1.gif);
background-repeat:no-repeat;
background-size:100% 100%;
-webkit-background-origin: padding-box; /* Safari */
background-origin: padding-box;
}

/*Position the background image within the border-box..*/

.test
{
background:url(img1.gif);
background-repeat:no-repeat;
background-size:100% 100%;
-webkit-background-origin:border-box; /* Safari */
background-origin:border-box;
}

/*Position the background image within the content-box..*/

.test
{
background:url(img1.gif);
background-repeat:no-repeat;
background-size:100% 100%;
-webkit-background-origin:content-box; /* Safari */
background-origin:content-box;
}

CSS3 Other Background Properties..

CSS3 background-size property with example

noreply@blogger.com (Unknown) — Fri, 02 Dec 2011 17:52:00 +0000

The "background-size" property specifies the size of the background image.

Until CSS3, the background image size was determined by the actual size of the image.

But CSS3 provides a way to specify the size of the background image, which allows us to
re-use background images in different contexts.

We can specify the size in pixels or in percentages. If you specify the size as a percentage, the size is relative to the width and height of the parent element.

Internet Explorer 9, Firefox 4, Chrome, Safari 5 and Opera support these new background properties.

Firefox 3.6 and earlier requires the prefix -moz- to support the background-size property.

Safari 4 requires the prefix -webkit- to support the new background properties.

Example for background-size property..

/*background image specified in pixels, this will resize the original image to the specified size..*/

.test
{
background:url(img1.gif);
background-size:80px 60px;
background-repeat:no-repeat;
/* Firefox 3.6 */
-moz-background-size:80px 60px;
}

/*background image specified in percentage, this will resize the original image relative to the width and height of the parent element*/

div
{
background:url(img1.gif);
background-size:100% 100%;
background-repeat:no-repeat;
/* Firefox 3.6 */
-moz-background-size:100% 100%;
}

CSS3 Other Background Properties..

How Does CSS3 Backgrounds work?

noreply@blogger.com (Unknown) — Fri, 02 Dec 2011 17:09:00 +0000

The new CSS3 background properties are ..

There are also some changes to the existing background property "background-image", that is, now it allows us to set multiple background images.

Internet Explorer 9, Firefox 4, Chrome, Safari 5 and Opera support these new background properties.

Firefox 3.6 and earlier does not support the background-origin property, and requires the prefix -moz- to support the background-size property.

Safari 4 requires the prefix -webkit- to support the new background properties.

CSS3 Mian Page

How Does CSS3 Borders work?

noreply@blogger.com (Unknown) — Fri, 02 Dec 2011 15:50:00 +0000

We can do the following things with CSS3 Border style properties

creating rounded borders
adding shadow to boxes
using an image as a border

The CSS3 Border style properties are..

border-radius
box-shadow
border-image

The latest versions of IE, Firefox, Chrome, Safari and Opera supports the following two CSS3 Border style properties

border-radius
box-shadow

IE does not support the "border-image" property. But all the other browsers support the same with some prefix.

Firefox requires the prefix -moz- for border-image.
Chrome and Safari requires the prefix -webkit- for border-image.
Opera requires the prefix -o- for border-image.

Example for box-shadow

.test{
width:200px;
height:100px;
background-color:blue;
box-shadow: 10px 10px 5px #676767;
}

After applying it to a div, it look like as follows

Example for border-radius

.test
{
border:2px solid;
border-radius:25px;
background-color:red;
/* Firefox 3.6 and earlier */
-moz-border-radius:25px;
}

After applying it to a div, it look like as follows

Example for border-image
This has two examples one with option "round" other one with option "stretch", you can copy this play by applying it to some div, to see the immediate output.

#round
{
-moz-border-image:url(border.png) 30 30 round; /* Firefox */
-webkit-border-image:url(border.png) 30 30 round; /* Safari and Chrome */
-o-border-image:url(border.png) 30 30 round; /* Opera */
border-image:url(border.png) 30 30 round;
}

#stretch
{
-moz-border-image:url(border.png) 30 30 stretch; /* Firefox */
-webkit-border-image:url(border.png) 30 30 stretch; /* Safari and Chrome */
-o-border-image:url(border.png) 30 30 stretch; /* Opera */
border-image:url(border.png) 30 30 stretch;
}

CSS3 Mian Page

Understanding CSS3 with examples -Introduction to CSS3

noreply@blogger.com (Unknown) — Fri, 02 Dec 2011 15:38:00 +0000

CSS3 include so many new features and functions that it can be hard to achieve before CSS3. The inclusion of native support for things like rounded corners, 2D/3D Transformations and multi-column layouts are just the samples.

Most important CSS3 modules are:

Selectors
Box Model
Backgrounds
Borders
Text Effects
2D/3D Transformations
Animations
Multiple Column Layout
User Interface

The CSS3 specification is still under development by W3C.
However, many of the new CSS3 properties have been implemented in modern browsers.

CSS3 is completely backwards compatible, so you will not have to change existing designs. Browsers will always support CSS2.

HTML 5 Media Elements With Example

noreply@blogger.com (Unknown) — Thu, 01 Dec 2011 11:26:00 +0000

The new HTML5 media elements are ..

<audio> : For audio content, sounds, music or other audio streams
<video> : For video content, such as a movie clip or other video streams
<source> : For media resources for media elements, defined inside video or audio elements
<embed> : For embedded content, such as a plug-in
<track> : For text tracks used in media players

Audio example :

Video example :

Difference between CSS Class and ID selector

noreply@blogger.com (Unknown) — Wed, 30 Nov 2011 01:22:00 +0000

The first difference is
An ID selector can be called only once in a document.
A class selector can be called multiple times in a document.

The second difference is
ID can be called by Javascript's getElementByID function.

Note1: There is no hard rule on when to use ID and when to use Class. Use class as much as possible for maximum flexibility, with the only exception being when you want to use Javascript's getElementByID function, in which case you need use ID.

Note2: Class and ID names are both case sensitive. For example, .divclass and .DivClass are two different classes.