Monthly Archives: February 2016

What is an Abstract Class in Java?

In Java every category described is automatically tangible category, but if we want to apply subjective category, we need to use the subjective keyword and key phrase before the category to indicate a category as subjective class

As per vocabulary, Abstraction is the quality of working with concepts rather than activities. for example when you consider the situation of e-mail, complicated information such as what happens soon you deliver an e-mail, the process your e-mail server uses are invisible from the consumer, therefore to deliver an e-mail you just need to type the material, discuss the deal with of the recipient and just click deliver.

java programme

like sensible in Item focused development Abstraction is an activity procedure for concealing the execution information from the consumer, only the performance will be offered to the consumer. In simple terms customer will have the information on what the item does instead of how it does it.

In Java Abstraction is obtained using Abstract sessions, and Connections.

Abstract Class

A category which contains the subjective keyword and key phrase in its announcement is known as subjective category.

Abstract sessions may or may not contain subjective techniques ie., techniques with out body ( community gap get(); )

But, if a category have at least one subjective technique, then the category must be announced subjective.

If a category is said subjective it cannot be instantiated.

To use an subjective category you have to acquire it from another category, offer implementations to the subjective techniques in it.

If you acquire an subjective category you have to give implementations to all the subjective techniques in it.

Example

This area provides you an example of the subjective category to develop an subjective category just use the subjective keyword and key phrase before the category keyword and key phrase, in the category announcement .

Subjective Methods:

If you want a category to contain a particular technique but you want the real execution of that technique to be driven by kid sessions, you can announce the process in parents category as abstract.

abstract keyword and key phrase is used to announce the process as abstract.

You have to put the abstract keyword and key phrase before the process name in the process announcement.

An abstract technique contains an approach trademark, but no technique body system.

Instead of wavy tooth braces an abstract technique will have a semoi digestive tract ( ; ) at the end.

Below given is an example of the abstract technique.

Don't be shellfish...Email this to someonePrint this pageTweet about this on TwitterShare on StumbleUponShare on TumblrShare on LinkedInShare on RedditDigg thisShare on Google+Pin on PinterestShare on FacebookBuffer this page

What is Java and XML Tutorial?

XML is the acronym for Extensible Markup Language and is a recognised information return structure. XML was described 1998 by the Globe Extensive Web Range (W3C).

java xml

An XML papers comprises of components, each factor has a begin tag, material and an end tag. An XML papers must have exactly one main factor (i.e., one tag which clos the staying tags). XML distinguishes between investment and non-capital characters.

An XML data file must be “well-formed”.

A well-formed XML data file must implement to the following conditions:

An XML papers always begins with a prolog (see below for an description of what a prolog is)

Every starting tag has a ending tag.

All labels are absolutely stacked.

An XML data file is known as legitimate if it is well-formed and if it is contains a connect to an XML schema and is legitimate according to the schema.

1.2. Evaluation of XML to other formats

XML has the following features which creates handling it via laptop or software applications not at all hard than the binary or unstructured format:

XML is simply text

XML symbolizes information without interpreting how the information should be displayed

XML can be become other types via XSL

XML can be quickly prepared via conventional parsers

XML data files are hierarchical

On lack of is XML structure is relatively verbose, e.g., if information is showed as XML the length of this information is relatively huge compared to other types. In the Online JSON or binary types are used to restore XML if the information throughput is significant.

1.3. XML Example

The following is a legitimate, well-formed XML data file.

<?xml
version="1.0"?>
<!--
This is a comment -->
<address>
  <name>Lars
</name>
  <street>
Test </street>
  <telephone
number= "0123"/>
</address

1.4. XML Elements

An XML papers always begins with a prolog which explains the XML computer file. This prolog can be little, e.g. <?xml version=”1.0″?> or can contain other details, e.g. the development, e.g. <?xml version=”1.0″ encoding=”UTF-8″ standalone=”yes” ?>

A tag which does not include any material is know as an “empty tag”. For example: <flag/>

Comments in XML are described as: <! COMMENT>

2. Java XML overview

The Java development terminology contains several techniques for handling and composing XML.

Older Java editions reinforced only the DOM API (Document Item Model) and the SAX (Simple API for XML) API.

In DOM you accessibility the XML papers over a product shrub. DOM can be used to create and look XML details.

