Java Features

Features of  Java:

Java is completely Object oriented.

Objected Oriented:

To stay abreast of modern software development practices, Java is Object-Oriented from the ground up. Many of Java's Object_Oriented concepts are inherited from C++, the language on which it is based, plus concepts from other Object-Oriented languages as well.

Simple:

Java Omits many confusing, rarely used features of C++. There is no pointer level programming or pointer arithematic. Memory management is automatic. There are no header files, Structures, Unions, Operators overloading, virtual base classes and multiple inheritance.

Robust:

Java programs are reliable. Java puts a lot of emphasis on early checking for potential problems, dynamic checking and eliminating situations that are error-prone. Java has a pointer model that eliminates possibility of overwriting memory and corrupting data.

Security: 

Java is intended to used in networked/distributed environments. Thus a lot of emphasis is placed on security. Normally two things affect security;

•  Confidential information may be compromised, and
• Computer systems are vulnerable to corruption or destruction by hackers.

Java security model has three primary components;

• Byte Code verifier : The byte code verifier ensures the following;

• the Java programs have been complied correctly
• they will obey the virtual machine's access restrictions, and 
• the byte codes will not access private data when they should not.

• Class Loader : When the loader retrieves classes from the network , it keeps classes from different servers separate from each other and from local classes. through this separation, the class loader prevents a class that loaded off the network from pretending to be one of the standard built-in classes, or from interfering with the operation of classes loaded from other servers.
• Security Manager:

It implements a security policy for the VM. The security policy determines which activities of the VM is allowed to perform and under what circumstances., operations should pass.

Architecture-Neutral:

A central issue for the Java designers was of code longevity and portability. One of the main problems facing programmers is that there is no guarantee that when you write a program today, it will run tomorrow -- even on the same machine. Operating system upgrades, processors upgrades, and changes in core system resources can all combine to make a program malfunction. The java designers made several hard decisions in the Java language and the JVM in an attempt to alter this situation. Their goal was "write once; run anywhere, any time, forever"; To a great extent, this goal was accomplished.

Platform Independent: 

This refers to a program's capability of moving easily from one computer system to another. Java is platform-independent at both the source and the binary level.

• At the source level, java's primitive data types have consistent sizes across all development platforms.
• Java binary files are also platform-Independent and can run on multiple platforms without the need to recompile the source because they are in the form of byte codes.

Interpreted and Complied: 

Java programs are complied into an intermediate byte code format, which in turn will be interpreted by the VM at run time. Hence, any Java program is checked twice before it's actually runs.

Multi-threaded:

A multi-threaded application can have several threads of execution running independently and simultaneously. these threads may communicate and cooperate. To user it will appear to be a single program. Java implements multi-threaded through a part of its class library. However, Java also has language constructs to make programs thread-safe.

Dynamic:

Java programs carry with them substantial amounts of run-time type information that is used to verify and resolve accesses to objects at run time. This makes it possible to dynamically link code in a safe and expedient manner. This is crucial to the robustness of the applet environment, in which small fragments of bytecode may be dynamically updated on a running system.

Memory Management and Garbage Collection:

Java manages memory de-allocation by using garbage collection. Temporary memory is automatically reclaimed after it is no longer referenced by any active part of the program. To improve performance, Java's garbage collector runs in its own low-priority thread, providing a good balance of efficiency and real-time responsiveness.