Java Interview Answers

Sort Algorithms

2019-06-30T22:18:00.004-07:00

Quick Sort

Insertion Sort

Merge Sort

Search Algorithms

2019-06-30T22:10:00.000-07:00

Linear Search

Binary Search

Breadth First Search

Depth First Search

JAVA

2010-05-31T11:41:00.001-07:00

Java is a programming language originally developed by James Gosling at Sun Microsystems (which is now a subsidiary of Oracle Corporation) and released in 1995 as a core component of Sun Microsystems' Java platform. The language derives much of its syntax from C and C++ but has a simpler object model and fewer low-level facilities.

Java applications are typically compiled to bytecode (class file) that can run on any Java Virtual Machine (JVM) regardless of computer architecture. Java is a general-purpose, concurrent, class-based, and object-oriented, and is specifically designed to have as few implementation dependencies as possible. It is intended to let application developers "write once, run anywhere". Java is considered by many as one of the most influential programming languages of the 20th century, and is widely used from application software to web applications.

James Gosling initiated the Java language project in June 1991 for use in one of his many set-top box projects. the language, initially called Oak after an oak tree that stood outside Gosling's office, also went by the name Green and ended up later renamed as Java, from a list of random words. Gosling aimed to implement a virtual machine and a language that had a familiar C/C++ style of notation.

Sun Microsystems released the first public implementation as Java 1.0 in 1995. It promised "Write Once, Run Anywhere" (WORA), providing no-cost run-times on popular platforms. Fairly secure and featuring configurable security, it allowed network- and file-access restrictions. Major web browsers soon incorporated the ability to run Java applets within web pages, and Java quickly became popular. With the advent of Java 2 (released initially as J2SE 1.2 in December 1998), new versions had multiple configurations built for different types of platforms. For example, J2EE targeted enterprise applications and the greatly stripped-down version J2ME for mobile applications (Mobile Java). J2SE designated the Standard Edition. In 2006, for marketing purposes, Sun renamed new J2 versions as Java EE, Java ME, and Java SE, respectively.

In 1997, Sun Microsystems approached the ISO/IEC JTC1 standards body and later the Ecma International to formalize Java, but it soon withdrew from the process.Java remains a de facto standard, controlled through the Java Community Process. At one time, Sun made most of its Java implementations available without charge, despite their proprietary software status. Sun generated revenue from Java through the selling of licenses for specialized products such as the Java Enterprise System. Sun distinguishes between its Software Development Kit (SDK) and Runtime Environment (JRE) (a subset of the SDK); the primary distinction involves the JRE's lack of the compiler, utility programs, and header files.

On November 13, 2006, Sun released much of Java as open source software under the terms of the GNU General Public License (GPL). On May 8, 2007, Sun finished the process, making all of Java's core code available under free software/open-source distribution terms, aside from a small portion of code to which Sun did not hold the copyright.

There were five primary goals in the creation of the Java language:

It should be "simple, object oriented, and familiar".

It should be "robust and secure".

It should be "architecture neutral and portable".

It should execute with "high performance".

It should be "interpreted, threaded, and dynamic".

Sun has defined and supports four editions of Java targeting different application environments and segmented many of its APIs so that they belong to one of the platforms. The platforms are:

Java Card for smartcards.

Java Platform, Micro Edition (Java ME) — targeting environments with limited resources.

Java Platform, Standard Edition (Java SE) — targeting workstation environments.

Java Platform, Enterprise Edition (Java EE) — targeting large distributed enterprise or Internet environments.

Flex Cairngorm

2010-05-31T11:38:00.000-07:00

Cairngorm is one of the primary open source frameworks for application architecture in Adobe Flex. It was developed by iteration::two, who was acquired byMacromedia in 2005. It is part of the Adobe Engagement Platform.

Cairngorm is based on the MVC model. It is specifically designed to facilitate complex state and data synchronization between the client and the server, while keeping the programming of the View layer detached from the data implementation.

The role of the View layer in a Cairngorm application is to throw events and bind to data stored in the Model. Components on the View can bind to Value Objects or other properties in the Model (data) layer.

In a Cairngorm Model, related data are stored in Value Objects (VOs), while simple variables can be stored as direct properties of the ModelLocator class. A static reference to the ModelLocator singleton instance is used by the View layers to locate the required data.

The Controller is the most sophisticated part of the Cairngorm architecture. The Controller layer is implemented as a singleton FrontController. The FrontController instance, which receives every View-generated event, dispatches the events to the assigned Command class based on the event's declared type.

The Command class then processes the event by running the Command class' execute() method, which is an ICommand interface method. The event object may include additional data if required by the developer. The execute() method can update the central Model, as well as invoke a Service class which typically involves communication with a remote server. The IResponder interface, which is also implemented by the Command class, includes onResult and onFault methods to handle responses returned from the invoked remote service.

Organizing a Cairngorm Project

One of the tasks involved with any project is organization. When working with other developers, this becomes extremely important. Normally a Cairngorm project is organized in the following manner:

There is a Main.mxml file that is the main application file for the Cairngorm application.
The project files are contained in a folder that uses "reverse-dns" format. For example, if the project was named CairngormSample, I would use the following folders net/CairngormSample .
Within the CairngormSample directory, there will be the following folders:

events/ - This directory holds all of the custom events for the application
control/ - This directory houses the FrontController for the application
commands/ - This directory contains the Commands that are called by the FrontController
model/ - The ModelLocator is contained in this folder (and other classes related to the model)
view/ - The components of the view are contained in this directory

By following this standard, you can know where to find any class that you may need in your Cairngorm application. Figure 1 illustrates this project structure. It also is a good development process to have a standard organizational structure for your projects - even if you are not using Cairngorm.

Figure 1 - Cairngorm Project Structure

The Service to Worker Pattern

The Service to Worker pattern is the hardest for most people to grasp. It encompasses most of the logic for a Cairngorm application. To understand this pattern, you will need to understand some of the classes that are included with Cairngorm and their respective purposes.

CairngormEvent [Reference] - CairngormEvent is central in this pattern. It extends from Event. For your event to be handled properly in Cairngorm, it will need to be of type CairngormEvent.
CairngormEventDispatcher [Reference] - CairngormEventDispatcher actually dispatches the CairngormEvents. It is a singleton (just like the ModelLocator). In previous Cairngorm versions, you would call this class regularly, but now CairngormEvents can dispatch themselves (via the method dispatch). This method is simply a wrapper for the CairngormEventDispatcher, so even if you don't actually import and call the class, it is still central to the Service to Worker pattern in Cairngorm.
FrontController [Reference] - The FrontController maps a CairngormEvent to a Command.
ICommand [Reference] - For a Command to function properly in Cairngorm, it needs to implement the ICommand interface. This interface requires that a command have a method named execute and that it accept the CairngormEvent that is mapped to it as an argument.

The Cairngorm Event Flow

The way that these classes interact is the Cairngorm Event Flow. Figure 2 illustrates this entire process. While this process seems lengthy, it follows a logical order.

Figure 2 - Cairngorm Basic Event Flow

For example, assume that Figure 2 shows what happens when a user clicks a login button. It would follow the following steps:

1. The user is viewing a component that has a login button.

2. When the button is clicked, that component would dispatch an event named LoginEvent that extends CairngormEvent.

3. The FrontController would receive the LoginEvent and execute the command that is mapped to that event. For this example, it will be named LoginCommand and will implement ICommand.

4. The Command is executed and received the LoginEvent as an argument. The LoginCommand will change the workflowState value in the ModelLocator.

5. The ModelLocator will have a predefined constant for the "Logged in View". The command will change workflowState to this value.

6. Since the view is bound to workflowState, it will automatically update itself to the new view.

Once these items are understood, the next most important thing to understand about Cairngorm is: Everything Should Be Mapped to an Event. This is a drastic over-simplification, but it holds true in most situations. When a user clicks a login button - it should dispatch a CairngormEvent. When the user selects an option to change the view - it should dispatch a CairngormEvent. When a user submits a form to be stored on in a database - the form should dispatch a CairngormEvent. The dispatching of a CairngormEvent sets everything in motion.

Organizing Your Cairngorm Project (With Server Interaction)

In the last section you saw the standard Cairngorm structure for a project. To complete this structure, you will need to add an additional two folders:

/business - This folder typically contains two types of files: the ServiceLocator (named Services.mxml) and Business Delegates.
/vo - This folder contains the value objects that are passed to and from the server.

Understanding the Process

Before you begin crafting the server interaction for your project, you need to understand the full Service to Worker pattern. Figure 3 illustrates the entire process.

Figure 3 - Cairngorm Event Flow with Server Interaction

Phase I - Execution Phase

1. The user is viewing a component that has a login button. When the button is clicked, that component would dispatch an event named LoginEvent that extends CairngormEvent.

2. The FrontController would receive the LoginEvent and execute the command that is mapped to that event. For this example, it will be named LoginCommand and will implement ICommand.

3. The Command is executed and received the LoginEvent as an argument. The LoginCommand creates an instance of the Delegate while passing a reference to the Responder. The Command then calls the specified method on the Delegate.

4. The Delegate gets the service from the ServiceLocator and calls the method on the specific service.

5. The service defined in the ServiceLocator receives the information that is passed to it from the call in the Delegate.

Phase II - Application Tier Processing

Phase III - Response Phase

1. The service that is defined in the ServiceLocator returns the result of the server-side processing.

2. The Delegate receives the result and passes it to the specified responder.

3. The Responder receives the result indicating a successful login.

4. The ModelLocator will have a predefined constant for the "Logged in View". The Responder will change workflowState to this value.

5. Since the view is bound to workflowState, it will automatically update itself to the new view.

Note: Traditionally the Command and Responder were the same class in a Cairngorm application. If you are working with other developers, the applications will probably be coded in this manner. However, most developers (including Adobe Consulting) are now separating these classes into two different classes. For a less complex project, it might not make sense to separate these items, but in a large application it could prove advantageous in organization and practice to have two different classes.

Coming soon: Cairngorm Videos below made by David Tucker, an expert on the subject!

UML

2010-05-30T20:42:00.001-07:00

Unified Modeling Language (UML) is a standardized general-purpose modeling languagein the field of software engineering. The standard is managed, and was created by, theObject Management Group.
UML includes a set of graphic notation techniques to create visual models of software-intensive systems.
The Unified Modeling Language (UML) is used to specify, visualize, modify, construct and document the artifacts of an object-oriented software intensive system under development. UML offers a standard way to visualize a system's architectural blueprints, including elements such as:

actors
business processes
(logical) components
activities
programming language statements
database schemas, and
reusable software components.

UML diagrams represent two different views of a system model:

Static (or structural) view: Emphasizes the static structure of the system using objects, attributes, operations and relationships. The structural view includes class diagrams and composite structure diagrams.
Dynamic (or behavioral) view: Emphasizes the dynamic behaviour of the system by showing collaborations among objects and changes to the internal states of objects. This view includes sequence diagrams, activity diagrams and state machine diagrams.

UML models can be exchanged among UML tools by using the XMI interchange format.

Diagrams overview

UML 2.2 has 14 types of diagrams divided into two categories.^[10] Seven diagram types represent structural information, and the other seven represent general types ofbehavior, including four that represent different aspects of interactions. These diagrams can be categorized hierarchically as shown in the following class diagram:

UML does not restrict UML element types to a certain diagram type. In general, every UML element may appear on almost all types of diagrams; this flexibility has been partially restricted in UML 2.0. UML profiles may define additional diagram types or extend existing diagrams with additional notations.

In keeping with the tradition of engineering drawings, a comment or note explaining usage, constraint, or intent is allowed in a UML diagram.

Structure diagrams

Structure diagrams emphasize what things must be in the system being modeled:

Class diagram: the class diagrams describes the structure of a system by showing the system's classes, their attributes, and the relationships among the classes.
Component diagram: depicts how a software system is split up into components and shows the dependencies among these components.
Composite structure diagram: describes the internal structure of a class and the collaborations that this structure makes possible.
Deployment diagram: serves to model the hardware used in system implementations, and the execution environments and artifacts deployed on the hardware.
Object diagram: shows a complete or partial view of the structure of a modeled system at a specific time.
Package diagram: depicts how a system is split up into logical groupings by showing the dependencies among these groupings.
Profile diagram: operates at the metamodel level to show stereotypes as classes with the <> stereotype, and profiles as packages with the <> stereotype. The extension relation (solid line with closed, filled arrowhead) indicates what metamodel element a given stereotype is extending.

Class diagram	Component diagram	Composite structure diagrams	Deployment diagram
Object diagram	Package diagram

