Skip to main content

Object initialization

  • As with class initialization, the simplest kind of object initialization is automatic initialization of object fields to default values.
  • Example:

    class ObjectInitializationDemo1

    {

    boolean b;

    byte by;

    char c;

    double d;

    float f;

    int i;

    long l;

    short s;

    String st;

    public static void main (String [] args)

    {

    ObjectInitializationDemo1 oid1 = new ObjectInitializationDemo1 ();

    System.out.println ("oid1.b = " + oid1.b);

    System.out.println ("oid1.by = " + oid1.by);

    System.out.println ("oid1.c = " + oid1.c);

    System.out.println ("oid1.d = " + oid1.d);

    System.out.println ("oid1.f = " + oid1.f);

    System.out.println ("oid1.i = " + oid1.i);

    System.out.println ("oid1.l = " + oid1.l);

    System.out.println ("oid1.s = " + oid1.s);

    System.out.println ("oid1.st = " + oid1.st);

    }

    }

  • Output

    b = false

    by = 0

    c =  

    d = 0.0

    f = 0.0

    i = 0

    l = 0

    s = 0

    st = null


     

  • There is no class loading and byte code verifying in between.
  • The same way the explicit assignment is done.
  • The default constructer initializes the contents of the object. For that it uses <init> methodfrom JVM perspective
  • The same way as in class initialization the object initialization also allows us to refer to the previously initialized field.
  • Object Block Initailazation

    {

          System.out.println ("Initializing object " + hashCode ());

          int localVariable = 1;

       }

  • In many situations, you will not use object block initializers because you can use constructors to perform complex initialization tasks. 
  • For situations like:  Anonymous inner classes often require object block initializers to perform complex initialization tasks.


    Anonymous inner classes require object block initializers because anonymous inner classes have no names, constructors take on the names of their classes, and you cannot declare constructors in classes that have no names.
  • In the case of hierarchies the class at the top most level is first initialized.
  • In object field/block initialization , one can access the field of the subclass but at that time the explicit value is not assigned so it will give us default value.


     
Labels:

Popular posts from this blog

Primitive Obsession with Example

Primitive Obsession is the name of a code smell that occurs when we use primitive data types to represent domain ideas. For example, we use a string to represent a message or an integer to represent an amount of money. For Example: Code with Primitive Obsession // primitiveObsession.java public class primitiveObsession { public static void main ( String args []) { Integer [] cityPopulations = { 13000000 , // London 21903623 , // New York 12570000 , // Tokyo 1932763 , // Stockholm 1605602 , // Barcelona 4119190 // Sydney }; for ( Integer cityPopulation : cityPopulations ) { System . out . println ( cityPopulation ); } } } public class City { private final String name ; private final int population ; private final Continent continent ; public String getName () { return name ; } public int getPopulation () { return population ; } public Continent ge...
Read more

Factory Pattern

This pattern is used when it must be decided at run time which one of several compatible classes is to be instantiated. For example, the abstract Collator class's getInstance() method returns a collation object that is appropriate for the default locale, as determined by java.util.Locale.getDefault() : Like other locale-sensitive classes, you can use the static factory method, getInstance, to obtain the appropriate Collator object for a given locale.  The following example shows how to compare two strings using the Collator for the default locale. Compare two strings in the default locale Collator myCollator = Collator.getInstance(); if( myCollator.compare("abc", "ABC") < 0 ) System.out.println("abc is less than ABC"); else System.out.println("abc is greater than or equal to ABC");
Read more

Singleton Pattern

Lazy Initialization :- The instantiation of an object can be delayed until it is actually needed. Usage: This especially beneficial when the constructor is doing a costly job like, accessing a remote database. Example: This code demonstrates how the Singleton pattern can be used to create a counter to provide unique sequential numbers, such as might be required for use as primary keys in a Database:   Sequence.java   public class Sequence { private static Sequence instance; private static int counter; private Sequence() { counter = 0; // May be necessary to obtain // starting value elsewhere... } public static synchronized Sequence getInstance() { if(instance==null) // Lazy instantiation { instance = new Sequence(); } return instance; } public static synchronized int getNext() { return ++counter; } }   Some things to note about this implementation: Synchronized methods are used to ensure that the class is thread-safe. This class cannot be subclassed because the constructor is private ...
Read more