SAX (Simple API for XML) is a Java API for successive studying of XML details. SAX can only study XML records. SAX provides an occasion motivated XML Processing following the Push-Parsing Design, e.g., you sign-up audience in the type of Handlers to the Parser and these are informed through call-back techniques.

Both DOM and Sax are mature APIs and I suggest not using them any longer.

Stax (Streaming API for XML) is an API with and composing XML Documents. It was presented in Java 6.0 and is regarded better than SAX and DOM.

Don't be shellfish...Email this to someonePrint this pageTweet about this on TwitterShare on StumbleUponShare on TumblrShare on LinkedInShare on RedditDigg thisShare on Google+Pin on PinterestShare on FacebookBuffer this page

What is Java StAX Parser in detail?

StAX is a JAVA centered API to parse XML papers similarly as SAX parser does. But there are two significant distinction between the two APIs

StAX is a PULL API where as SAX is a PUSH API. It indicates regarding StAX parser, customer system need to ask StAX parser to get details from XML whenever it needs but regarding SAX parser, customer system is needed to get details when SAX parser informs the consumer system that details are available.

java

StAX API can study as well as create XML records. Using SAX API, xml can be only be study.

Environment Setup

In to use StAX parser, you should have stax.jar in your application’s classpath. Acquire stax-1.2.0.jar.

Following are the functions of StAX API

Flows an XML papers from head to feet, acknowledging the wedding party that comprise a well-formed XML document

Tokens are prepared in the same purchase that they appear in the document

Reviews the system program the characteristics of wedding party that the parser has experienced as they occur

The system program provides an “event” audience which functions as an iterator and iterates over the occasion to get the needed details. Another audience available is “cursor” audience which functions as a suggestion to xml nodes.

As the activities are recognized, xml components can be recovered from the occasion item and can be prepared further.

When to use?

You should use a StAX parser when:

You can procedure the XML papers in a straight line style from the top down.

The papers is not greatly stacked.

You are handling a very huge XML papers whose DOM shrub would eat too much storage. Common DOM implementations use ten bytes of storage to signify one byte of XML.

The issue to be fixed includes only portion of the XML papers.

Information is available as soon as it is seen by the parser, so StAX can be useful for an XML papers that comes over a flow.

Disadvantages of SAX

We have no unique accessibility to an XML papers since it is prepared in a forward-only manner

If you need to monitor information the parser has seen or modify an purchase of products, you must create the program code and shop the information on your own

XMLEventReader Class

This category offer iterator of activities which can be used to iterate over activities as they happen while parsing the XML document

StartElement asStartElement() – used to recover value and functions of factor.

EndElement asEndElement() – known as at the end of a factor.

Figures asCharacters() – can be used to acquire characters such a CDATA, whitespace etc.

XMLEventWriter Class

This interface identifies indicates of making a meeting.

add(Event event) – Add occasion containing components to XML.

Don't be shellfish...Email this to someonePrint this pageTweet about this on TwitterShare on StumbleUponShare on TumblrShare on LinkedInShare on RedditDigg thisShare on Google+Pin on PinterestShare on FacebookBuffer this page

Java Developers are Helped to Create Microservices

Lightbend, formerly known as Typesafe, is providing microservices-based architectures to Java with its Lagom system.

Due in beginning Goal, Lagom is a microservices structure that reduces down to developing these microservices in Java. Designed on the Scala efficient terminology, free Lagom functions as an improvement atmosphere for handling microservices. APIs originally are offered for Java solutions, with Scala to follow.

he structure features Lightbend’s Akka middleware technological innovation as well as its ConductR microservices implementation device and Play Web structure. Applications are implemented to Lightbend’s professional Sensitive system for message-driven applications or via free Akka.

java

Lightbend recognizes microservices as generally combined, separated, single-responsibility solutions, each having its own data and easily consisting into bigger techniques. Lagom provides for asynchronous emails and event-sourcing, which is saving the case prior to particular declares in a meeting, organization authorities said.

Analyst Wayne Governor of RedMonk recognizes an opportunity for Lagom. “The Java group needs good resources for developing and handling microservices architectures,” he said. “Lagom is directly targeted at that space.”

Lagom would contest with the Springtime Start application system in some areas, according to Governor. “It is beginning for Lagom, but the design points appear sensible,” he mentioned. Typesafe was targeted on Scala, which was implemented in some sectors, such as financial solutions, but never became popular, he claims. “So is looking to take its encounters and pedaling and then get them to more generally appropriate with a Java-first technique.”

