Convert the hexadecimal to decimal then verify with the below chart.

major minor Java version
45 3 1.0
45 3 1.1
46 0 1.2
47 0 1.3
48 0 1.4
49 0 1.5
50 0 1.6

Open the class file in Hex editor

if you have find difficulty in above procedure then write the java file to check the class version.

Method to check the class version:-
public void checkClassVersion(String classfile)
{
DataInputStream in = new DataInputStream
(new FileInputStream(filename));

int magic = in.readInt();
if(magic != 0xcafebabe) {
System.out.println(filename + ” is not a valid class!”);;
}
int minor = in.readUnsignedShort();
int major = in.readUnsignedShort();
System.out.println(filename + “:- ” + major + ” :- ” + minor);
in.close();

}

– Enjoy

- My friend blogs i like it..

Let us talk about some example say – we want an utility class which have a method which will return always random number, so it wouldn’t matter which instance of class is invoking this method. Here method job is to return the random number.

So why then, do we need an instance to invoke this method? Why not just tell the class itself to run this method.

- So here what it means – the variable or method which is not be an instance-specific, there we should use the static keyword.

What it mean that we can use static method and variable without having the instance of class at all.

Now what it strikes it in my head, usually we use to invoke the method or variable of class with the use of (.) dot operator.

So all the non-static variable and method is get invoked with the class instance.

Can we invoke the static method or variable by the instance of class?

- Yes, you can. But the rule’s is not changed here; it’s just the syntax trick to invoke the static method or variable with the instance of class, but the static members is not aware of the particular instance of class to invoke the members.

Compiler knows that the instance of which class, so it will run the static members with no concerns.

Bullets point(s):-

• Static method cannot access an instance (non-static) variable.
  
• Static method cannot access an instance (non-static) method.
• Static method can access a static method and variable.

Here comes tricky one? Can we override the static method?

- NO, static method’s can’t be overridden. This does not mean that they can’t be redefined in subclass but redefining and overloading isn’t the same thing.

Let take an example – Shave trimmer that have an adapter which is used to connect it to power sockets.

Now let us take an ipod which uses the same adapter to connect it to power sockets. so here come two disimilar objects ( shave trimmer and ipod) that are allowed to use the same adaptar.Interface is like a guideline or making a contract between the class (shave trimmer and ipod) with the kind of adaptar. My making a adaptar as an interface we can implement the mechanism which is used to handle the voltage and power out put.

• Basically used to provide the certain functionality to class with no matter what type of object is invoking.
• All the class which implement this interface(adapter) all it knows it should support the type of voltage and power out put.

Abstract

Abstract class are purely used for inheritance.

Let take again an example of ipod – when the first version of ipod release it has the method of changing the song and display the song name on the screen and lot more other method which provide some functionality.

In that case Abstract class should have method where all the child ipod( new version ipod) should inherit .In that case all the new version of ipod default inherit the feature of change the song and display the song name methods.

But there may be chance that all the new version of ipod may have slightly changes in one of the method , but they all inherit the basic functionality from the base class.Now what makes this different from a regular base class is that its abstract meaning that all those child ipods that inherit from the original override the functionality.

Abstract classes are not meant to be directly instantiated, they are primarily used to inherit from. You can pull all the functionality common to all ipods out there in one basic class and then in each child class only override what is new to the child class (aka the improvements).

• By creating an interface, you can move your implementation to any class that implements your interface.

• By creating an abstract class, you can share implementation for all derived classes in one central place, and avoid lots of bad things like code duplication.

As constructor is not public we should restrict the user to invoke the class.

Sample:-

package com.blog.preenu
{
public class SingletonClass
{
private static var s_singletonClass : SingletonClass;

public function SingletonClass(singletonEnforcer:SingletonEnforcer)
{
if ( singletonEnforcer == null )
{
throw new Error( “Only one SingletonClass instance should be instantiated” );
}
}

public static function getInstance() : SingletonClass
{
if(s_singletonClass == null)
{
s_singletonClass = new SingletonClass(new SingletonEnforcer());
}

return s_singletonClass;
}
}

}
class SingletonEnforcer {

}