CONSTRUCTORS

A constructor is a unique approach which will be known as by the JVM unquestioningly (automatically) for putting user/programmer described principles instead of putting standard value.

Constructors are intended for initializing the item principles.

ADVANTAGES OF CONSTRUCTORS:
   1. A constructor removes putting the standard principles.
   2. A constructor removes contacting the regular technique unquestioningly.

RULES/PROPERTIES/CHARACTERISTICS OF A CONSTRUCTOR:
   1. Constructor name must be just like name of the category.
   2.  Constructor should not come back any value even gap also (if we create the come back kind for the  Constructor then that  Constructor will be handled as common method)
   3.  Constructor should not be fixed since  Constructor will be known as each and whenever whenever an item is developing.
   4.  Constructor should not be personal offer an item of one category is designed in another category ( Constructor can be personal offer an item of one category designed in the same category.
   5.  Constructor will not be got at all.
   6.  Constructor are known as instantly whenever an item is developing.
   Note:-
   If the developer is not interpreting any  Constructor then compiler is always produced standard  Constructor.

TYPES OF CONSTRUCTORS:
       Depending on developing item in coffee we hava two kinds of  Constructor. They are default/parameter less/no discussion  Constructor and parameterized  Constructor

    A standard  Constructor is one which will not take any factors.

SYNTAX:-
Class <clsname>
{
   classname () //default  Constructor
    {
        prevent of statements;
        -------------------;
        -------------------;
    }
   ---------------;
   ---------------;
};

FOR EXAMPLE:
class check
{
  int a,b;
  check ()
  {
    program.out.println ("I AM FROM DEFAULT CONSTRUCTOR...");
    a=10;
    b=20;
    program.out.println ("VALUE OF a= "+a);
    program.out.println ("VALUE OF b= "+b);
   }
};
class testdemo
{
   community fixed gap primary (string [] args)
    {
        check t1 =new check ();
     }
};
RULE-1:
     Whenever we make an item only with standard  Constructor interpreting the standard  Constructor is optionally available. If we are not interpreting standard  Constructor of a category then JVM will contact instantly program described standard  Constructor. If we determine JVM will contact user/programmer described standard  Constructor.

    A parameterized  Constructor is one which projects some factors.

SYNTAX:
Class <classname>
{
     ---------------;
     ---------------;
    <classname>(list of parametrs) //parameterized  Constructor
    {
             Block of claims (s);
     }
     ------------;
     ------------;
}
FOR EXAMPLE:
Class test
{
    int a,b;
    check (int n1, int n2)
    {
           program.out.println ("I AM FROM PARAMETER CONSTRUCTOR..");
           a=n1;
           b=n2;
           program.out.println ("VALUE OF a = "+a");
           syatem.out.println (" VALUE OF b = "+b):
     }
};
class testdemo1
{
    community fixed gap primary (string k [])
     {
         check t1 =new check (10,20);
      }
};

RULE-2:
        Whenever we make an item using parameterized  Constructor it is mandatory for the coffee developer to determine parametrized  Constructor otherwise we will get gather time mistake.

    over filling  Constructor is one in which  Constructor name is identical but its trademark is different. Signature symbolizes variety of factors kind of factors and acquire of factors. Here at least one factor must be separated.

FOR EXAMPLE:

  check t1=new test(10,20);
  Test t2=new Test(10,20,30);
  Test t3=new Test(10.5,20.5);

  Test t4=new Test(10,20.5);
  Test t5=new Test(10.5,20);