Remembering what the growth world was like in 1995 is no easy process. Object-oriented growth, for one, was a recognised but rarely used model, with much of what approved as so-called object-oriented programs being little more than renamed C rule that used >> instead of printf and sophistication instead of struct. The programs we had written those times regularly thrown out primary due to suggestion mathematics mistakes or ran out of storage due to leaking. Resource rule could hardly be ported between different editions of Unix. Running the same binary on different processor chips and operating-system was insane talk.

Java improved the situation dramatically. While platform-dependent, personally assigned, step-by-step C rule will continue to be with us for the next 20 years at least, Java shown this was a choice, not essential. For the first time, we started writing real manufacturing rule in a cross-platform, garbage-collected, object-oriented language; and we liked it … an incredible number of us. Different languages that have come after Java, specifically C#, have had to clear the new higher bar for designer efficiency that Java recognized.

Don't be shellfish...Email this to someonePrint this pageTweet about this on TwitterShare on StumbleUponShare on TumblrShare on LinkedInShare on RedditDigg thisShare on Google+Pin on PinterestShare on FacebookBuffer this page

What is so special about Java Collections Framework?

A selection — sometimes known as a package — is simply a product that categories several components into a single device. collections are used to store, recover, function, and fasten total information. Generally, they signify information items that type a natural team, such as a on-line poker hand (a selection of cards), a email listing (a selection of letters), or a phone listing (a applying of titles to phone numbers). If you have used the Java development terminology — or just about any other development terminology — you are already acquainted with collections.

What Is a collections Framework?

java collection

A collections structure is a specific structure for comprising and adjusting collections. All collections frameworks contain the following:

Interfaces: These are subjective information types that signify collections. Connections allow collections to be controlled individually of the information their reflection. In object-oriented ‘languages’, interfaces generally type a structure.

Implementations: These are the tangible implementations of the selection interfaces. In substance, they are recycleable information components.

Algorithms: These are the techniques that execute useful calculations, such as looking and organizing, on things that apply selection interfaces. The techniques are said to be polymorphic: that is, the same method can be used on many different implementations of the appropriate selection interface. In substance, techniques are recycleable performance.

Apart from the Java collections Framework, the best-known types of collections frameworks are the C++ Conventional Design Collection (STL) and Smalltalk’s selection structure. Traditionally, collections frameworks have been quite complicated, which provided them a popularity for having a extreme studying bend. We believe that the Java collections Framework smashes with this custom, as you’ll find out for yourself in this section.

Benefits of the Java collections Framework

The Java collections Framework provides the following benefits:

Decreases development effort: By offering useful information components and techniques, the collections Framework liberates you to focus on the important areas of your system rather than on the low-level “plumbing” required to succeed. By assisting interoperability among irrelevant APIs, the Java collections Framework liberates you from composing adaptor things or transformation program code to link APIs.

Improves system rate and quality: This collections Framework provides high-performance, high-quality implementations of useful information components and techniques. The various implementations of each interface are exchangeable, so applications can be easily updated by changing selection implementations. Because you’re free of the boredom of composing your own information components, you’ll have a longer period to invest in enhancing programs’ great quality and efficiency.

Allows interoperability among irrelevant APIs: The selection interfaces are the language by which APIs successfully pass collections back and forth. If my system management API offers a selection of node titles and if your GUI tool set desires a selection of line titles, our APIs will interoperate easily, even though they were published individually.

Don't be shellfish...Email this to someonePrint this pageTweet about this on TwitterShare on StumbleUponShare on TumblrShare on LinkedInShare on RedditDigg thisShare on Google+Pin on PinterestShare on FacebookBuffer this page

What is Polymorphism in Java?

Polymorphism is the capability of an item to take on many types. The most common use of polymorphism in OOP happens when a father or mother category referrals is used to make reference to a child category item.

Any Java item that can successfully pass more than one IS-A analyze is regarded to be polymorphic. In Java, all Java things are polymorphic since any item will successfully pass the IS-A analyze for their own kind and for the category Object.

It is important to know that the only possible way to access an item is through a referrals varying. A referrals varying can be of only one kind. Once announced, the kind of a referrals varying cannot be modified.