Since structure diagrams represent the structure they are used extensively in documenting the architecture of software systems.

Behavior diagrams

Behavior diagrams emphasize what must happen in the system being modeled:

Activity diagram: represents the business and operational step-by-step workflows of components in a system. An activity diagram shows the overall flow of control.
State machine diagram: standardized notation to describe many systems, from computer programs to business processes.
Use case diagram: shows the functionality provided by a system in terms of actors, their goals represented as use cases, and any dependencies among those use cases.

UML Activity Diagram

State Machine diagram

Use case diagram

Since behavior diagrams illustrate the behaviour of a system, they are used extensively to describe the functionality of software systems.

Interaction diagrams

Interaction diagrams, a subset of behaviour diagrams, emphasize the flow of control and data among the things in the system being modeled:

Communication diagram: shows the interactions between objects or parts in terms of sequenced messages. They represent a combination of information taken from Class, Sequence, and Use Case Diagrams describing both the static structure and dynamic behavior of a system.
Interaction overview diagram: are a type of activity diagram in which the nodes represent interaction diagrams.
Sequence diagram: shows how objects communicate with each other in terms of a sequence of messages. Also indicates the lifespans of objects relative to those messages.
Timing diagrams: are a specific type of interaction diagram, where the focus is on timing constraints.

Communication diagram

Interaction overview diagram

Sequence diagram

Page Content Source: Wikipedia
More UML Questions

JDK Release Dates

2010-05-26T12:32:00.000-07:00

Here are the dates the various Java versions were released. This table does not show the minor _01 _02 type releases. Major releases 1.3, 1.4.0, 1.5.0 and 1.6.0 are named after birds or mammals, while minor releases are named after insects, given that they are bug-fix releases.

Java Versions Release Dates
version	Release Date	Code Name
JDK 1.0	1996-01-23	Oak? Java first released to the public
Java version 1.1	1997-02-18	Sparkler
JDK 1.1.4	1997-09-12	Sparkler
JDK 1.1.5	1997-12-03	Pumpkin
JDK 1.1.6	1998-04-24	Abigail
JDK 1.1.7	1998-09-28	Brutus
JDK 1.1.8	1999-04-08	Chelsea
J2SE 1.2	1998-12-04	Playground
J2SE 1.2.1	1999-03-30	(none)
J2SE 1.2.2	1999-07-08	Cricket
J2SE 1.3	2000-05-08	Kestrel
J2SE 1.3.1	2001-05-17	Ladybird
J2SE 1.4.0	2002-02-13	Merlin
J2SE 1.4.1	2002-09-16	Hopper (Grasshopper)
J2SE 1.4.2	2003-06-26	Mantis
J2SE 1.5.0	2004-09-29	Tiger
J2SE 1.5.1	N/A	Dragonfly, Dragon
J2SE 6.0 (1.6.0)	2006-12-12	Mustang
Future Releases
J2SE 7.0 (1.7.0)		Dolphin

Mac OS programmers are still on Java version 1.5. To get Java version 1.6 they need Mac OS X.

WebServer/ApplicationServer

2010-05-17T17:15:00.000-07:00

A Web server exclusively handles HTTP requests, whereas an application server serves business logic to application programs through any number of protocols. A Web server serves pages for viewing in a Web browser, while an application server provides methods that client applications can call.

Let's examine each in more detail.

The Web server
A Web server handles the HTTP protocol. When the Web server receives an HTTP request, it responds with an HTTP response, such as sending back an HTML page. To process a request, a Web server may respond with a static HTML page or image, send a redirect, or delegate the dynamic response generation to some other program such as CGI scripts, JSPs (JavaServer Pages), servlets, ASPs (Active Server Pages), server-side JavaScripts, or some other server-side technology. Whatever their purpose, such server-side programs generate a response, most often in HTML, for viewing in a Web browser.

Understand that a Web server's delegation model is fairly simple. When a request comes into the Web server, the Web server simply passes the request to the program best able to handle it. The Web server doesn't provide any functionality beyond simply providing an environment in which the server-side program can execute and pass back the generated responses. The server-side program usually provides for itself such functions as transaction processing, database connectivity, and messaging.

While a Web server may not itself support transactions or database connection pooling, it may employ various strategies for fault tolerance and scalability such as load balancing, caching, and clustering—features oftentimes erroneously assigned as features reserved only for application servers.

The Application server:
As for the application server,it exposes business logic to client applications through various protocols, possibly including HTTP. While a Web server mainly deals with sending HTML for display in a Web browser, an application server provides access to business logic for use by client application programs. The application program can use this logic just as it would call a method on an object.

Such application server clients can include GUIs (graphical user interface) running on a PC, a Web server, or even other application servers. The information traveling back and forth between an application server and its client is not restricted to simple display markup. Instead, the information is program logic. Since the logic takes the form of data and method calls and not static HTML, the client can employ the exposed business logic however it wants.

In most cases, the server exposes this business logic through a component API, such as the EJB (Enterprise JavaBean) component model found on J2EE (Java 2 Platform, Enterprise Edition) application servers. Moreover, the application server manages its own resources. Such gate-keeping duties include security, transaction processing, resource pooling, and messaging. Like a Web server, an application server may also employ various scalability and fault-tolerance techniques.

An example:
As an example, consider an online store that provides real-time pricing and availability information. Most likely, the site will provide a form with which you can choose a product. When you submit your query, the site performs a lookup and returns the results embedded within an HTML page. The site may implement this functionality in numerous ways.

Scenario 1: Web server without an application server
In the first scenario, a Web server alone provides the online store's functionality. The Web server takes your request, then passes it to a server-side program able to handle the request. The server-side program looks up the pricing information from a database or a flat file. Once retrieved, the server-side program uses the information to formulate the HTML response, then the Web server sends it back to your Web browser.
To summarize, a Web server simply processes HTTP requests by responding with HTML pages.

Scenario 2: Web server with an application server
Scenario 2 resembles Scenario 1 in that the Web server still delegates the response generation to a script. However, you can now put the business logic for the pricing lookup onto an application server. With that change, instead of the script knowing how to look up the data and formulate a response, the script can simply call the application server's lookup service. The script can then use the service's result when the script generates its HTML response.

In this scenario, the application server serves the business logic for looking up a product's pricing information. That functionality doesn't say anything about display or how the client must use the information. Instead, the client and application server send data back and forth. When a client calls the application server's lookup service, the service simply looks up the information and returns it to the client.

By separating the pricing logic from the HTML response-generating code, the pricing logic becomes far more reusable between applications. A second client, such as a cash register, could also call the same service as a clerk checks out a customer. In contrast, in Scenario 1 the pricing lookup service is not reusable because the information is embedded within the HTML page. To summarize, in Scenario 2's model, the Web server handles HTTP requests by replying with an HTML page while the application server serves application logic by processing pricing and availability requests.

Note:
Recently, XML Web services have blurred the line between application servers and Web servers. By passing an XML payload to a Web server, the Web server can now process the data and respond much as application servers have in the past.

