Java Persistence API (JPA)

2015-02-03T04:59:00.003-08:00

Serialization

2015-02-03T04:52:00.003-08:00

Synchronization

2015-02-03T04:52:00.001-08:00

Overriding

2015-02-03T04:49:00.006-08:00

Overloading

2015-02-03T04:49:00.004-08:00

Inheritance

2015-02-03T04:49:00.002-08:00

Container Managed Persistence (CMP)

2015-02-03T04:43:00.005-08:00

Bean Managed Persistence (BMP)

2015-02-03T04:43:00.002-08:00

Stateful Session Bean

2015-02-03T04:39:00.005-08:00

Stateless Session Bean

2015-02-03T04:39:00.003-08:00

Message Driven Bean

2015-02-03T04:38:00.006-08:00

Entity Bean

2015-02-03T04:38:00.003-08:00

Session Bean

2015-02-03T04:38:00.001-08:00

Enterprise Java Beans (EJB)

2015-02-03T04:37:00.001-08:00

Remote Procedure Call (RPC)

2015-02-03T04:34:00.002-08:00

Remote Method Invocation (RMI)

2015-02-03T04:33:00.002-08:00

Transaction Attributes

2015-02-03T04:31:00.003-08:00

Transaction

2015-02-03T04:31:00.001-08:00

Finalize

2015-02-03T04:29:00.001-08:00

Unchecked Exception

2015-02-03T04:28:00.005-08:00

Checked Exception

2015-02-03T04:28:00.003-08:00

Exception

2015-02-03T04:28:00.000-08:00

Final

2015-02-03T04:27:00.001-08:00

Static

2015-02-03T01:40:00.001-08:00

Static
The static keyword denotes that a member variable, or method, can be accessed without requiring an instantiation of the class to which it belongs.
In simple terms, it means that you can call a method, even if you've never created the object to which it belongs! Every time you run a stand-alone application (which requires a static main method), the virtual machine can call the main method without creating a new application object. Of course, unless the application's methods are all static, you will need to create an instance of it at some point.
Static keyword can be used in many ways:

Static field
Static method
Static class
Static block

Static field
The value of a static field is the same across all instances of the class. In other words, if a class has a static field named CompanyName, all objects created from the class will have the same value for CompanyName.

A field that’s declared with the static keyword, like this:

private static int ballCount;

The position of the static keyword is interchangeable with the positions of the visibility keywords (private and public, as well as protected). As a result, the following statement works, too:

static private int ballCount;
Static fields are created and initialized when the class is first loaded. That happens when a static member of the class is referred to or when an instance of the class is created, whichever comes first.

Static method
A method declared with the static keyword. Like static fields, static methods are associated with the class itself, not with any particular object created from the class. As a result, you don’t have to create an object from a class before you can use static methods defined by the class.

The best-known static method is main, which is called by the Java runtime to start an application.
The main method must be static, which means that applications run in a static context by default.
One of the basic rules of working with static methods is that you can’t access a nonstatic method or field from a static method because the static method doesn’t have an instance of the class to use to reference instance methods or fields.

Static class
Static classes are nested classes that act like top-level classes, even if they appear somewhere in the middle or the bottom of the program hierarchy (within a class) in other words Java has no way of making a top-level class static, only nested classes can be declared as static classes.

Static classes are independent of the outer class, while other inner classes are dependent on the outer class.
A good use of a static class is in defining one-off, utility and/or library classes where instantiation would not make sense.
A static class cannot access non-static members of the Outer class. It can access only static members of Outer class.

Example : To declare a static class within our “Car” class, we use the syntax:

 class Car {
   class SUVs {
   }
   static class sedans {
   }
}

Here, the keyword “static” ensures that the class sedan will be treated as an outer class.

Static block
Static blocks are also called Static initialization blocks . A static initialization block is a normal block of code enclosed in braces: { }, and preceded by the static keyword. Here is an example:

 static {  
   // whatever code is needed for initialization goes here  
 }

A class can have any number of static initialization blocks, and they can appear anywhere in the class body
The runtime system guarantees that static initialization blocks are called in the order that they appear in the source code.
The static blocks will be executed when JVM loads the class.
JVM combines all the static blocks into one single static block and then executes.
If you’re referring some static variables/methods from the static blocks, these statements will be executed after the class is loaded into JVM same as above i.e., now the static variables/methods referred and the static block both will be executed.

Java Concepts