java

The referrals varying can be reassigned to other things given that it is not announced last. The kind of the referrals varying would figure out the methods that it can produce on the item.

A referrals varying can make reference to any item of its announced kind or any subtype of its announced kind. A referrals varying can be announced as a category or interface kind.

The term polymorphism indicates having many types. Generally, polymorphism happens when there is a structure of sessions and they are related by bequest.

C++ polymorphism signifies that a call to part operate will cause a different operate to be implemented based on the kind of item that creates the operate.

Consider the following example where basics category has been produced by other two classes:

#include <iostream> 
using namespace std;

 

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      int area()
      {
         cout << "Parent
class area :" <<endl;
         return 0;
      }
};
class Rectangle: public Shape{
   public:
      Rectangle( int a=0, int
b=0):Shape(a, b) { }
      int area ()
      { 
         cout <<
"Rectangle class area :" <<endl;
         return (width *
height); 
      }
};
class Triangle: public Shape{
   public:
      Triangle( int a=0, int
b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Triangle
class area :" <<endl;
         return (width * height
/ 2); 
      }
};
// Main function for the program
int main( )
{
   Shape *shape;
   Rectangle rec(10,7);
   Triangle  tri(10,5);

   // store the address of
Rectangle
   shape = &rec;
   // call rectangle area.
   shape->area();

   // store the address of
Triangle
   shape = &tri;
   // call triangle area.
   shape->area();

 

   return 0;
}

When
the above code is compiled and executed, it produces the following
result:
Parent class area
Parent
class area
Don't be shellfish...Email this to someonePrint this pageTweet about this on TwitterShare on StumbleUponShare on TumblrShare on LinkedInShare on RedditDigg thisShare on Google+Pin on PinterestShare on FacebookBuffer this page

The life Pattern of Multi Threading in Java

Java is a multi threaded development language which means we can develop several threaded system using Java. A several threaded system contains two or more parts that can run simultaneously and each part can handle different process simultaneously making maximum use of the available sources specially when your computer has several CPUs.

By meaning multi-tasking is when several procedures share common handling sources such as a CPU. Multi threads expands the idea of multi-tasking into programs where you can subdivide specific functions within a single program into individual discussions. Each of the discussions can run running in similar. The OS separates handling time not only among different programs, but also among each line within a software.

Multi threads enables you to write in a way where several activities can continue simultaneously in the same system.

Life Pattern of a Thread:

multithreading

A line goes through various procedures in its life-cycle. For example, a line comes into the world, began, operates, and then passes away. Following plan shows finish life-cycle of a line.

Java Thread

New: A new line begins its life-cycle in the new condition. It continues to be in this condition until the system begins the line. It is also known to as a created line.

Runnable: After a recently created line is began, the line becomes runnable. A line in this condition is considered to be performing its process.

Waiting: Sometimes, a line changes to the patiently waiting condition while the line stays for another line to perform an activity.A line changes back again to the runnable condition only when another line alerts the patiently waiting line to continue performing.

Timed waiting: A runnable line can enter the timed patiently waiting condition for a specified period of your energy. A line in this condition changes back again to the runnable condition when that period period ends or when the event it is awaiting happens.

Ended ( Deceased ): A runnable line goes into the terminated condition when it finishes its process or otherwise ends.

Thread Priorities:

Every Java line has a concern that helps the os determine the transaction in which discussions are planned.

Java line main concerns are in the range between MIN_PRIORITY (a continuous of 1) and MAX_PRIORITY (a continuous of 10). By standard, every line is given concern NORM_PRIORITY (a continuous of 5).

Threads with higher concern are more important to a system and should be assigned processer time before lower-priority discussions. However, line main concerns cannot guarantee the transaction in which discussions perform and very much system reliant.

Create Thread by Applying Runnable Interface:

If your category is designed to be implemented as a line then you can achieve this by implementing Runnable interface. You will need to follow three basic steps:

Step 1:

As a starting point you need to apply a run() technique provided by Runnable interface. This approach provides access point for the line and you will put you finish business reasoning inside this technique. Following is straightforward format of run() method:

public void run( )

Step 2:

At second phase you will instantiate a Thread item using the following constructor:

Thread(Runnable threadObj, Sequence threadName);

Where, threadObj is a clear case of a category that utilizes the Runnable interface and threadName is the name given to the new line.