Additionally, most application servers also contain a Web server, meaning you can consider a Web server a subset of an application server. While application servers contain Web server functionality, developers rarely deploy application servers in that capacity. Instead, when needed, they often deploy standalone Web servers in tandem with application servers. Such a separation of functionality aids performance (simple Web requests won't impact application server performance), deployment configuration (dedicated Web servers, clustering, and so on), and allows for best-of-breed product selection.

Web Services Answers

2010-05-16T19:20:00.000-07:00

1. What is a Web service?
A Web service is any piece of software that makes itself available over the Internet and uses a standardized XML messaging system.

XML is used to encode all communications to a Web service. For example, a client invokes a Web service by sending an XML message, then waits for a corresponding XML response. Because all communication is in XML, Web services are not tied to any one operating system or programming language--Java can talk with Perl; Windows applications can talk with Unix applications.

Beyond this basic definition, a Web service may also have two additional properties:
First, a Web service can have a public interface, defined in a common XML grammar. The interface describes all the methods available to clients and specifies the signature for each method. Currently, interface definition is accomplished via the Web Service Description Language (WSDL).

Second, if you create a Web service, there should be some relatively simple mechanism for you to publish this fact. Likewise, there should be some simple mechanism for interested parties to locate the service and locate its public interface. The most prominent directory of Web services is currently available via UDDI, or Universal Description, Discovery, and Integration.

Web services currently run a wide variety of services from news syndication and stock-market data to weather reports and package-tracking systems.
------------------------------------------------------------------------------
2. What is new about Web services?
People have been using Remote Procedure Calls (RPC) for some time now, and they long ago discovered how to send such calls over HTTP.So, what is really new about Web services? The answer is XML.

XML lies at the core of Web services, and provides a common language for describing Remote Procedure Calls, Web services, and Web service directories. By standardizing on XML, different applications can more easily talk to one another, and this makes software a whole lot more interesting.
------------------------------------------------------------------------------
3. What is the Web service protocol stack?
The Web service protocol stack is an evolving set of protocols used to define, discover, and implement Web services. The core protocol stack consists of four layers:
-Service Transport: This layer is responsible for transporting messages between applications. Currently, this includes HTTP, SMTP, FTP, and newer protocols, such as Blocks Extensible Exchange Protocol (BEEP).
-XML Messaging: This layer is responsible for encoding messages in a common XML format so that messages can be understood at either end. Currently, this includes XML-RPC and SOAP.
-Service Description: This layer is responsible for describing the public interface to a specific Web service. Currently, service description is handled via the WSDL.
-Service Discovery: This layer is responsible for centralizing services into a common registry, and providing easy publish/find functionality. Currently, service discovery is handled via the UDDI.
------------------------------------------------------------------------------
4. What is XML-RPC?
XML-RPC is a protocol that uses XML messages to perform Remote Procedure Calls. Requests are encoded in XML and sent via HTTP POST; XML responses are embedded in the body of the HTTP response. More succinctly, XML-RPC = HTTP + XML + Remote Procedure Calls.

Because XML-RPC is platform independent, diverse applications can communicate with one another. For example, a Java client can speak XML-RPC to a Perl server.
------------------------------------------------------------------------------
5.What is SOAP?
SOAP is an XML-based protocol for exchanging information between computers. Although SOAP can be used in a variety of messaging systems and can be delivered via a variety of transport protocols, the main focus of SOAP is Remote Procedure Calls (RPC) transported via HTTP. Like XML-RPC, SOAP is platform independent, and therefore enables diverse applications to communicate with one another.
------------------------------------------------------------------------------
6. What is WSDL?
The Web Services Description Language (WSDL) currently represents the service description layer within the Web service protocol stack. In a nutshell, WSDL is an XML grammar for specifying a public interface for a Web service. This public interface can include the following:

Information on all publicly available functions.
Data type information for all XML messages.
Binding information about the specific transport protocol to be used.
Address information for locating the specified service.

WSDL is not necessarily tied to a specific XML messaging system, but it does include built-in extensions for describing SOAP services.
------------------------------------------------------------------------------
7. What is UDDI?
UDDI (Universal Description, Discovery, and Integration) currently represents the discovery layer within the Web services protocol stack.

UDDI was originally created by Microsoft, IBM, and Ariba, and represents a technical specification for publishing and finding businesses and Web services. At its core, UDDI consists of two parts:

First, UDDI is a technical specification for building a distributed directory of businesses and Web services. Data is stored within a specific XML format, and the UDDI specification includes API details for searching existing data and publishing new data.

Second, the UDDI Business Registry is a fully operational implementation of the UDDI specification.
Launched in May 2001 by Microsoft and IBM, the UDDI registry now enables anyone to search existing
UDDI data. It also enables any company to register themselves and their services.

The data captured within UDDI is divided into three main categories:
White Pages: This includes general information about a specific company. For example, business name, business description, and address.
Yellow Pages: This includes general classification data for either the company or the service offered. For example, this data may include industry, product, or geographic codes based on standard taxonomies.
Green Pages: This includes technical information about a Web service. Generally, this includes a pointer to an external specification, and an address for invoking the Web service.

You can view the Microsoft UDDI site, or the IBM UDDI site. The complete UDDI specification is available at uddi.org.

w3schools:

What is SOAP?

SOAP is an XML-based protocol to let applications exchange information over HTTP.

Or more simple: SOAP is a protocol for accessing a Web Service.

SOAP stands for Simple Object Access Protocol
SOAP is a communication protocol
SOAP is a format for sending messages
SOAP is designed to communicate via Internet
SOAP is platform independent
SOAP is language independent
SOAP is based on XML
SOAP is simple and extensible
SOAP allows you to get around firewalls
SOAP is a W3C standard

What is WSDL?

WSDL is an XML-based language for locating and describing Web services.

WSDL stands for Web Services Description Language
WSDL is based on XML
WSDL is used to describe Web services
WSDL is used to locate Web services
WSDL is a W3C standard

What is UDDI?

UDDI is a directory service where companies can register and search for Web services.

UDDI stands for Universal Description, Discovery and Integration
UDDI is a directory for storing information about web services
UDDI is a directory of web service interfaces described by WSDL
UDDI communicates via SOAP
UDDI is built into the Microsoft .NET platform

JUnit Answers

2010-05-13T15:20:00.000-07:00

1. What is JUnit?
It is a software testing framework for unit testing. It is written in Java and designed to test Java applications.
It is an Open Source Software maintained by the JUnit.org community.

JUnit is a simple, open source framework to write and run repeatable tests. It is an instance of the xUnit architecture for unit testing frameworks. JUnit features include:

► Assertions for testing expected results
► Test fixtures for sharing common test data
► Test runners for running tests

JUnit was originally written by Erich Gamma and Kent Beck.
--------------------------------------------------------------
2. Who Should Use JUnit, Developers or Testers?
I should say that JUnit is mostly used by developers. JUnit is designed for unit testing, which is really a coding process, not a testing process. But many testers or QA engineers, are also required to use JUnit for unit testing.
--------------------------------------------------------------
3. Why Do You Use JUnit to Test Your Code?
This is a commonly asked question in a job interview. Your answer should have these points:

► I believe that writing more tests will make me more productive, not less productive.
► I believe that tests should be done as soon as possible at the code unit level.
► I believe that using JUnit makes unit testing easier and faster.
--------------------------------------------------------------
4. How To Write a Simple JUnit Test Class?
You should be able to write this simple test class with one test method:

import org.junit.*;
public class HelloTest
{
@Test public void testHello()
{
String message = "Hello World!";
Assert.assertEquals(12, message.length());
}
}
--------------------------------------------------------------
5. How To Compile a JUnit Test Class?
Compiling a JUnit test class is like compiling any other Java classes. The only thing you need watch out is that the JUnit JAR file must be included in the classpath. For example, to compile the test class HelloTest.java described previously, you should do this:

javac -cp junit-4.4.jar HelloTest.java

dir HelloTest.*
453 HelloTest.class
183 HelloTest.java

The compilation is ok, if you see the HelloTest.class file.
--------------------------------------------------------------
6. How To Run a JUnit Test Class?
A JUnit test class usually contains a number of test methods. You can run all test methods in a JUnit test class with the JUnitCore runner class. For example, to run the test class HelloTest.java described previously, you should do this:

java -cp .;
junit-4.4.jar org.junit.runner.JUnitCore HelloTest

JUnit version 4.4
Time: 0.015
OK (1 test)

This output says that 1 tests performed and passed.
--------------------------------------------------------------
7. What CLASSPATH Settings Are Needed to Run JUnit?
It doesn't matter if you run your JUnit tests from a command line, from an IDE, or from "ant", you must define your CLASSPATH settings correctly. Here is what recommended by the JUnit FAQ with some minor changes:

To run your JUnit tests, you'll need the following elemements in your CLASSPATH:

* The JUnit JAR file.
* Location of your JUnit test classes.
* Location of classes to be tested.
* JAR files of class libraries that are required by classes to be tested.

If attempting to run your tests results in a NoClassDefFoundError, then something is missing from your CLASSPATH.

If you are running your JUnit tests from a command line on a Windows system:

set CLASSPATH=c:\A\junit-4.4.jar;c:\B\test_classes;
c:\B\target_classes;c:\D\3rd_party.jar

If you are running your JUnit tests from a command line on a Unix (bash) system:

export CLASSPATH=/A/junit-4.4.jar:/B/test_classes:
/C/target_classes:/D/3rd_party.jar
--------------------------------------------------------------
8. How Do I Run JUnit Tests from Command Window?
To run JUnit tests from a command window, you need to check the following list:

1. Make sure that JDK is installed and the "java" command program is accessible through the PATH setting. Type "java -version" at the command prompt, you should see the JVM reports you back the version string.
2. Make sure that the CLASSPATH is defined as shown in the previous question.
3. Invoke the JUnit runner by entering the following command:

java org.junit.runner.JUnitCore
--------------------------------------------------------------
9. How To Write a JUnit Test Method?
This interview question is to check if you know the basic rules about writing a JUnit test method:

* You need to mark the method as a JUnit test method with the JUnit annotation: @org.junit.Test.
* A JUnit test method must be a "public" method. This allows the runner class to access this method.
* A JUnit test method must be a "void" method. The runner class does not check any return values.
* A JUnit test should perform one JUnit assertion - calling an org.junit.Assert.assertXXX() method.

Here is a simple JUnit test method:

import org.junit.*;
@Test public void testHello() {
String message = "Hello World!";
Assert.assertEquals(12, message.length());
}
--------------------------------------------------------------
10. Why Not Just Use a Debugger for Unit Testing?
* A debugger is designed for manual debugging and manual unit testing, not for automated unit testing. JUnit is designed for automated unit testing.
* Automated unit testing requires extra time to setup initially. But it will save your time, if your code requires changes many times in the future.
--------------------------------------------------------------
11. Why Not Just Write a main() Method for Unit Testing?
It is possible to write a main() method in each class that needs to be tested for unit testing. In the main() method, you could create test object of the class itself, and write some tests to test its methods. However, this is not a recommended approach because of the following points:

* Your classes will be cluttered with test code in main method. All those test codes will be packaged into the final product.
* If you have a lots of classes to test, you need to run the main() method of every class. This requires some extra coding effort.
* If you want the test results to be displayed in a GUI, you will have to write code for that GUI.
* If you want to log the results of tests in HTML format or text format, you will have to write additional code.
* If one method call fails, next method calls won't be executed. You will have to work-around this.
--------------------------------------------------------------
12. Why Not Just Use System.out.println() for Unit Testing?
Inserting debug statements into code is a low-tech method for debugging it. It usually requires that output be scanned manually every time the program is run to ensure that the code is doing what's expected.

It generally takes less time in the long run to codify expectations in the form of an automated JUnit test that retains its value over time. If it's difficult to write a test to assert expectations, the tests may be telling you that shorter and more cohesive methods would improve your design.
--------------------------------------------------------------
13. Under What Conditions Should You Test set() and get() Methods?
Tests should be designed to target areas that might break. set() and get() methods on simple data types are unlikely to break. So no need to test them.

set() and get() methods on complex data types are likely to break. So you should test them.
--------------------------------------------------------------
14. Do You Need to Write a Test Class for Every Class That Need to Be Tested?
This is a simple question. But the answer shows your organization skills.

The technical answer is no. There is no need to write one test class for each every class that need to be tested. One test class can contain many tests for many test target classes.

But the practical answer is yes. You should design one test class per test target class for low level basic tests. This makes your test classes much easier to manage and maintain. You should write separate test classes for high level tests that requires multiple target classes working together.
--------------------------------------------------------------
15. What Are JUnit 3.8 Naming Conventions?
Test Case Class: Named as [classname]Test.java, where "classname" is the name of the class that is being tested. A test case class define the fixture to run multiple tests. A test case class must be subclass of junit.framework.TestCase.

Test Method: Named test[XXX], where "XXX" is any unique name for this test. A test method name should be prefixed with "test" to allow the TestSuite class to extract it automatically. A test method must be declared as "public".

Test Suite: Can be named any way you want to. But Eclipse uses AllTests.java as the name. A test suite is a collection of test cases.
--------------------------------------------------------------
16. Can You Explain the Life Cycle of a JUnit 3.8 Test Case Class?
A JUnit 3.8 test case class contains a setUp() method, a tearDown() method and multiple testXXX() methods. When calling a test runner to run this test class, the runner will execute those methods in a specific order giving the test case class an execution life cycle like this:

setUp()
testXXX1()
tearDown()

setUp()
testXXX2()
tearDown()
--------------------------------------------------------------
17. Can You Explain the Life Cycle of a JUnit 4.4 Test Class?
A JUnit 4.4 test class contains a @Before method, an @After method and multiple @test methods. When calling a test runner to run this test class, the runner will execute those methods in a specific order giving the test class an execution life cycle like this:

@Before
@Test XXX1
@After

@Before
@Test XXX2
@After
--------------------------------------------------------------
18. How To Group Test Cases Class using JUnit TestSuite?
Usually, there are many classes to be tested in a Java application. For each Java class in the application you need to write a JUnit test case class containing multiple test methods.

You could call a JUnit runner to run each JUnit test case class manually. But you should group all JUnit test case clases into a test suite with JUnit TestSuite.

To group all test case classes together and run them a single unit, you should create a new class named like AllTests.java. In this class you must create a "public static Test suite()" method, which returns a TestSuite object as a container of test case classes.
--------------------------------------------------------------
19. How Do You Test a private Method?
When a method is declared as "private", it can only be accessed within the same class. So there is no way to test a "private" method of a target class from any test class.

To resolve this problem, you have to perform unit testing manually. Or you have to change your method from "private" to "protected".
--------------------------------------------------------------
20. How Do You Test a protected Method?
When a method is declared as "protected", it can only be accessed within the same package where the class is defined. In order to test a "protected" method of a target class, you need to define your test class in the same package as the target class.
--------------------------------------------------------------
21. How Do You Test Classes That Must Be Run in a J2EE Container?
To test classes that must be run in a J2EE container (e.g. servlets, EJBs), you should refactor J2EE components to delegate functionality to other objects that don't have to be run in a J2EE container will improve the design and testability of the software.

Cactus is an open source JUnit extension that can be used to test J2EE components in their natural environment.
--------------------------------------------------------------
22. How to create a Test Suite using JUnit in Eclipse?
There are four ways to create a JUnit test suite class in Eclipse with JUnit plugin: org.junit_3.8.1. First, select the directory (usually unit-tests) that you wish to create the test suite class in.

1. Select File > New > Other... > Java > JUnit > JUnit Test Suite.
2. Select the arrow of the button in the upper left of the toolbar. Select Other... > Java > JUnit > JUnit Test Suite,
3. Right click on a package in the Package Explorer view in the Java Perspective, and select Other... > Java > JUnit > JUnit Test Suite,
4. You can create a normal Java class as shown in the Eclipse tutorial, but include junit.framework.TestSuite as the super class of the test class you are creating.
--------------------------------------------------------------
23. Can You Describe Steps of Creating Test Case Classes in Eclipse?
Steps to create a test case class in Eclipse with JUnit plugin: org.junit_3.8.1.

1. Use the Browse button to search for a different super class. The default super class is junit.framework.TestCase.
2. Check which method stubs you would like to create. You can create a main method, setUp(), tearDown(), or a constructor(), but all of these are optional. A constructor is only run when the test case class is first instantiated, but the setUp() and tearDown() methods are run before and after, respectively, each test case is run.
3. You can browse the application that you are creating for a class that you wish to test, or this could be left blank if you will generate the class while creating while creating the test.

- If you selected a "Class Under Test" you can click the Next button, otherwise click Finish. You will be able to select which methods in the class under test that you want to write test cases for. The method signatures will be created for you. Click Finish. The new test case class will be open in the editor.

- This test class demonstrates the basic functionality of the setUp() and tearDown() methods, and gives example test cases. The testForException() method demonstrates how to test that an exception is properly thrown.
--------------------------------------------------------------
24. How to Run a JUnit Test Case in Eclipse?
There are three ways to run JUnit Test Cases or Test Suites in Eclipse with JUnit plugin: org.junit_3.8.1.

1. You can right click on the test case class or test suite class and select Run As > JUnit Test.
2. You can select a test case or suite and click the arrow on the icon or select Run from the toolbar, and select Run As > JUnit Test.
3. You can select a test case or suite and click the arrow on the icon or select Run from the toolbar, and select Run... From here you will create a new JUnit test configuration, and name it. You can choose to run a single test case, or run all test cases in a project or folder.
--------------------------------------------------------------
25. How To Create Test Class in Eclipse?
There are five ways to create a JUnit test case class in Eclipse with JUnit plugin: org.junit_3.8.1. First, select the directory (usually unittests/) that you wish to create the test case class in.

1. Select File ; New ; JUnit Test Case.
2. Select the arrow of the button in the upper left of the toolbar. Select JUnit Test Case.
3. Right click on a package in the Package Explorer view in the Java Perspective, and select JUnitTestCase.
4. Click on the arrow of the icon in the toolbar. Select JUnit Test Case.
5. You can create a normal Java class as shown in the Eclipse tutorial, but include junit.framework.TestCase as the super class of the test class you are creating.
--------------------------------------------------------------
26. What Do You Do When a Defect Is Reported?
Test-driven development generally lowers the defect density of software. But we're all fallible, so sometimes a defect will slip through. When this happens, write a failing test that exposes the defect. When the test passes, you know the defect is fixed!

Don't forget to use this as a learning opportunity. Perhaps the defect could have been prevented by being more aggressive about testing everything that could reasonably break. Or perhaps there are other places in the application that have the similar code that might break too.
--------------------------------------------------------------
27. How Often Should You Run Your JUnit Tests?
Run all your unit tests as often as possible, ideally every time the code is changed. Make sure all your unit tests always run at 100%. Frequent testing gives you confidence that your changes didn't break anything and generally lowers the stress of programming in the dark.

For larger systems, you may just run specific test suites that are relevant to the code you're working on. Run all your acceptance, integration, stress, and unit tests at least once per day.
--------------------------------------------------------------
28. Do You Have To Write a Test for Everything?
No, just test everything that could reasonably break.

Be practical and maximize your testing investment. Remember that investments in testing are equal investments in design. If defects aren't being reported and your design responds well to change, then you're probably testing enough. If you're spending a lot of time fixing defects and your design is difficult to grow, you should write more tests.

If something is difficult to test, it's usually an opportunity for a design improvement. Look to improve the design so that it's easier to test, and by doing so a better design will usually emerge.
--------------------------------------------------------------
29. How Do You Test a Method That Does not Return Anything?
You need to follow the logic below to answer this question:

* If a method is not returning anything through the "return" statement (void method), it may return data through its arguments. In this case, you can test the data returned in any argument.
* Else if a method is not returning any data through its arguments, it may change values of its instance variables. In this case, you can test changes of any instance variables.
* Else if a method is not changing any instance variable, it may change values of its class variables. In this case, you can test changes of any class variables.
* Else if a method is not changing any class variable, it may change external resources. In this case, you can test changes of any external resources.
* Else if a method is not changing any external resources, it may just doing nothing but holding the thread in a waiting status. In this case, you can test this waiting condition.
* Else if a method is not holding the thread in waiting status, then this method is really doing nothing. In this case, there is no need to test this method!
--------------------------------------------------------------
30. When Should Unit Tests Should Be Written In Development Cycle?
If you are a TDD (Test-Driven Development) believer, you should write unit test before writing the code. Test-first programming is practiced by only writing new code when an automated test is failing.

Good tests tell you how to best design the system for its intended use. They effectively communicate in an executable format how to use the software. They also prevent tendencies to over-build the system based on speculation. When all the tests pass, you know you're done!

Whenever a customer test fails or a bug is reported, first write the necessary unit test(s) to expose the bug(s), then fix them. This makes it almost impossible for that particular bug to resurface later. Test-driven development is gaining momentum these days compared to writing tests after the code.

SQL Server Stored Procedures

2010-05-13T13:30:00.000-07:00

Blogged Originally By : Tom O'Neill

Learning something new is challenging. Learning something new on your own redefines challenging.

For a tutorial on MySQL Stored Procedures please visit MYSQL Tutorial.

This article (for SQL Server) will consist of the following topics:

-What are stored procedures?
-What do you need to get started?
-Writing your first stored procedure
-Writing more sophisticated stored procedures
-Input Variables
-Input Variables with SELECT and UPDATE Statements
-Exercise: Pass Data to a SELECT Stored Procedure
-Conclusion
--------------------------------------------------------

What Are Stored Procedures?
Have you ever written SQL statements, like inserts, selects, and updates? Then you have already written most of a stored procedure. A stored procedure is an already written SQL statement that is saved in the database. If you find yourself using the same query over and over again, it would make sense to put it into a stored procedure. When you put this SQL statement in a stored procedure, you can then run the stored procedure from the database's command environment.

An example is: exec usp_displayallusers

The name of the stored procedure is "usp_displayallusers", and "exec" tells SQL Server to execute the code in the stored procedure. (Note: "usp_" in front of the stored procedure name is used to designate this stored procedure as a user-created stored procedure.) The code inside the stored procedure can be something as simple as:

SELECT * FROM USERLIST

This "select" statement will return all data in the USERLIST table. You may think, skeptically, that stored procedures aren’t terribly useful. Just save the query and run it when you need to. Too easy, right?

Well, there is more to the story. Many queries get more complex than "select * from . . ." Also, you may want to call the stored procedure from an application, such as an ASP page, Visual Basic application, or a Java servlet. With a stored procedure, you can store all the logic in the database, and use a simple command to call the stored procedure. Later, if you decide to migrate from ASP to J2EE, you only need to change the application layer, which will be significantly easier. Much of the business logic will remain in the database.
------------------------------------------------
Getting Started with Stored Procedures
What do I need to get started? To begin writing stored procedures, the following are essential:

-A database management system.
-A database built inside the database management system.
-A text editor, such as Notepad or Query Analyzer.

Items 1 and 2 are absolutely essential. You can’t write stored procedures without a database. They would be useless. Sometimes, I write my procedures in Notepad (or another text editor), and copy them into the New Stored Procedure window in SQL Server.

Next, you will have to decide what you want your stored procedure to do. It can be tempting to just dive right into the task at hand, but it is always prudent to sketch out some ideas first. Some considerations should be:

-Do you want to view data in the database (SELECT), insert new records (INSERT INTO), or do I want to change an existing record (UPDATE)?
-With which tables will you have to work? Does it make sense to create a VIEW first?
-How often will this procedure actually be used?

Once you have struggled with these questions , you will be ready to start coding!
------------------------------------------------
Writing Your First Stored Procedure

Finally!!! It is time to write your first stored procedure (assuming you have created your database). In SQL Server, under your database tree, select the "Stored Procedures" option from Enterprise Manager (when you gain more experience, you can use Query Analyzer to create stored procedures). There will be a number of system generated stored procedures there already. Just ignore them. Your next step is to right click on any of the existing stored procedures (don’t worry, you won’t actually use them), then select "New Stored Procedure . . ." This will open the stored properties window I discussed above. The following code will appear already in the window:

CREATE PROCEDURE [PROCEDURE NAME] AS

The first thing I usually do is provide some spacing (we’ll need it later). This isn’t required, and as you write more stored procedures, you will find a style with which you are comfortable.

/* We will use this area for comments */

CREATE PROCEDURE [PROCEDURE NAME]

/* We will put the variables in here, later */

/*This is where the actual SQL statements will go*/

So far, it is pretty simple. Let’s look at the top comments section first,

/*We will use this area for comments*/

When you write stored procedures (especially for a business or academic project), you never know who will eventually have to alter the code. This top section is useful for comments about the stored procedure, a change log, and other pertinent information. While this is not required, it is just a good programming habit. For this exercise, make it look like this:

/*Name: usp_displayallusers
Description: displays all records and columns in USERLIST table
Author: NahkModification Log: Change

Description Date Changed By
Created procedure 5/13/2010 Nahk
*/

Of course, you can use your own name and today’s date.

The next section will change only slightly. Every stored procedure needs the words "CREATE PROCEDURE" followed by the name you want to assign to the stored procedure. While not required, stored procedure names usually begin with the prefix "usp_".

CREATE PROCEDURE usp_displayallusers

This tells the database that you are creating a stored procedure named "usp_displayallusers". So far, your stored procedure should look like this:

/*
Name: usp_displayallusers
Description: displays all records and columns in USERLIST table
Author: Nahk
Modification Log: Change

Description Date Changed By
Created procedure 5/13/2010 Nahk
*/

CREATE PROCEDURE usp_displayallusers

The next step is to think about variables. Since this is our first stored procedure together, we won’t deal with them yet. Just keep in mind that they are usually added after the "CREATE PROCEDURE" line. Since we don’t have variables, the next step is quite simple. Put the word "AS" beneath the create procedure line.

CREATE PROCEDURE usp_displayallusers
AS

We are telling the database that we want to create a stored procedure that is called "usp_displayallusers" that is characterized by the code that follows. After the "AS" entry, you will simply enter SQL code as you would in a regularly query. For our first, we will use a SELECT statement:

SELECT * FROM USERLIST

Now, your stored procedure should look like this:

/*
Name: usp_displayallusers
Description: displays all records and columns in USERLIST table
Author: Nahk
Modification Log: Change

Description Date Changed By
Created procedure 5/13/2010 Nahk
*/

CREATE PROCEDURE usp_displayallusers

SELECT * FROM USERLIST

Congratulations, you have written your first stored procedure. If you authored the procedure in a text editor, now would be a good time to copy it into the New Stored Procedure window in SQL Server. Once you have done so, click the "Check Syntax" box. This is a great troubleshooting tool for beginners and experts alike. When SQL Server tells you "Syntax check successful!", you can click OK to save your stored procedure. To view the procedure, simply double-click usp_displayallusers in the Stored Procedures window. To run your stored procedure, open the Query Analyzer and type:

exec usp_displayallusers

Then, click the green "play" button to run the query. You will see that the procedure has run successfully.

------------------------------------------

More Sophisticated Stored Procedures

In this section, we are going to address a few new topics. In addition to writing SELECT queries, you are going to want to insert, update, and delete database records. Also, you will probably want to pass information from outside the query. Since inserts and updates require some sort of data input to be useful, our first topic will be variables. From there, we will use data stored in variables for inserts and updates.

Note: In this article, we will only address input variables (variables that pass data to the SQL statement in the stored procedure). There are various types of outputs and returns, and they can become quite complex.

Input Variables

There are many reasons for wanting to pass data to a stored procedure, especially if your stored procedure is being called by a dynamic web page or other application. You may want to use a SELECT statement to pull information into the application for dynamic display. In this case, you would pass selection criteria to the stored procedure (for use in a WHERE clause). If you are inserting new records, you will need to get the data from somewhere. Updating existing records also involves simply getting the data. In both INSERT and UPDATE statements, it is necessary to pass data to the stored procedure. For INSERT, UPDATE, and SELECT statements (to name a few), you can pass the data to your stored procedure using variables.

Input variables are essentially "storage" for data that you want to pass to your stored procedure. Inside your stored procedure, you will declare variables at the top of the stored procedure. How does the data get there? The data is entered in the execstatement that you use to kick off the stored procedure.

There are two types of variables that you can create in SQL Server stored procedures: Global and Local. Since this is for beginners, I don’t want to go crazy with too many options. We’ll stick to local variables for now. The only real requirement is that you begin your variable with the "@" symbol. Here are some examples:

@f_name @fullname @HomePhone @ext

For every data element you want to pass, you will need to declare a variable. Declaring a variable is quite easy. You decide on a name and a datatype (integer, text, etc.), and indicate the name and datatype at the top of the procedure (below the "CREATE PROCEDURE" line). Let’s add a record to USERLIST. Remember the following:

"usr_id" is the primary key, and is system-generated. We won’t need to pass a value for it.
"login", "pswd", "l_name", and "email" are required fields. We will have to pass values for them.

First, let’s create the header information that should be a part of every stored procedure.

/*
Name: usp_adduser
Description: Adds a user
Author: Nahk
Modification Log: Change

Description Date Changed By
Created procedure 5/13/2010 Nahk
*/

Remember this?

CREATE PROCEDURE usp_adduser

/*We will put the variables in here, later*/

Add the "CREATE PROCEDURE" line, assigning the name "usp_adduser". Our next step is to remove the comments and declare our variables!

To start, let’s look at how our variables will fit. We will need to create a variable for every value we may need to pass. We may not pass a value to every field every time we run the stored procedure. But, we do need to address the possibility that over the life of the stored procedure, every data element may be used. The best way to address this issue is to create a variable for every column in USERLIST. To keep this example simple, we are also assuming that each of the columns can be NULL, and we will also be passing all of the variables to the stored procedure. If some of the columns cannot be NULL, or if not all of the columns will be affected, then the stored procedure and/or the exec statement have to be rewritten slightly. The list below shows the variable and the field with which it is associated.

@login—login
@pswd—pswd
@f_name—f_name
@l_name—l_name
@address_1—address_1
@address_2—address_2
@city—city
@state—state
@zipcode—zipcode
@email—email

You have probably noticed that I gave the variables names that closely resemble the column names with which they are associated. This will make it easier for you to maintain the stored procedure in the future. Delete the comments about variables, and put your list of variables beneath the "CREATE PROCEDURE" line.

CREATE PROCEDURE usp_adduser
@login
@pswd
@f_name
@l_name
@address_1
@address_2
@city
@state
@zipcode
@email

Next, add datatypes to each of the variables. The datatype assigned to the variable should match the datatype assigned to the corresponding column in the database. For any elements with the "char", "varchar", or "numeric" datatypes, you will need to put the maximum character length list in parentheses after the datatype. Separate all variables (except the last one), with a comma.

CREATE PROCEDURE usp_adduser

@login varchar(20),
@pswd varchar(20),
@f_name varchar(25),
@l_name varchar(35),
@address_1 varchar(30),
@address_2 varchar(30),
@city varchar(30),
@state char(2),
@zipcode char(10),
@email varchar(50)

With that last keystroke, you have created your first set of variables. To finish "usp_adduser", we will have to figure out what we want the stored procedure to do, then add the appropriate code after the "AS" statement. This stored procedure will add a new record to the USERLIST table, so we should use an INSERT statement. The SQL should be:

INSERT INTO USERLIST (login, pswd, f_name, l_name, address_1, address_2, city, state, zipcode, email)

The INSERT clause is pretty standard. The VALUES clause is a bit more complex. If you have worked with databases, you are probably accustomed to seeing something like this:

VALUES ('dnelson', 'dean2003', 'Dean', 'Nelson', '200 Berkeley Street', '', 'Boston', 'MA', '02116', 'dnelson@test.com')

Since we are passing values from variables, it will look a bit different. Instead of putting the actual values in the VALUES clause, we’ll just put the variables. You won’t need to use quotes.

VALUES (@login, @pswd, @f_name, @l_name, @address_1, @address_2, @city, @state, @zipcode, @email)

What does the entire stored procedure look like? Let’s pull it all together.

/* Name: usp_adduser
Description: Add new logins.
Author: Nahk
Modification Log: Change

Description Date Changed By
Created procedure 5/13/2010 Nahk */

CREATE PROCEDURE usp_adduser

INSERT INTO USERLIST (login, pswd, f_name, l_name, address_1, address_2, city, state, zipcode, email)

VALUES (@login, @pswd, @f_name, @l_name, @address_1, @address_2, @city, @state, @zipcode, @email)

It looks pretty long and complex, though we know from the process above that the stored procedure is not necessarily complex; it just contains a lot of data.

Now, we have a stored procedure that can accept external data. What do we do with it? How do we get the data? It’s not that hard; I promise. We’ll start with the "exec" statement we used when we wrote our first stored procedure. Remember?

exec usp_displayallusers

We have a new stored procedure to execute, so this time, the command will be:

exec usp_adduser

There is still the issue of how to get our data into the stored procedure. Otherwise, all those variables will be useless. To get data into our stored procedure, simply add the information (in single quotes ' ') after the execute statement.

exec usp_adduser ' '

Remember to pass as many parameters as you have variables, otherwise SQL Server will throw an error. Since we have ten variables, your execute statement should look like this:

exec usp_adduser ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '

Next, let’s include the data that we will want to pass to usp_adduser. Your execute statement will look like:

exec usp_adduser 'dnelson', 'dean2003', 'Dean', 'Nelson', '200 Berkeley Street', ' ', 'Boston', 'MA', '02116', 'dnelson@test.com'

Running the query should be successful, and SQL Server will tell you that one row has been affected. Now, let’s try using input variables with some other query types.

Input Variables with SELECT and UPDATE Statements

Regardless of the type of SQL statement you use, variables work the same way. Look at the following stored procedure:

/* Name: usp_updateuser
Description: Updates user information
Author: Nahk
Modification Log: Change

Description Date Changed By
Created procedure 5/13/2010 Nahk */

CREATE PROCEDURE usp_updateuser

@usr_id int,
@login varchar(20),
@pswd varchar(20),
@f_name varchar(25),
@l_name varchar(35),
@address_1 varchar(30),
@address_2 varchar(30),
@city varchar(30),
@state char(2),
@zipcode char(10),
@email varchar(50)

UPDATE USERLIST

SET

login=@login,
pswd=@pswd,
f_name=@f_name,
l_name=@l_name,
address_1=@address_1,
address_2=@address_2,
city=@city,
state=@state,
zipcode=@zipcode,
email=@email

WHERE usr_id=@usr_id

What’s different about this stored procedure (compared to the INSERT stored procedure)? Aside from the obvious fact that this is an UPDATE instead of an INSERT? First, you should have noticed that we added another variable, @usr_id. This new variable has the datatype "int" because it is an integer field. Why did we have to do this? In the INSERT stored procedure, we were creating a new record. Since usr_id is assigned by the system, we didn’t need to worry about it. Now we are updating an existing record. To ensure that we update the right record, we need to use the primary key as a filter. Notice that @usr_id shows up again in the WHERE clause, where we would normally have a value in quotes (like '1233').

The other difference is that we have included the variables in the SET clause. Instead of:

we have used:

Remember, when you use variables, you do not have to use quotes.

-----------------------------------------------

Exercise: Pass Data to a SELECT Stored Procedure

Create a stored procedure that returns one record, based on the table’s primary key. Remember to:

Create the header record (commented)
Create the stored procedure name and declare variables
Create the rest of your stored procedure

Solution:

Stored Procedure:

/* Name: usp_finduser
Description: find a user
Author: Nahk
Modification Log: Change

Description Date Changed By
Created procedure 5/13/2010 Nahk */

CREATE PROCEDURE usp_finduser

@usr_id int

SELECT * FROM USERLIST
WHERE usr_id=@usr_id

Execute Statement:

exec usp_finduser '1'

Did it work? If not, check the if you have any user with the user_id as '1' or not.

As stated earlier this article was a tutorial on Stored Procedures for the SQL Server. For a tutorial on Stored Procedures using MySQL click here.

JAVA Collections Answers

2010-05-02T11:38:00.000-07:00

Introduction to Collections:
A collection — sometimes called a container — is simply an object that groups multiple elements into a single unit. Collections are used to store, retrieve, manipulate, and communicate aggregate data. Typically, they represent data items that form a natural group, such as a poker hand (a collection of cards), a mail folder (a collection of letters), or a telephone directory (a mapping of names to phone numbers).
Collection implementations in earlier versions of the Java platform included Vector, Hashtable, and array. However, those earlier versions did not contain a collections framework.

*Differentiate between Collection and Collections.
Collection is an interface and collections is a class.

Collection is the root interface in the collection hierarchy. A collection represents a group of objects, known as its elements. Some collections allow duplicate elements and others do not. Some are ordered and others unordered. The SDK does not provide any direct implementations of this interface: it provides implementations of more specific subinterfaces like Set and List. This interface is typically used to pass collections around and manipulate them where maximum generality is desired.

The Collections class consists exclusively of static methods that operate on or return collections. It contains polymorphic algorithms that operate on collections, "wrappers", which return a new collection backed by a specified collection, and a few other odds and ends.

The following list describes the core collection interfaces:

- Collection — the root of the collection hierarchy. A collection represents a group of objects known as its elements.

- Set : A Set is a collection that cannot contain duplicate elements.

- List :A List is an ordered collection (sometimes called a sequence). Lists can contain duplicate elements. The user of a List generally has precise control over where in the List each element is inserted. The user can access elements by their integer index (position) eg ArrayList.

- Queue — a collection used to hold multiple elements prior to processing.

- Map :A Map is an object that maps keys to values. Maps cannot contain duplicate keys: Each key can map to at most one value eg HashMap.
----------------------------------------------------------------------------------

Quick Overview:

ArrayList class
This class uses dynamic arrays for storing elements, and arrays are sequentially arranged in the memory. It implements the List interface and extends the AbstractList class. It can contain duplicate elements, and it maintains an insertion order. The elements can be accessed using the index notation. This class contains various inbuilt methods, which help in making data retrieval and manipulation easy.

LinkedList class

This class uses a doubly-linked list to store elements. It maintains an insertion order, and it can be used as a list, stack or queue. It actually implements the List and Dequeue interfaces and extends the Abstract class. The add and remove methods are used to add and delete. The size method returns the number of lists in the list.

HashMap

This is used to store key value pairs. It implements the Map interface and is not a part of the collection. HashMap uses the hashing technique to store key value pairs. The key value pair is called a bucket. Each bucket is stored in an array in the HashMap class. The hashing function works on the key and returns an index at which the bucket is stored. There are chances of two keys returning the same index upon hashing. In such cases, the buckets are stored at the same index but are linked, the same as in a Linked List. Each bucket contains the pointer to the next bucket. The equals method is overridden, and the value is fetched when the key matches the key in the bucket. HashMap contains two basic methods, called get and put, to get the value and put the key value pair in the map.

TreeMap

The TreeMap class implements the Map interface by using a tree. A TreeMap provides an efficient means of storing key/value pairs in sorted order, and allows rapid retrieval. You should note that, unlike a HashMap, a TreeMap guarantees that its elements will be sorted in ascending key order. You can specify the sorting order while creating TreeMap by providing an explicit comparator to TreeMap. Basically, you can create TreeMap in Java in different waysa TreeMap with a natural sorting order, and TreeMap with custom sorting order by providing the comparator, by copying the sorting order from the other SortedMap, etc.

TreeSet

This provides an implementation of the Set interface that uses a tree for storage. Objects are stored in sorted, ascending order. Access and retrieval times are quite fast, which makes TreeSet an excellent choice when storing large amounts of sorted information that must be found quickly. It contains unique elements only.

----------------------------------------------------------------------------------
1. What Is a Collections Framework?
A collections framework is a unified architecture for representing and manipulating collections. All collections frameworks contain the following:
Interfaces: These are abstract data types that represent collections. Interfaces allow collections to be manipulated independently of the details of their representation. In object-oriented languages, interfaces generally form a hierarchy.
Implementations: These are the concrete implementations of the collection interfaces. In essence, they are reusable data structures.
Algorithms: These are the methods that perform useful computations, such as searching and sorting, on objects that implement collection interfaces. The algorithms are said to be polymorphic: i.e the same method can be used on many different implementations of the appropriate collection interface. In essence, algorithms are reusable functionality.
----------------------------------------------------------------------------------
2. What is HashMap and Map?

Map is Interface and Hashmap is class that implements this interface. Click Here for example.
----------------------------------------------------------------------------------
3. What is the significance of ListIterator? What is the difference b/w Iterator and ListIterator?
Iterator : Enables you to cycle through a collection in the forward direction only, for obtaining or removing elements
ListIterator : It extends Iterator, allow bidirectional traversal of list and the modification of elements.
----------------------------------------------------------------------------------
4. Difference between HashMap and HashTable? Can we make hashmap synchronized?
1. The HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized and permits nulls. (HashMap allows null values as key and value whereas Hashtable doesn’t allow nulls).
2. HashMap does not guarantee that the order of the map will remain constant over time.
3. HashMap is non synchronized whereas Hashtable is synchronized.
4. Iterator in the HashMap is fail-safe while the enumerator for the Hashtable isn't.
Note on Some Important Terms
1)Synchronized means only one thread can modify a hash table at one point of time. Basically, it means that any thread before performing an update on a hashtable will have to acquire a lock on the object while others will wait for lock to be released.
2)Fail-safe is relevant from the context of iterators. If an iterator has been created on a collection object and some other thread tries to modify the collection object "structurally”, a concurrent modification exception will be thrown. It is possible for other threads though to invoke "set" method since it doesn’t modify the collection "structurally”. However, if prior to calling "set", the collection has been modified structurally, "IllegalArgumentException" will be thrown.
HashMap can be synchronized by
Map m = Collections.synchronizeMap(hashMap);
----------------------------------------------------------------------------------
5. What is the difference between set and list?
A Set stores elements in an unordered way and does not contain duplicate elements, whereas a list stores elements in an ordered way but may contain duplicate elements.
----------------------------------------------------------------------------------
6. Difference between Vector and ArrayList? What is the Vector class?
Vector is synchronized whereas ArrayList is not. The Vector class provides the capability to implement a growable array of objects. ArrayList and Vector class both implement the List interface. Both classes are implemented using dynamically resizable arrays, providing fast random access and fast traversal. In vector the data is retrieved using the elementAt() method while in ArrayList, it is done using the get() method. ArrayList has no default size while vector has a default size of 10. when you want programs to run in multithreading environment then use concept of vector because it is synchronized. But ArrayList is not synchronized so, avoid use of it in a multithreading environment.
----------------------------------------------------------------------------------
7. What is an Iterator interface? What is its use?
The Iterator is an interface, used to traverse through the elements of a Collection. It is not advisable to modify the collection itself while traversing an Iterator.

