public final void setDisplayOrientation (int degrees)

 public static void setCameraDisplayOrientation(Activity activity,

         int cameraId, android.hardware.Camera camera) {

     android.hardware.Camera.CameraInfo info =

             new android.hardware.Camera.CameraInfo();

     android.hardware.Camera.getCameraInfo(cameraId, info);

     int rotation = activity.getWindowManager().getDefaultDisplay()

             .getRotation();

     int degrees = 0;

     switch (rotation) {

         case Surface.ROTATION_0: degrees = 0; break;

         case Surface.ROTATION_90: degrees = 90; break;

         case Surface.ROTATION_180: degrees = 180; break;

         case Surface.ROTATION_270: degrees = 270; break;

     }


     int result;

     if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {

         result = (info.orientation + degrees) % 360;

         result = (360 - result) % 360;  // compensate the mirror

     } else {  // back-facing

         result = (info.orientation - degrees + 360) % 360;

     }

     camera.setDisplayOrientation(result);

 }

 

At work I noticed an interesting piece of code. I wrote it in error, as I meant to write a static initializer (code that is run once when a static class is being referenced)

static {
// initialize static variables
}

but instead I wrote this

{
// initialize variables
}

It compiled nicely, but what is it good for?

The effect is not that of a static initializer, but it is actually run before the constructor; But not when referenced statically. You can have as many instance initializers as you want, and they are appearing to run in the order they are defined.

The author of “Java in a Nutshell” writes so nicely:

An instance initializer is simply a block of code inside curly braces that is embedded in a class definition, where a field or method definition normally appears.  A class (any class — not just anonymous classes) can have any number of instance initializers.  The instance initializers and any variable initializers that appear in field definitions for the class are executed in the order they appear in the Java source code.  These initializers are automatically run after the superclass constructor has returned but before the constructor, if any, of the current class runs.

This puzzles me, because this seems at first hand to be what we have constructors for. They are the blocks of code that is run whenever we instantiate a class, and should do all the complex logic and initialization that needs to be done to assure data integrity.

But; What about anonymous classes? You know, the ones that are used frequently in event-programming

someObject.addEventListener(new MouseAdapter() {
    public void mouseClicked(MouseEvent e) { // .... }
});

They cannot have constructors, but I imagine it can be useful to have complex (more than one line..) initialization even there. Also, according to more seasoned programmers than my self, instance initializers can be used to make the code easier to read, since the initialization block can be placed right next to the variables.

The initializers are run in the order they are defined, and you can have as many you want. In contrast to constructors, which you can only have one of without an argument list. This could also be useful with regards to code readability, since complex constructors, like any block of code, should be avoided.