Step 3

Once Thread item is created, you can begin it by contacting start( ) technique, which carries out a call to run( ) technique. Following is straightforward format of start() method:

void start( );

Don't be shellfish...Email this to someonePrint this pageTweet about this on TwitterShare on StumbleUponShare on TumblrShare on LinkedInShare on RedditDigg thisShare on Google+Pin on PinterestShare on FacebookBuffer this page

What is Java Remote Method Invocation?

The RMI (Remote Method Invocation) is an API that provides a procedure to develop allocated program in Java. The RMI allows an mind produce techniques on an item operating in another JVM.

The RMI provides distant interaction between the programs using two things stub and bones.

Understanding stub and skeleton

java

RMI uses stub and bones item for interaction with the distant item.

A distant item is an item whose method can be invoked from another JVM. Let’s comprehend the stub and bones objects:

stub

The stub is an item, functions as a entrance for the consumer part. All the confident demands are directed through it. It exists at the consumer part and symbolizes the distant item. When the owner creates method on the stub item, it does the following tasks:

  1. It triggers an association with (JVM),

  2. It creates and sends (marshals) the factors to the (JVM),

  3. It stays for the result

  4. It flows (unmarshals) the come back value or exemption, and

  5. It lastly, profits the value to the owner.

skeleton

The bones is an item, functions as a entrance for the server part item. All the inbound demands are directed through it. When the bones gets the inbound demand, it does the following tasks:

It flows the parameter for the distant method

It creates the process on the real distant item, and

It creates and sends (marshals) the outcome to the owner.

Understanding requirements for the allocated applications

If any system performs these tasks, it can be allocated system.

The applying need to locate the distant method

It need to deliver the communication with the distant things, and

The applying need to load the course explanations for the things.

The RMI system have all these features, so it is called the allocated system.

Steps to create the RMI program

The is given the 6 actions to create the RMI system.

  1. Make the distant interface

  2. Offer the execution of the distant interface

  3. Gather the execution category and build the stub and skeleton things using the rmic tool

  4. Begin the registry service by rmiregistry tool

  5. Make you should the distant application

  6. Make you should the client application

The (Java RMI) is a JAPI that works remote method invocation, the object-oriented comparative of remote procedure phone calls (RPC), with assistance for direct transfer of serialized Java classes and allocated rubbish collection.

The very first execution depends on (JVM) class reflection systems and it thus only facilitates making phone calls from one JVM to another. The method actual this Java-only execution is known as (JRMP).

In order to assistance code running in a non-JVM perspective, a CORBA edition was later developed.

Don't be shellfish...Email this to someonePrint this pageTweet about this on TwitterShare on StumbleUponShare on TumblrShare on LinkedInShare on RedditDigg thisShare on Google+Pin on PinterestShare on FacebookBuffer this page

What are the Significance of Java Generic Method?

It would be nice if we could create only one type manner in which could type the sun and rain in an Integer range, a Sequence range or a variety of any kind that supports ordering.

Java General techniques and generic classes enable developers to specify, with only one technique announcement, a set of relevant techniques or, with only one class announcement, a set of relevant kinds, respectively.

java generic

Generics also provide compile-time kind safety that allows developers to catch incorrect kinds at gather time.

Using Java General concept, we might create a plain means for organizing a variety of objects, then produce the generic technique with Integer arrays, Dual arrays, Sequence arrays and so on, to type the range components.

Generic Methods:

You can create only one generic technique announcement that can be called with justifications of different kinds. Based on the kinds of the justifications approved to the generic technique, the compiler handles each technique call properly. Following are the rules to define General Methods:

All generic technique conditions have a type parameter area delimited by position supports (< and >) that comes before the method’s come back kind ( < E > in the next example).

Each kind parameter area contains one or more kind factors divided by commas. A kind parameter, also known as a type varying, is an identifier that identifies a plain kind name.

The kind factors can be used to declare the come back kind and act as placeholders for the kinds of the justifications approved to the generic technique, which are known as actual kind justifications.

A generic method’s body is said like that of any other technique. Note that kind factors can represent only reference kinds, not basic kinds (like int, double and char).

Example:

Following example illustrates how we can print array of different type using a single Generic method:

public class GenericMethodTest
{
   // generic method printArray 
                       