Click Here on how to iterate a loop
----------------------------------------------------------------------------------
8. What is the Collections API?
The Collections API is a set of classes and interfaces that support operations on collections of objects.
Example of classes: HashSet, HashMap, ArrayList, LinkedList, TreeSet and TreeMap.
Example of interfaces: Collection, Set, List and Map.
----------------------------------------------------------------------------------
9. What is the List interface?
The List interface provides support for ordered collections of objects.
----------------------------------------------------------------------------------
10. How can we access elements of a collection?
We can access the elements of a collection using the following ways:
1.Every collection object has get(index) method to get the element of the object. This method will return Object.
2.Collection provide Enumeration or Iterator object so that we can get the objects of a collection one by one.
----------------------------------------------------------------------------------
11. What is the Set interface?
The Set interface provides methods for accessing the elements of a finite mathematical set. Sets do not allow duplicate elements.
----------------------------------------------------------------------------------
12.What’s the difference between a queue and a stack?
Stack is a data structure that is based on last-in-first-out rule (LIFO), while queues are based on First-in-first-out (FIFO) rule.
----------------------------------------------------------------------------------
13.What is the Map interface?
The Map interface is used to associate keys with values.
----------------------------------------------------------------------------------
14. What is the Properties class?
The properties class is a subclass of Hashtable that can be read from or written to a stream. It also provides the capability to specify a set of default values to be used.
----------------------------------------------------------------------------------
15. Which implementation of the List interface provides for the fastest insertion of a new element into the middle of the list?

