Many older languages, like C and Pascal, were procedural languages. Procedures (also called functions) were blocks of code that were part of a module or application. Procedures passed parameters (primitive data types like integers, characters, strings, and floating point numbers). Code was treated separately to data. You had to pass around data structures, and procedures could easily modify their contents. This was a source of problems, as parts of a program could have unforeseen effects in other parts. Tracking down which procedure was at fault wasted a great deal of time and effort, particularly with large programs.  You are reading the right article if it’s computer programming help that you seek.

In some procedural language, you could even obtain the memory location of a data structure. Armed with this location, you could read and write to the data at a later time, or accidentally overwrite the contents.

Java is an object-oriented language. An object-oriented language deals with objects. Objects contain both data (member variables) and code (methods). Each object belongs to a particular class, which is a blueprint describing the member variables and methods an object offers. In Java, almost every variable is an object of some type or another – even strings. Object-oriented programming requires a different way of thinking, but is a better way to design software than procedural programming. ……more

Java is basically a programming language,which was originally developed by James Gosling (best known as the father of the Java programming language) at Sun microsystems which is now a subsidiary of Oracle Corporation. It was first released by Sun in 1995. In short, it is the underlying technology that powers state-of-the-art programs including utilities, games, and business applications. Java runs on more than 850 million personal computers worldwide, and on billions of devices worldwide, including mobile and TV devices.

Why do people need JAVA?

There are lots of applications and websites that won’t work unless you have Java installed, and more are created every day. Java is fast, secure, and reliable. From laptops to datacenters, game consoles to scientific supercomputers, cell phones to the Internet, Java is everywhere!

Characteristics of JAVA

The programs you create are portable in a network
The code is robust, here meaning that, unlike programs written in C++ and perhaps some other languages, the Java objects can contain no references to data external to themselves or other known objects.
Java is object-oriented, which means that, among other characteristics, an object can take advantage of being part of a class of objects and inherit code that is common to the class.
In addition to being executed at the client rather than the server, a Java applet has other characteristics designed to make it run fast.
Relative to C++, Java is easier to learn. (However, it is not a language you’ll pick up in an evening) ……more

Java is most suitable for creating Enterprise Applications for its flexibility and control. JAVA is used to create wide range of application with an extensive functionality. The only disadvantage is that Java provides huge functionality and that requires some expert skills to take advantages and integrating JAVA application.

For developing enterprise applications Java is the best fit. As it is flexible object oriented programming language for robust enterprise application development. JAVA is having huge acceptability in building enterprise applications. JAVA is having worldwide acceptance and giant community. JAVA has replaced C++ in enterprise application development by its uniqueness of compiling and debugging the code. Java is very useful for not only developers but also for the end users because of its interactive, dynamic and neutral architectural quality. The end users can get live up to date content on the web. JAVA is having a wide community support which is helpful in solving all kind of problems with in very short time. ……more

The Java Virtual Machine

The Java virtual machine is called “virtual” because it is an abstract computer defined by a specification. To run a Java program,
you need a concrete implementation of the abstract specification. This chapter describes primarily the abstract specification of the Java virtual machine.
To illustrate the abstract definition of certain features, however, this chapter also discusses various ways in which those features could be implemented.

What ‘s the Java Virtual Machine?

To understand the Java virtual machine you must first be aware that you may be talking about any of three different things
when you say “Java virtual machine.” You may be speaking of the abstract specification, a concrete implementation, or a runtime instance.

The abstract specification is a concept, described in detail in the book: The Java Virtual Machine Specification, by Tim Lindholm and Frank Yellin.
Concrete implementations, which exist on many platforms and come from many vendors, are either all software or a combination of hardware and software.
A runtime instance hosts a single running Java application.
Each Java application runs inside a runtime instance of some concrete implementation of the abstract specification of the Java virtual machine.
In this book, the term “Java virtual machine” is used in all three of these senses. Where the intended sense is not clear from the context,
one of the terms “specification,” “implementation,” or “instance” is added to the term “Java virtual machine”.

The lifetime of a Java Virtual Machine

A runtime instance of the Java virtual machine has a clear mission in life: to run one Java application.
When a Java application starts, a runtime instance is born. When the application completes, the instance dies.
If you start three Java applications at the same time, on the same computer, using the same concrete implementation,
you’ll get three Java virtual machine instances. Each Java application runs inside its own Java virtual machine.
A Java virtual machine instance starts running its solitary application by invoking the method of some initial class.
The method must be public, static, return , and accept one parameter.
Any class with such a method can be used as the starting point for a Java application.