   public static < E >
void printArray( E[] inputArray )
   {
      // Display array elements 
            
         for ( E element :
inputArray ){        
            System.out.printf(
"%s ", element );
         }
         System.out.println();
    }

    public static void main(
String args[] )
    {
        // Create arrays of
Integer, Double and Character
        Integer[] intArray = {
1, 2, 3, 4, 5 };
        Double[] doubleArray = {
1.1, 2.2, 3.3, 4.4 };
        Character[] charArray =
{ 'H', 'E', 'L', 'L', 'O' };

        System.out.println(
"Array integerArray contains:" );
        printArray( intArray  );
// pass an Integer array

        System.out.println(
"\nArray doubleArray contains:" );
        printArray( doubleArray
); // pass a Double array

        System.out.println(
"\nArray characterArray contains:" );
        printArray( charArray );
// pass a Character array
    } 
}

This would produce the following result:

Array integerArray contains:
1 2 3 4 5 6

Array doubleArray contains:
1.1 2.2 3.3 4.4 

Array characterArray contains:
H E
L L O
Don't be shellfish...Email this to someonePrint this pageTweet about this on TwitterShare on StumbleUponShare on TumblrShare on LinkedInShare on RedditDigg thisShare on Google+Pin on PinterestShare on FacebookBuffer this page

What is Exception Handling in Java?

The exception handling in coffee is one of the highly effective procedure to deal with the playback mistakes so that regular circulation of the applying can be managed.

In this site, we will find out about coffee exception, its kind and the distinction between examined and uncontrolled exclusions.

What is exception

java handling

Dictionary Meaning: Exemption is an situation.

In Java, exception is a meeting that interrupts the regular circulation of this method. It is a product which is tossed at playback.

What is exception handling

Exception Managing is a procedure to deal with playback mistakes such as ClassNotFound, IO, SQL, Distant etc.

Advantage of Exception Handling

The primary benefits of exception handling is to sustain the regular circulation of the applying. Exemption normally interrupts the regular circulation of the applying that is why we use exception handling.

Types of Exception

There are mainly two kinds of exceptions: examined and uncontrolled where mistake is regarded as uncontrolled exception. The sun microsystem says there are three kinds of exceptions:

  1. Checked Exception

  2. Unchecked Exception

  3. Error

Difference between examined and uncontrolled exceptions

1) Checked Exception

The sessions that increase Throwable category except RuntimeException and Error are known as examined exclusions e.g.IOException, SQLException etc. Checked exclusions are examined at compile-time.

2) Unchecked Exception

The sessions that increase RuntimeException are known as uncontrolled exclusions e.g. ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException etc. Unchecked exclusions are not examined at compile-time rather they are examined at playback.

3) Error

Error is irrecoverable e.g. OutOfMemoryError, VirtualMachineError, AssertionError etc.

Typical circumstances where exclusions may occur

There are given some circumstances where uncontrolled exclusions can happen. They are as follows:

1) Situation where ArithmeticException occurs

If we split any variety by zero, there happens an ArithmeticException.

int a=50/0;//ArithmeticException

2) Situation where NullPointerException occurs

If we have zero value in any varying, executing any function by the varying happens an NullPointerException.

String s=null;

  1. System.out.println(s.length());//NullPointerException

3) Situation where NumberFormatException occurs

The incorrect style of any value, may happen NumberFormatException. Assume I have a sequence varying that have figures, transforming this varying into variety will happen NumberFormatException.

String s=”abc”;

  1. int i=Integer.parseInt(s);//NumberFormatException

4) Situation where ArrayIndexOutOfBoundsException occurs

If you are placing any value in the incorrect catalog, it would outcome ArrayIndexOutOfBoundsException as proven below:

int a[]=new int[5];

  1. a[10]=50; //ArrayIndexOutOfBoundsException

In common, different is managed (resolved) by preserving the present condition of performance in a predetermined place and changing the performance to a particular subroutine known as different owner. If exclusions are continuable, the owner may later continue the performance at the very first place using the stored details. For example, a sailing point split by zero exemption will generally, by standard, allow the system to be started again, while an out of storage situation might not be resolvable transparently.

Don't be shellfish...Email this to someonePrint this pageTweet about this on TwitterShare on StumbleUponShare on TumblrShare on LinkedInShare on RedditDigg thisShare on Google+Pin on PinterestShare on FacebookBuffer this page