a. Vector b. ArrayList c. LinkedList

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 the elements that follow the insertion point must be shifted to make room for the new element. The LinkedList is implemented using a doubly linked list; an insertion requires only the updating of the links at the point of insertion. Therefore, the LinkedList allows for fast insertions and deletions.
----------------------------------------------------------------------------------
16. How can we use hashset in collection interface?
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. This class permits the Null element.
This class offers constant time performance for the basic operations (add, remove, contains and size), assuming the hash function disperses the elements properly among the buckets.
----------------------------------------------------------------------------------
17. What are differences between Enumeration, ArrayList, Hashtable and Collections and Collection?
Enumeration: It is series of elements. It can be use to enumerate through the elements of a vector, keys or values of a hashtable. You can not remove elements from Enumeration.
ArrayList: It is re-sizable array implementation. Belongs to 'List' group in collection. It permits all elements, including null. It is not thread -safe.
Hashtable: It maps key to value. You can use non-null value for key or value. It is part of group Map in collection.
Collections: It implements Polymorphic algorithms which operate on collections.
Collection: It is the root interface in the collection hierarchy.
----------------------------------------------------------------------------------
What is the difference between an Array, ArrayList and a List?

An Array (System.Array) is fixed in size once it is allocated. You can't add items to it or remove items from it. Also, all the elements must be the same type. As a result, it is type safe, and is also the most efficient of the three, both in terms of memory and performance. Also, System.Array supports multiple dimensions (i.e. it has a Rank property) while List and ArrayList do not (although you can create a List of Lists or an ArrayList of ArrayLists, if you want to).

