Java Tips

Java General Tips

 Unicode Characters are expressed as 4 character hex codes e.g. c = "\u45c7" .
 Scientific numerical literals such as 1E2 are assigned to double data types by default.
 The default type of any numeric literal with a decimal point is double.
 integer and long operations / and % can throw ArithmeticException whilst float / and % do not - not even with divide by zero.
 Negative binary numbers are the same as their positive equivalents 1 , with bits reversed.
 ( -1 >> anything ) = -1 and is always promoted to at least int type.
 ( -1 & anything ) = anything, since 1 is all 1 bits.
 The &sim operator is actually a typo in some books for "~" (bitwise integral inversion).
 In range literal assignments are allowed for byte , short and char primitive data types.
 The Math.random() method produces a number >= 0.0 and < 1.0 .
 Angles passed to Math.sin(), cos() or tan() are expressed in Radians.
 The Math class is immutable.
 The expression -0.0 == 0.0 returns true.
 Valid boolean literals are true¡± and false¡± only.
 The expression for ( ; ; ) { } is an infinite loop therefore it will compile.
 Static methods are called once at class load time.
 Static methods can not be overridden, nor can final methods.
 Methods may not have the same name as the constructor(s).
 Constructors CAN be private, as in the Math class - but it is not common.
 Constructors can throw ANY exception.
 Initializer blocks are executed in the order of their declaration.
 Instance initializers get executed ONLY IF the objects are constructed.
 The main() method can be declared final.
 Static methods can not use non-static features of the class. The main() method can not reference unqualified non-static methods.
 You can access and use static methods and variables e.g. Math.round() and Math.PI.
 Access modifiers dictate which classes NOT instances may access features.
 Access modifiers are only used on class level variables, with rare exceptions.
 (Local) Inner classes in methods can access final variables inside the enclosing method or its parameters. They may also access the non-static data of the enclosing class.
 Methods of a static inner class can not access instance variables of the enclosing class, only static ones.
 Inner classes can have any access modifier, but those defined within a method can not. Such a class is private to that block. Inner classes in a block may not be static.
 No inner class can have a static member.
 Garbage collection takes place (possibly) sometime after an object is no longer being used. Assign null to a variable when you have finished using it.
 A method of the form : public Object pop() { return storage[index--]; } will cause a memory leak.

Java (programming language)

Java is a programming language originally developed by Sun Microsystems 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 that can run on any Java virtual machine (JVM) regardless of computer architecture.

The original and reference implementation Java compilers, virtual machines, and class libraries were developed by Sun from 1995. As of May 2007, in compliance with the specifications of the Java Community Process, Sun made available most of their Java technologies as free software under the GNU General Public License. Others have also developed alternative implementations of these Sun technologies, such as the GNU Compiler for Java and GNU Classpath.

History

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 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 secure 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. J2SE designated the Standard Edition. In 2006, for marketing purposes, Sun renamed new J2 versions as Java EE, Java ME, and Java SE, respectively.

Java Platform

One characteristic of Java is portability, which means that computer programs written in the Java language must run similarly on any supported hardware/operating-system platform. One should be able to write a program once, compile it once, and run it anywhere.

This is achieved by compiling the Java language code, not to machine code but to Java bytecode – instructions analogous to machine code but intended to be interpreted by a virtual machine (VM) written specifically for the host hardware. End-users commonly use a Java Runtime Environment (JRE) installed on their own machine for standalone Java applications, or in a Web browser for Java Applets.


Automatic memory management

Java uses an automatic garbage collector to manage memory in the object lifecycle. The programmer determines when objects are created, and the Java runtime is responsible for recovering the memory once objects are no longer in use. Once no references to an object remain, the unreachable object becomes eligible to be freed automatically by the garbage collector. Something similar to a memory leak may still occur if a programmer's code holds a reference to an object that is no longer needed, typically when objects that are no longer needed are stored in containers that are still in use.

One of the ideas behind Java's automatic memory management model is that programmers be spared the burden of having to perform manual memory management. In some languages memory for the creation of objects is implicitly allocated on the stack, or explicitly allocated and deallocated from the heap. Either way the responsibility of managing memory resides with the programmer. If the program does not deallocate an object, a memory leak occurs. If the program attempts to access or deallocate memory that has already been deallocated, the result is undefined and the program may become unstable and/or may crash. This can be partially remedied by the use of smart pointers, but it adds overhead and complexity.

Syntax

The syntax of Java is largely derived from C++. Unlike C++, which combines the syntax for structured, generic, and object-oriented programming, Java was built almost exclusively as an object oriented language. All code is written inside a class and everything is an object, with the exception of the intrinsic data types (ordinal and real numbers, boolean values, and characters), which are not classes for performance reasons.

Java suppresses several features (such as operator overloading and multiple inheritance) for classes in order to simplify the language and to prevent possible errors and anti-pattern design.

Examples

The traditional Hello world program can be written in Java as:

/**
* Outputs "Hello, World!" and then exits
*/
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}

A class that is declared private may be stored in any .java file. The compiler will generate a class file for each class defined in the source file. The name of the class file is the name of the class, with .class appended. For class file generation, anonymous classes are treated as if their name was the concatenation of the name of their enclosing class, a $, and an integer.

The keyword public denotes that a method can be called from code in other classes, or that a class may be used by classes outside the class hierarchy. The class hierarchy is related to the name of the directory in which the.java file is.

The keyword static in front of a method indicates a static method, which is associated only with the class and not with any specific instance of that class. Only static methods can be invoked without a reference to an object. Static methods cannot access any method variables that are not static.

The keyword void indicates that the main method does not return any value to the caller. If a Java program is to exit with an error code, it must call System.exit()

The method name "main" is not a keyword in the Java language. It is simply the name of the method the Java launcher calls to pass control to the program. Java classes that run in managed environments such as applets and Enterprise Java Beans do not use or need a main() method. A java program may contain multiple classes that have main methods, which means that the VM needs to be explicitly told which class to launch from.