For example, consider an application that prints out its command line arguments:

// On CD-ROM in file jvm/ex1/Echo.javaclass Echo
{ public static void main(String[] args)
{
int len = args.length;
for (int i = 0; i {
System.out.print(args[i] + ” “);
}
System.out.println();
}
}

You must in some implementation-dependent way give a Java virtual machine the name of the initial class that has the method that
will start the entire application. One real world example of a Java virtual machine implementation is the program from Sun’s Java 2 SDK.
If you wanted to run the application using Sun’s on Window98, for example, you would type in a command such as:
java Echo Greetings, Planet.

The first word in the command, indicates that the Java virtual machine from Sun’s Java 2 SDK should be run by the operating system.
The second word, is the name of the initial class.must have a public static method named that returns and takes a array as its only parameter.
The subsequent words, are the command line arguments for the application.
These are passed to the method in the array in the order in which they appear on the command line.
So, for the previous example, the contents of the array passed to main,
The method of an application’s initial class serves as the starting point for that application’s initial thread.
The initial thread can in turn fire off other threads.
Inside the Java virtual machine, threads come in two flavors: daemon and non- daemon.
A daemon thread is ordinarily a thread used by the virtual machine itself, such as a thread that performs garbage collection.
The application, however, can mark any threads it creates as daemon threads.
The initial thread of an application–the one that begins at –is a non- daemon thread.
A Java application continues to execute (the virtual machine instance continues to live) as long as any non-daemon threads are still running.
When all non-daemon threads of a Java application terminate, the virtual machine instance will exit.
If permitted by the security manager, the application can also cause its own demise by invoking the method of class or .
In the application previous, the method doesn’t invoke any other threads. After it prints out the command line arguments, returns.
This terminates the application’s only non-daemon thread, which causes the virtual machine instance to exit.

The Architecture of the Java Virtual Machine

In the Java virtual machine specification, the behavior of a virtual machine instance is described in terms of subsystems, memory areas, data types,
and instructions. These components describe an abstract inner architecture for the abstract Java virtual machine.
The purpose of these components is not so much to dictate an inner architecture for implementations.
It is more to provide a way to strictly define the external behavior of implementations.
The specification defines the required behavior of any Java virtual machine implementation in terms of these abstract components and their interactions.
When a Java virtual machine runs a program, it needs memory to store many things, including bytecodes and other information
it extracts from loaded class files, objects the program instantiates, parameters to methods, return values, local variables,
and intermediate results of computations. The Java virtual machine organizes the memory it needs to execute a program into several runtime data areas.
Although the same runtime data areas exist in some form in every Java virtual machine implementation,
their specification is quite abstract. Many decisions about the structural details of the runtime data areas are left to the
designers of individual implementations.
Different implementations of the virtual machine can have very different memory constraints.
Some implementations may have a lot of memory in which to work, others may have very little.
Some implementations may be able to take advantage of virtual memory, others may not.
The abstract nature of the specification of the runtime data areas helps make it easier to implement the Java virtual machine on a wide
variety of computers and devices.
Some runtime data areas are shared among all of an application’s threads and others are unique to individual threads.
Each instance of the Java virtual machine has one method area and one heap. These areas are shared by all threads running inside the virtual machine.
When the virtual machine loads a class file, it parses information about a type from the binary data contained in the class file.
It places this type information into the method area. As the program runs, the virtual machine places all objects the program instantiates onto the heap.
As each new thread comes into existence, it gets its own pc register (program counter) and Java stack.
If the thread is executing a Java method (not a native method), the value of the pc register indicates the next instruction to execute.
A thread’s Java stack stores the state of Java (not native) method invocations for the thread.
The state of a Java method invocation includes its local variables, the parameters with which it was invoked,
its return value (if any), and intermediate calculations. The state of native method invocations is stored in an implementation-dependent way
in native method stacks, as well as possibly in registers or other implementation-dependent memory areas.
The Java stack is composed of stack frames (or frames). A stack frame contains the state of one Java method invocation. When a thread invokes a method,
the Java virtual machine pushes a new frame onto that thread’s Java stack. When the method completes, the virtual machine pops and discards
the frame for that method.
The Java virtual machine has no registers to hold intermediate data values. The instruction set uses the Java stack for storage of intermediate data values. This approach was taken by Java’s designers to keep the Java virtual machine’s instruction set compact and to facilitate implementation on architectures with few or irregular general purpose registers. In addition, the stack-based architecture of the Java virtual machine’s instruction set facilitates the code optimization work done by just-in-time and dynamic compilers that operate at run-time in some virtual machine implementations.