An ArrayList is a flexible array which contains a list of objects. You can add and remove items from it and it automatically deals with allocating space. If you store value types in it, they are boxed and unboxed, which can be a bit inefficient. Also, it is not type-safe.

A List<> leverages generics; it is essentially a type-safe version of ArrayList. This means there is no boxing or unboxing (which improves performance) and if you attempt to add an item of the wrong type it'll generate a compile-time error.----------------------------------------------------------------------------------
18. What is difference between array and arraylist?

An ArrayList is resizable, where as, an array is not. ArrayList is a part of the Collection Framework. We can store any type of objects, and we can deal with only objects. It is growable.
Array is collection of similar data items. We can have array of primitives or objects. It is of fixed size. We can have multi dimensional arrays.
Array: can store primitive            ArrayList: Stores object only
Array: fix size                            ArrayList: resizable
Array: can have multi dimensional
Array: lang                                ArrayList: Collection framework
----------------------------------------------------------------------------------
19. Can you limit the initial capacity of vector in java?
Yes you can limit the initial capacity. We can construct an empty vector with specified initial capacity:
public vector(int initialcapacity)
----------------------------------------------------------------------------------
20. What method should the key class of Hashmap override?
The methods to override are equals() and hashCode().
----------------------------------------------------------------------------------
21. What is the difference between Enumeration and Iterator?
The functionality of Enumeration interface is duplicated by the Iterator interface. Iterator has a remove() method while Enumeration doesn't. Enumeration acts as Read-only interface, because it has the methods only to traverse and fetch the objects, where as using Iterator we can manipulate the objects also like adding and removing the objects. So Enumeration is used when ever we want to make Collection objects as Read-only.
--------------------------------------------------
22. What is the difference between List and List (not parametrized list and list parametrized by String) in Java ?
List stores Objects so every "get" from List has to cast object to desired type.
List stores objects of type String only so casting is not necessary. Generalization gives compilation time error checking.
---------------------------------------------------------
23. Can you write your own generic types in Java ?
Yes.
---------------------------------------------------------
24. What is a Comparator?
A comparison function, which imposes a total ordering on some collection of objects. Comparators can be passed to a sort method (such as Collections.sort) to allow precise control over the sort order. Comparators can also be used to control the order of certain data structures (such as TreeSet or TreeMap).
---------------------------------------------------------
25. Explain compareTo().
Often, it is not enough to simply know whether two strings are identical. For sorting applications, you need to know which is less than, equal to, or greater than the next. A string is less than another if it comes before the other in dictionary order. A string is greater than another if it comes after the other in dictionary order. The String method compareTo( ) serves this purpose.

It has this general form: int compareTo(String str)

Here, str is the String being compared with the invoking String. The result of the comparison is returned and is interpreted as shown here:

Value Meaning :
Less than zero- The invoking string is less than str.
Greater than zero- T he invoking string is greater than str.
Zero- The two strings are equal.
---------------------------------------------------------
26. Explain toString().
The toString() method is used when we need a string representation of an object. It is defined in Object class. This method can be overridden to customize the String representation of the Object.

Example:
Class PointCoordinates {

private int x, y;
 public PointCoordinates(int x, int y) { this.x = x;this.y = y; }
 public int getX() { return x; }
 public int getY() { return y; }
 public String toString()  // Custom toString() Method.

{  return "X=" + x + " " + "Y=" + y; }
}
public class ToStringDemo2 {
 public static void main(String args[]) {
  PointCoordinates point = new PointCoordinates(10, 10);
  System.out.println(point);
  String s = point + " testing";
  System.out.println(s); }}

27.Why use an ArrayList instead of a Vector?

All methods of the Vector class are synchronized. It is safe to access a Vector object from two threads. But if you only access a vector from a single thread—by far the more common case—your code wastes quite a bit of time with synchronization. In contrast, the ArrayList methods are not synchronized. We recommend that you use an ArrayList instead of a Vector whenever you don't need synchronization.

general

2010-05-01T11:39:00.001-07:00

Object-Oriented Programming Concepts

What Is an Object?

An object is a software bundle of related state and behavior. Software objects are often used to model the real-world objects that you find in everyday life.

What Is a Class?

A class is a blueprint or prototype from which objects are created.

What Is an Interface?

An interface is a contract between a class and the outside world. When a class implements an interface, it promises to provide the behavior published by that interface.

What Is a Package?

A package is a namespace for organizing classes and interfaces in a logical manner. Placing your code into packages makes large software projects easier to manage.

-------------------------------------------------------------------------------------------------------------

Source Code Comments

Three styles of comment notation are used in Java.

-Any text between "//" and the end of the line is a comment.

-Text starting with "/*" and terminated with "*/" is used to make multiple-line comments.

-The special form starting with "/**" and terminated with "*/" is used to create comments that can be processed by the Javadoc program to produce HTML-formatted documentation.

-------------------------------------------------------------------------------------------------------------

Because any import statements must precede any class definitions, the required order for these primary

elements is as follows:

- 0 or 1 package declaration

- 0, 1, or many import statements

- 1 or many class definitions, but at most one public class definition.

-------------------------------------------------------------------------------------------------------------

Java keywords:

abstract default if private this boolean do implements protected throw break double import public throws byte else instanceof return transient case extends int short try catch final interface static void char finally long strictfp volatile class float native super while const for new switch

continue goto package synchronized

Reserved Word:I true, false, null, const, goto

----------------------------------------------------------------------------------

What are the Difference between Functions and Procedures?

Answer:

1. Functions are used for computations where as Procedures can be used for performing business logic

2. Functions MUST return a value, Procedures need not be.

3) Function parameters are always IN, no OUT is possible

4) Function returns 1 value only. Procedure can return multiple values(max. 1024)

5) We can select the fields from function.In the case of procdure we cannot select the fields.

6) Function do not return the images,text whereas stored procedures returns all data types.

-------------------------------------------------------------------------------------------------------------
How to swap two variables, without using third variable ?
Let the variable be a and b. Then

a=a*b;
b=a/b;
a=a/b;

-------------------------------------------------------------------------------------------------------------

Package Visiblity:

Visibility of a class controls the ability of other classes to create objects or gain access to the

variables and methods in the class. There are various types of visibility:

 Public visibility-A class, variable, or method declared public can be used by any class in

the program.

 Protected visibility-A variable or method declared protected can be used only by classes in

the same package or in a derived class in the same or a different package.

 Default, or package, visibility-If none of the visibility keywords are used, the item is said

to have package visibility, meaning that only classes in the same package can use it.

 Private visibility-The private keyword is not used with classes, only with variables and

methods. A private variable or method can be used within a class only.

-------------------------------------------------------------------------------------------------------------

Identifiers

Words used in programs to name variables, classes, methods, or labels are identifiers and are subject to

strict rules. None of the Java reserved words may be used as identifiers. An identifier can begin with a

letter, a dollar sign, or an underscore character.

The compiler generates an error if you try to use a digit or any punctuation other than the dollar sign and underscore to start an identifier. Identifiers are case sensitive.

-------------------------------------------------------------------------------------------------------------

Array:

Examples of array declarations:

1. int[] counts ; 2. String names[] ; 3. boolean flags[][] ;

Statement 1 declares that the variable counts is an array of int primitives.

Statement 2 declares that the variable names is an array of references to String objects.

Statement 3 declares that the variable flags is a two-dimensional array of boolean primitives.

Note that in these statements, I have not set the size of the arrays, and no memory has been allocated for the array items.

Creating an Array

The size of an array is fixed when it is created with the new operator or with special combined declaration

and initialization statements.

Here are examples of creating some arrays :

1. counts = new int[20] ; // assuming counts was declared int[]

2. String names[] = new String[100] ; // combines declaration and creation

3. boolean[][] flags = new boolean[8][8] ;

When arrays of primitives are created, they are filled with the default values: zero for numerics and false

for booleans. Reference variable arrays, on the other hand, are filled with the special value null. After you

have created an array, you can use the length variable to find out the number of elements the array has.

Initializing an Array

Arrays of primitives are automatically initialized to the default values, but reference variable arrays contain

references to objects only after you create each individual object. In other words, there is no way to "bulk"

initialize. In the following code, statement 1 declares and creates an array of Point objects, but there are no

objects in the array until statement 2 runs. Statement 3 illustrates use of the length variable belonging to the

array.

1. Point spots[] = new Point[20];

2. for(int i = 0 ; i < 20 ; i++){spots[i] = new Point(i,0);}

3. int count = spots.length ;

-------------------------------------------------------------------------------------------------------------

Increment and Decrement

When an operator appears in a larger expression, the order in which the modification occurs depends on the position of the operator, as shown in the following code fragment:

1. int x = 5 ;

2. int y = x++ ; // y gets the value 5, before incrementing x

3. int y2 = ++x ; // y2 gets the value 7, after incrementingstatic variables, and variables declared inside code blocks.

-------------------------------------------------------------------------------------------------------------

Here is a summary of the different configurations of nested classes:

 Nested static class—A named class declared static. It can directly access only static variables and methods. It is considered a top-level class.

 Nested interface—A named interface, declared as a static member of a class, typically used for defining methods used to access the enclosing class.

 Inner class (member)—A named class defined as a member of the enclosing class. It must be associated with an instance of the enclosing class. There can be multiple member inner classes in an enclosing class. Member inner classes can be declared as public, private, protected, final, or abstract, but they cannot have the same name as any enclosing class.

 Inner class (local)—A named class defined in a code block in a method of the enclosing class. The inner class can access local variables in the method and parameters passed to the method only if the variables are declared final. As with a local variable, the inner class cannot be accessed outside the code block; in other words, the scope of the class is confined to the code block.

 Inner class (anonymous)—A class defined inside a single expression, having no name or constructor method. These classes can access local variables in the method and parameters passed to the method only if they are declared final.

XML Answers

2010-04-30T22:13:00.000-07:00

