Basic Rules Need to Follow When Writing Constructors In Java

Name of the constructor must be same as that of a class name. If you give another name it will give compile time error. If you give another name, it is neither a method because of no return type, nor constructor because name is different from class name.
?
class A
{
     A()
     {
         // Constructor of Class A
     }
     A1()
     {
         // Compile time error, It is neither a constructor nor a method
     }
}

Constructors must not have a return type. If you keep return type for the constructor, it will be treated as another method.But compiler gives a warning saying that this method has a constructor name. That means, it is legal to have method name same as constructor name or same as class name but it is not recommended.
?
class A
{
     A()
     {
         // Constructor of Class A, not having any return type.
     }
 
     void A()
     {
         // constructor having a return type, It will be treated as method but with a warning.
     }
}
Every class should have at least one constructor. If you don’t write constructor for your class, compiler will give default constructor. Default constructor is always public and it has no arguments (No-Arg Constructor).
?
class A
{
     // No Constructors written
}
Compiler will treat the above code as,

?
class A
{
    public A()
    {
        //   Constructor provided by the compiler.
    }
}
Constructor can be declared as private. If you declare constructor as private, you can’t use it outside that class.
?
class A
{
     private A()
     {
          // Private Constructor
     }
 
     void methodOne()
     {
          //You can use private constructor inside the class
          A a1 = new A();
     }
}
 
class MainClass
{
     public static void main(String[] args)
     {
          //You can't use private constructor ouside the class like this
          // A a1 = new A();
     }
}
One class can have more than one constructors. It is called Constructor Overloading. Through constructor overloading, you can have multiple ways to create objects.
?
class A
{
     A()
     {
        // First Constructor
     }
 
     A(int i)
     {
        // Second Constructor
     }
 
    A(int i, int j)
    {
       // Third Constructor
    }
}

 
you can create the objects to the above class in three ways like below,


 
?
class MainClass
{
     public static void main(String[] args)
     {
          A a1 = new A();      //Using First Constructor
          A a2 = new A(10);    // Using Second Constructor
          A a3 = new A(10, 20);    // Using Third Constructor
     }
}
Duplicate Constructors not allowed. If you keep duplicate constructors, you will get compile time error.
?
class A
{
     A(int i)
     {
         // Duplicate Constructor
     }
 
     A(int i)
     {
        // Duplicate Constructor
     }
}
Multiple arguments of the constructors can’t have same name. If the two arguments have the same name, you will get compile time error.
?
class A
{
     A(int i, int i)
     {
         // Duplicate Arguments Passed. It gives compile time error
     }
}
Only public, protected and private keywords are allowed before a constructor name. If you keep any other keyword before a constructor name, it gives compile time error.
?
class A
{
     final A()
     {
         //Constructor can not be final
     }
     static A()
     {
         //Constructor can not be static
     }
     abstract A()
     {
        //Constructors can not be abstract
     }
}
First statement in a constructor must be either super() or this(). If you put any other statements you will get compile time error.If you don’t include these statements, by default compiler will keep super() calling statement. super() – It is a calling statement to default constructor of super class. this()- it is a calling statement to constructor of the same class.
?
class A
{
     A()
     {
          //By Default, Compile will keep super() calling statement here.
          System.out.println("First Constructor");
     }
     A(int i)
     {
          //Compiler will not keep any statement here
          super();
          System.out.println("Second Constructor");
     }
     A(int i, int j)
     {
          //Compiler will not keep any statement here
          this();
          System.out.println("Third Constructor");
     }
     A(int i, int j, int k)
     {
          System.out.println("Fourth Constructor");
          // super(); It will give error if you keep super() here
     }
}
Recursive constructor calling is not allowed.?
class A
{
     A()
     {
          this();
          // It gives compile time error
     }
}
No Cylic calling of constructors.?
class A
{
     A()
     {
          this(10);
          // It gives compile time error
     }
     A(int i)
     {
          this();
          // It gives compile time error
     }
}

Comments

Post a Comment

Popular posts from this blog

References and Resources java  1.  Java General Java mother site @  http://java.sun.com  (or  http://www.oracle.com/technetwork/java/index.html ). Java Developers' sites, in particular,  http://java.net . JDK  (aka  Java SE ) Java SE  mother site @  http://java.sun.com/javase  (or  http://www.oracle.com/technetwork/java/javase/overview/index.html ). JDK 7  API  Documentation Online @  http://download.oracle.com/javase/7/docs/api/index.html . JDK 7 Documentation Online @  http://download.oracle.com/javase/7/docs/ . Ken Arnold, James Gosling and David Holmes, "The Java Programming Language", 4th ed, 2005. (The defacto standard for Java Language, but does not seem to have been updated to cover the latest features?!) James Gosling, Bill Joy, Guy Steele and Gilad Bracha, "The Java Language Specification", 3rd ed, 2005. (The defacto standard for JVM, but does not seem to have been updated?!)...
Read more

What is string immutability?

Image
What is string immutability? Here are a set of diagrams to illustrate Java String's  immutability . 1. Declare a string String s = "abcd" ; s stores the reference of the string object. The arrow below should be interpreted as "store reference of". 2. Assign one string variable to another string variable String s2 = s ; s2 stores the same reference value, since it is the same string object. 3. Concat string s = s. concat ( "ef" ) ; s now stores the reference of newly created string object. Summary Once a string is created in  memory (heap), it can not be changed. We should note that all methods of String do not change the string itself, but rather return a new String. If we need a string that can be modified, we will need StringBuffer or StringBuilder. Otherwise, there would be a lot of time wasted for Garbage Collection, since each time a new String is created.  Here  is an example of StringBuilder u...
Read more
Java Question ..............? Q1. What is a cookie ? Ans. A cookie is a small piece of text stored on a user's computer by the browser for a specific domain. Commonly used for authentication, storing site preferences, and server session identification. Q2. Can we reduce the visibility of the overridden method ? Q3. What are different types of inner classes ? Ans. Simple Inner Class, Local Inner Class, Anonymous Inner Class , Static Nested Inner Class. Q4. Difference between TreeMap and HashMap ? Ans. They are different the way they are stored in memory. TreeMap stores the Keys in order whereas HashMap stores the key value pairs randomly. Q5. What is the difference between List, Set and Map ? Ans. List - Members are stored in sequence in memory and can be accessed through index. Set - There is no relevance of sequence and index. Sets doesn't contain duplicates whereas multiset can have duplicates. Map - Contains Key , Value pairs. Q6. Difference between Public...
Read more