1.What is XML?

Extensible Markup Language (XML) is the universal language for data on the Web
XML is a technology which allows us to create our own markup language.
XML documents are universally accepted as a standard way of representing information in platform and language independent manner.
XML is universal standard for information interchange.
XML documents can be created in any language and can be used in any language.

----------------------------------------------------------------------------------
2.What is the difference between XML and HTML?

XML is no way clashes with HTML, since they are for two different purposes.

HTML:
-HTML is for displaying purpose.
-HTML is used to mark up text so it can be displayed to users.
-HTML describes both structure and appearance.
-HTML uses a fixed, unchangeable set of tags

XML:
-XML is for data representation.
- XML is used to mark up data so it can be processed by computers.
- XML describes only content, or “meaning”.
- In XML, you make up your own tags

---------------------------------------------------------------------------------
3.What are the benefits of XML?

There are many benefits of using XML on the Web :

Simplicity- Information coded in XML is easy to read and understand, plus it can be processed easily by computers.
Openness- XML is a W3C standard, endorsed by software industry market leaders.
Extensibility - There is no fixed set of tags. New tags can be created as they are needed.
Self-description- In traditional databases, data records require schemas set up by the database administrator. XML documents can be stored without such definitions, because they contain meta data in the form of tags and attributes.
Contains machine-readable context information- Tags, attributes and element structure provide context information that can be used to interpret the meaning of content, opening up new possibilities for highly efficient search engines, intelligent data mining, agents, etc.
Separates content from presentation- XML tags describe meaning not presentation. The motto of HTML is: "I know how it looks", whereas the motto of XML is: "I know what it means, and you tell me how it should look." The look and feel of an XML document can be controlled by XSL style sheets, allowing the look of a document to be changed without touching the content of the document. Multiple views or presentations of the same content are easily rendered.
Supports multilingual documents and Unicode-This is important for the internationalization of applications.
Facilitates the comparison and aggregation of data - The tree structure of XML documents allows documents to be compared and aggregated efficiently element by element.
Can embed multiple data types - XML documents can contain any possible data type - from multimedia data (image, sound, video) to active components (Java applets, ActiveX).
Can embed existing data - Mapping existing data structures like file systems or relational databases to XML is simple. XML supports multiple data formats and can cover all existing data structures and .
Provides a 'one-server view' for distributed data - XML documents can consist of nested elements that are distributed over multiple remote servers. XML is currently the most sophisticated format for distributed data - the World Wide Web can be seen as one huge XML database.

---------------------------------------------------------------------------------
4.What is a well-formed XML document?

If a document is syntactically correct it can be called as well-formed XML documents. A well-formed document conforms to XML's basic rules of syntax:

Every open tag must be closed.
The open tag must exactly match the closing tag: XML is case-sensitive.
All elements must be embedded within a single root element.
Child tags must be closed before parent tags.
A well-formed document has correct XML tag syntax, but the elements might be invalid for the specified document type.

---------------------------------------------------------------------------------
5.What is a valid XML document?

If a document is structurally correct then it can be called as valid XML documents. A valid document conforms to the predefined rules of a specific type of document:

These rules can be written by the author of the XML document or by someone else.
The rules determine the type of data that each part of a document can contain.

Note:Valid XML document is implicitly well-formed, but well-formed may not be valid

---------------------------------------------------------------------------------
6.What is the structure of XML document ?

Figure 1: XML Structure

7.What is a Processing Instruction in XML?

A ProcessingIntruction is the information which we would like to give to application. Through a ProcessingInstruction an application would get idea about how to process the document. A ProcessingInstruction can appear anywhere and any no. of times in a document.

---------------------------------------------------------------------------------
8.How does the XML structure is defined?

XML document will have a structure which has to be defined before we can create the documents and work with them. The structural rules can be defined using many available technologies, but the following are popular way of doing so-

Document Type Definition (DTD)
Schema

---------------------------------------------------------------------------------
9.What is DTD?

A Document Type Definition (DTD) defines the legal building blocks of an XML document. It defines rules for a specific type of document, including:

Names of elements, and how and where they can be used
The order of elements
Proper nesting and containment of elements
Element attributes

To apply a DTD to an XML document, you can:

Include the DTD's element definitions within the XML document itself.
Provide the DTD as a separate file, whose name you reference in the XML document.

---------------------------------------------------------------------------------
10.What is XML Schema?

An XML Schema describes the structure of an XML instance document by defining what each element must or may contain.XML Schema is expressed in the form of a separate XML file.

XML Schema provides much more control on element and attribute datatypes.
Some datatypes are predefined and new ones can be created.

schema  xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    :element  name="test">
       :complexType>

Figure 2: XML Schema

11.What are differences between DTDs and Schema?

DTD:
-DTDs follow SGML syntax.
-In DTD everything is treated as text.
-Relationships is not possible in DTD without invalidating existing documents.
-Grouping of elements and attributes is not possible in DTD.
-It is not possible to specify an upper limit of an element in DTDs.

Schema:
-Schema document is an XML document i.e.the structure of an XML document is specified by another XML document.
-Schema supports variety of dataTypes similar to programming language.
-In Schema, It is possible to inherit and create relationship among elements.
-In Schema, It is possible to group elements and attributes so that they can be treated as single logical unit.
-In Schemas, it is possible to specify an upper limit for the number of occurrences of an element.
---------------------------------------------------------------------------------

12.What is a Complex Element?

A complex element is an XML element that contains other elements and/or attributes.
There are four kinds of complex elements:

empty elements
elements that contain only other elements
elements that contain only text
elements that contain both other elements and text

---------------------------------------------------------------------------------
13.What is a Simple Element?

A simple element is an XML element that can contain only text.

A simple element cannot have attributes
A simple element cannot contain other elements
A simple element cannot be empty
However, the text can be of many different types, and may have various restrictions applied to it

---------------------------------------------------------------------------------
14.What are namespaces? Why are they important?

A simple element is an XML element that can contain only text.

Namespaces are a simple and straightforward way to distinguish names used in XML documents, no matter where they come from.
XML namespaces are used for providing uniquely named elements and attributes in an XML instance
They allow developers to qualify uniquely the element names and relationships and make these names recognizable, to avoid name collisions on elements that have the same name but are defined in different vocabularies.
They allow tags from multiple namespaces to be mixed, which is essential if data is coming from multiple sources.

Example: a bookstore may define the . Namespaces help define this distinction clearly.

Note: a) Every namespace has a unique name which is a string. To maintain the uniqueness among namespaces a IRL is most preferred approach, since URLs are unique.

   b) Except for no-namespace Schemas, every XML Schema uses at least two namespaces:
                1.the target namespace.
                2. The XMLSchema namespace (http://w3.org/2001/XMLSchema)

---------------------------------------------------------------------------------
15.What are the ways to use namespaces?

There are two ways to use namespaces:

Declare a default namespace
Associate a prefix with a namespace, then use the prefix in the XML to refer to the namespace.

---------------------------------------------------------------------------------
16.What is the relevance of ElementFormDefault attribute in the Schema?

ElementFormDefault indicates whether or not locally declared elements must be qualified by the target namespace in an instance document. ElementFormDefault attribute in the Schema has the following relevance:

Qualified: Each and every element of the Schema must be qualified with the namespace in the instance document.
Unqualified: means only globally declared elements must be qualified with there namespace and not the local elements.

---------------------------------------------------------------------------------
17.What is XML parser?

An XML parser is a piece of software which can do following:

Check for well-formedness
Validate the document
Allows us to read, create or modify existing XML documents

Note: Parser is piece of software provided by vendors. An XML parser is built in Java runtime from JDK 1.4 onwards

---------------------------------------------------------------------------------
18.What is DOM?

The Document Object Model (DOM) is a platform and language-independent standard object model for representing XML and related formats. DOM is standard API which is not specific to any programming language. DOM represents an XML document as a tree model. The tree model makes the XML document hierarchal by nature. Each and every construct of the XML document is represented as a node in the tree.

---------------------------------------------------------------------------------
19.What is SAX?

SAX-Simple API for XML processing. SAX provides a mechanism for reading data from an XML document. It is a popular alternative to the Document Object Model (DOM).SAX provides an event based processing approach unlike DOM which is tree based.

---------------------------------------------------------------------------------
20.What are the interfaces of SAX?

The interfaces of SAX are:

DocumentHandler- is used for getting event notification relating to a document.
DTDHandler- is implemented to get the notifications related to declarations in DTD like entities and notations
EntityResolver- is used for reading external entities.
ErrorHandler- is used for handling error related notifications.

---------------------------------------------------------------------------------
21.What is the difference between SAX parser and DOM parser?

SAX	DOM
A SAX parser takes the occurrences of components of an input document as events (i.e., event based processing), and tells the client what it reads as it reads through the input document.	A DOM parser creates a tree structure in memory from an input document and then waits for requests from client.
No navigation possible (top to bottom only once)	Whereas, we can navigate the DOM tree in any direction, any no. of times.
We cannot modify the document content in SAX	We can modify the document content in DOM
A SAX parser serves the client application always only with pieces of the document at any given time.	A DOM parser always serves the client application with the entire document no matter how much is actually needed by the client.
A SAX parser, however, is much more space efficient in case of a big input document	A DOM parser is space inefficient when the document is huge.
Use SAX parser when Input document is too big for available memory. When only a part of the document is to be read and we create the data structures of our own. If you use SAX, you are using much less memory and performing much less dynamic memory allocation.	Use DOM when Your application has to access various parts of the document and using your own structure is just as complicated as the DOM tree. Your application has to change the tree very frequently and data has to be stored for a significant amount of time.

---------------------------------------------------------------------------------
22.What is a CDATA section in XML?

CDATA Sections are used to escape blocks of text containing characters which would otherwise be recognized as markup. All tags and entity references are ignored by an XML processor that treats them just like any character data. CDATA blocks have been provided as a convenience measure when you want to include large blocks of special characters as character data, but you do not want to have to use entity references all the time.

---------------------------------------------------------------------------------
23.What is XSL?

eXtensible Stylesheet Language(XSL) deals with most displaying the contents of XML documents.XSL consists of three parts:

XSLT - a language for transforming XML documents
XPath - a language for navigating in XML documents
XSL-FO - a language for formatting XML documents

---------------------------------------------------------------------------------
24.How is XSL different from Cascading Style Sheets? Why is a new Stylesheet language needed?

XSL is compatible with CSS and is designed to handle the new capabilities of XML that CSS can't handle. XSL is derived from Document Style Semantics and Specification Language (DSSSL), a complex Stylesheet language with roots in the SGML community. The syntax of XSL is quite different from CSS, which could be used to display simple XML data but isn't general enough to handle all the possibilities generated by XML. XSL adds the capability to handle these possibilities. For instance, CSS cannot add new items or generated text (for instance, to assign a purchase order number) or add a footer (such as an order confirmation). XSL allows for these capabilities.

---------------------------------------------------------------------------------
25.What is XSLT?

eXtensible Stylesheet Language Transformation (XSLT) deals with transformation of one XML document into XHTML documents or to other XML documents. XSLT uses XPath for traversing an XML document and arriving at a particular node.

Figure 3: XSLT

26.What is the role of XSL transformer?

An XSL transformer will transform in the following way:

The source tree is obtained by parsing in a normal XML style
The transformation is now applied to the source with the help of information available in Stylesheet.

---------------------------------------------------------------------------------
27.What is the structure of XSLT?

Figure 4: XSLT Structure

---------------------------------------------------------------------------------
28.What is XSL template?
Template specifies transformation rules. A Stylesheet document can be made up of at least one template, which acts as an entry point. Every template uniquely identifies a particular node in the source tree.
---------------------------------------------------------------------------------
29.What is XPath?

XPath is an expression language used for addressing parts of an XML document. XPath is used to navigate through elements and attributes in an XML document.

---------------------------------------------------------------------------------
30.What is XSL-FO?

XSL-FO deals with formatting XML data. This can be used for generating output in a particular format like XML to PDF, XML to DOC, etc.

---------------------------------------------------------------------------------
31.How XSL-FO Works (or) How would you produce PDF output using XSL’s?

Figure 5: XSL-FO

RMI Answers

2010-04-30T20:41:00.000-07:00

1. What is RMI?
Answer: Java Remote Method Invocation (Java RMI) enables the programmer to create distributed Java technology-based to Java technology-based applications, in which the methods of remote Java objects can be invoked from other Java virtual machines, possibly on different hosts. RMI uses object serialization to marshal and unmarshal parameters and does not truncate types, supporting true object-oriented polymorphism.
-----------------------------------------------------------------
2. How many types of protocol implementations does RMI have?
Answer: RMI has at least three protocol implementations:
- Java Remote Method Protocol(JRMP),
- Internet Inter ORB Protocol(IIOP),
- Jini Extensible Remote Invocation(JERI).
These are alternatives, not part of the same thing, All three are indeed layer 6 protocols from the earlier OSI reference model.
-----------------------------------------------------------------
3. Does RMI-IIOP support dynamic downloading of classes?
Answer: No, RMI-IIOP doesn't support dynamic downloading of the classes as it is done with CORBA in DII (Dynamic Interface Invocation).Actually RMI-IIOP combines the usability of Java Remote Method Invocation (RMI) with the interoperability of the Internet Inter-ORB Protocol (IIOP).So in order to attain this interoperability between RMI and CORBA,some of the features that are supported by RMI but not CORBA and vice versa are eliminated from the RMI-IIOP specification.
-----------------------------------------------------------------
4. Does RMI-IIOP support code downloading for Java objects sent by value across an IIOP connection in the same way as RMI does across a JRMP connection?
Answer: Yes. The JDK 1.2 support the dynamic class loading.
-----------------------------------------------------------------
5. Can RMI and Corba based applications interact ?
Answer Yes they can. RMI is available with IIOP as the transport protocol instead of JRMP.
-----------------------------------------------------------------
6. Assume an application needs security permissions granted before the application can talk to the database. How do you go about setting the permissions? Give an example of setting the permission in Tomcat and stand alone java program.
Answer:

In Tomcat:
Add security permission to catalina.policy file located under /conf/
Add the following lines:
grant codeBase "file:${catalina.home}/webapps/MyContext/-"
{
permission java.security.AllPermission;
};

In stand alone java application:
Create a .policy file that points to the code base where the application resides.
grant codebase "file:c:/source/java/-"
{
permission java.security.AllPermission;
};

java -Djava.security.policy=.policy com.test.MyClass

JMS Answers

2010-04-30T10:19:00.000-07:00

Click Here for a tutorial on Java Messaging Services.

1. How may messaging models does JMS provide for and what are they?
Answer: The Java Message Service (JMS) API is a messaging standard that allows application components based on the Java 2 Platform, Enterprise Edition (J2EE) to create, send, receive, and read messages. It enables distributed communication that is loosely coupled, reliable, and asynchronous.

JMS provide for two messaging models: publish-and-subscribe and point to-point queuing.
-----------------------------------------------------------------
2. What is messaging?
Answer: Messaging is a mechanism by which data can be passed from one application to another application.
-----------------------------------------------------------------
3. What is point-to-point messaging?
Answer: With point-to-point message passing the sending application/client establishes a named message queue in the JMS broker/server and sends messages to this queue. The receiving client registers with the broker to receive messages posted to this queue. There is a one-to-one relationship between the sending and receiving clients.
-----------------------------------------------------------------
4. Can two different JMS services talk to each other? For instance, if A and B are two different JMS providers, can Provider A send messages directly to Provider B? If not, then can a subscriber to Provider A act as a publisher to Provider B?
Answer: The answers are NO to the first question and YES to the second.

The JMS specification does not require that one JMS provider be able to send messages directly to another provider. However, the specification does require that a JMS client must be able to accept a message created by a different JMS provider, so a message received by a subscriber to Provider A can then be published to Provider B. One caveat is that the publisher to Provider B is not required to handle a JMSReplyTo header that refers to a destination that is specific to Provider A.
-----------------------------------------------------------------
5. What is the advantage of persistent message delivery compared to non-persistent delivery?
Answer: If the JMS server experiences a failure, for example, a power outage, any message that it is holding in primary storage potentially could be lost. With persistent storage, the JMS server logs every message to secondary storage. (The logging occurs on the front end, that is, as part of handling the send operation from the message producing client.) The logged message is removed from secondary storage only after it has been successfully delivered to all consuming clients.
-----------------------------------------------------------------
6. How is a java object message delivered to a non-java Client?
Answer: It is according to the specification that the message sent should be received in the same format. A non-java client cannot receive a message in the form of java object. The provider in between handles the conversion of the data type and the message is transferred to the other end.
-----------------------------------------------------------------
7. What is MDB and what is it special?
Answer: MDB is Message driven bean, which very much resembles the Stateless session bean. The incoming and out going messages can be handled by the Message driven bean. The ability to communicate asynchronously is the special feature about the Message driven bean.
-----------------------------------------------------------------
8. Give an example of using the publish/subscribe model.
Answer: JMS can be used to broadcast shutdown messages to clients connected to the Weblogic server on a module wise basis. If an application has six modules, each module behaves like a subscriber to a named topic on the server.
-----------------------------------------------------------------
9. What is the difference between the Mailing and Messaging?
Answer: Java Mailing is the set of APIs that primarily concerns with the sending of Mail messages through the standard mail protocols. Messaging is the way of communicating to the remote machines using Message Oriented Middlewares. Message Oriented Middlewares do not use mailing internally for communication. They create their own channels for communication.
-----------------------------------------------------------------
10. What are the types of messaging?
Answer: There are two kinds of Messaging.
Synchronous Messaging:
Synchronous messaging involves a client that waits for the server to respond to a message.
Asynchronous Messaging:
Asynchronous messaging involves a client that does not wait for a message from the server. An event is used to trigger a message from a server.
-----------------------------------------------------------------
11. What is publish/subscribe messaging?
Answer: With publish/subscribe message passing the sending application/client establishes a named topic in the JMS broker/server and publishes messages to this queue. The receiving clients register via the broker to messages by topic; every subscriber to a topic receives each message published to that topic. There is a one-many relationship between the publishing client and the subscribing clients.
-----------------------------------------------------------------
12. Why doesn't the JMS API provide end-to-end synchronous message delivery and notification of delivery?
Answer: Some messaging systems provide synchronous delivery to destinations as a mechanism for implementing reliable applications. Some systems provide clients with various forms of delivery notification so that the clients can detect dropped or ignored messages. This is not the model defined by the JMS API.

JMS API messaging provides guaranteed delivery via the once-and-only once delivery semantics of persistent messages. In addition, message consumers can insure reliable processing of messages by using either CLIENT_ACKNOWLEDGE mode or transacted sessions. This achieves reliable delivery with minimum synchronization and is the enterprise messaging model most vendors and developers prefer.
The JMS API does not define a schema of systems messages (such as delivery notifications). If an application requires acknowledgment of message receipt, it can define an application-level acknowledgment message.
-----------------------------------------------------------------
13. What are the core JMS-related objects required for each JMS-enabled application?
Answer: Each JMS-enabled client must establish the following:
- A connection object provided by the JMS server (the message broker).
- Within a connection, one or more sessions, which provide a context for message sending and receiving.
- Within a session, either a queue or topic object representing the destination (the message staging area) within the message broker.
- Within a session, the appropriate sender or publisher or receiver or subscriber object (depending on whether the client is a message producer or consumer and uses a point-to-point or publish/subscribe strategy, respectively).
-Within a session, a message object (to send or to receive).
-----------------------------------------------------------------
14. What are the various message types supported by JMS?
Answer:
-Stream Messages: Group of Java Primitives
-Map Messages: Name Value Pairs.
-Name being a string
-Value being a java primitive
-Text Messages: String messages (since being widely used a separate messaging Type has been supported)
Object Messages: Group of serialize able java object
Bytes Message: Stream of uninterrupted bytes.
-----------------------------------------------------------------
15. What is the role of the JMS Provider?
Answer: The JMS provider handles security of the messages, data conversion and the client triggering. The JMS provider specifies the level of encryption and the security level of the message, the best data type for the non-JMS client.
-----------------------------------------------------------------
16. How does a typical client perform the communication?
Answer:
1. Use JNDI to locate administrative objects.
1a. Locate a single ConnectionFactory object.
1b. Locate one or more Destination objects.
2. Use the ConnectionFactory to create a JMS Connection.
3. Use the Connection to create one or more Session(s).
4. Use a Session and the Destinations to create the MessageProducers and MessageConsumers needed.
5. Perform your communication.
-----------------------------------------------------------------
17.Give an example of using the point-to-point model.
Answer: The point-to-point model is used when the information is specific to a single client. For example, a client can send a message for a print out, and the server can send information back to this client after completion of the print job.
-----------------------------------------------------------------
18. Question How does the application server handle the JMS Connection?
Answer:
- Application server creates the server session and stores them in a pool.
- Connection consumer uses the server session to put messages in the session of the JMS.
- Server session is the one that spawns the JMS session.
- Applications written by application programmers creates the message listener.

JTA Answers

2010-04-30T09:59:00.000-07:00

1. What is JTA?
Answer: Java Transaction API (JTA) specifies standard Java interfaces between a transaction manager and the parties involved in a distributed transaction system: the resource manager, the application server, and the transactional applications.
-----------------------------------------------------------------
2. Why would a client application use JTA transactions?
Answer: One possible example would be a scenario in which a client needs to employ two (or more) session beans, where each session bean is deployed on a different EJB server and each bean performs operations against external resources (for example, a database) and/or is managing one or more entity beans. In this scenario, the client's logic could required an all-or-nothing guarantee for the operations performed by the session beans; hence, the session bean usage could be bundled together with a JTA UserTransaction object.

In the previous scenario, however, the client application developer should address the question of whether or not it would be better to encapsulate these operations in yet another session bean, and allow the session bean to handle the transactions via the EJB container. In general, lightweight clients are easier to maintain than heavyweight clients. Also, EJB environments are ideally suited for transaction management.

Context c = new InitialContext(); UserTransaction ut = (UserTransaction) c.lookup("java:comp/UserTransaction");
ut.begin(); // perform multiple operations...
ut.comm

JNDI Answers

2010-04-30T09:25:00.000-07:00

1. What is JNDI?
Answer: The Java Naming and Directory Interface (JNDI) is part of the Java platform, providing applications based on Java technology with a unified interface to multiple naming and directory services.
-----------------------------------------------------------------
2.What protocols does JNDI provide an interface to?
Answer: JNDI itself is independent of any specific directory access protocol. Individual service providers determine the protocols to support. JNDI supports popular protocols, such as LDAP (Light weight Directory Access Protocol) , NDS(Netscape Directory Service), DNS(Domain Naming Service), and NIS(Network Information Service), supplied by different vendors.
-----------------------------------------------------------------
3. What is Context and InitialContext?
Answer: A context represents a set of bindings within a naming service. A context object provides the methods for binding names to objects and unbinding names from objects, for renaming objects, and for listing the bindings. JNDI performs all naming operations relative to a context.
The JNDI specification defines an InitialContext class. This class is instantiated with properties that define the type of naming service in use (such as provider URL, security, ID and password to use when connecting).
-----------------------------------------------------------------
4. What's the difference between JNDI lookup(), list(), listBindings(), and search()?
Answer:
-lookup() attempts to find the specified object in the given context.
i.e., it looks for a single, specific object and either finds it in the current context or it fails.
-list() attempts to return an enumeration of all of the Name-ClassPair's of all of the objects in the current context. i.e., it's a listing of all of the objects in the current context but only returns the object's name and the
name of the class to which the object belongs.
-listBindings() attempts to return an enumeration of the Binding's of all of the objects in the current context. i.e., it's a listing of all of the objects in the current context with the object's name, its class name, and a reference to the object itself.
-search() attempts to return an enumeration of all of the objects matching a given set of search criteria. It can search across multiple contexts (or not). It can return whatever attributes of the objects that you desire. It's by far the most complex and powerful of these options but is also the most expensive.
-----------------------------------------------------------------
5. Name the components of JNDI.
Answer:
Naming Interface- The naming interface organizes information hierarchically and maps human-friendly names to addresses or objects that are machine-friendly. It allows access to named objects through multiple namespaces.
Directory Interface- JNDI includes a directory service interface that provides access to directory objects,which can contain attributes, thereby providing attribute-based searching and schema support.
Service Provider Interface- JNDI comes with the SPI, which supports the protocols provided by third parties.
-----------------------------------------------------------------
6. Is JNDI a protocol? Where is it used?
Answer: Yes. JNDI is a protocol.
-HotJava Views 1.1 is using JNDI to access LDAP.
-Enterprise APIs such as Enterprise JavaBeans, Java Message Service, JDBC 2.0 make use of JNDI to for their naming and directory needs.
-RMI over IIOP applications can use JNDI to access the CORBA (COS) naming service.

JNI Answers

2010-04-30T09:12:00.001-07:00

1. What are native methods? How do you use them?
Answer: Native methods are methods written in other languages like C, C++, or even assembly language. You can call native methods from Java using JNI.