Educationkidda

   Constructor is also know as the methid or the function in the java .Constructor are mainly used in the java programs to create  the object of the class.

Exmple:-

class Employee

  {

     public void setData()

        {

         System.out.println("This is the class Method");

    }

public static void main(String args[])

{

Employee e=new Employee();

e.setyData();

   }

}

Constructor in java and types of constructor with example in java|

           In this program we can clearly see that we have constructe the object of the Employee class  witn the hep of the new keyword.Normally cinstruction of the cklas means the allocating the memory space this reference.Refernce is the another topic we will disscuss deeply about this in another post. 

See some impoetant points  of the constructor

1. The constructor is same like the fucntions or the methods used in the  progerams.
2. constructor name should be same as the name of the class.
3. The cionstructor having no return types 
4. Constructors can use the  public access specifiers
5. We can use the constructors  in the abstract class but can't instatiate using thid.But we can instatiate the concrete class.

Types of Constructors in java:-

There are two types of constructors in the java.

1.Default constructor

2.non parametrised constructor

3.parametrised constructors

Default constructor

  If we are not  defining any constructors in the program then at the time of construction of the object the default constructor will be  called.

Non parameterised constrcutors:-

  In the non parametirsed constructors we are not passing any arguments and the main point is that the at the time of the execution of the JVM call the non parameterised constructor.

Parameterised constructor:-

  It is the opposite of the non parameterised constrcutor.

See some xemple

Example1:-

    class Demo1

{

int data;

Demo1()

{

data++;

System.out.println("Object is constructed");

}

protected Demo1(int x)

{

data=x;

}

public static void main(String args[])

{

Demo1 dd=new Demo1();

Demo1 bb=new Demo1(12);

System.out.println("value of the first object is"+dd.data);

System.out.println("Value of the second object is"+bb.data);

}

}

Example2:-

       Comand Line Argument means the passing the arguments through the main method.

Let's take example and then we can get more clarirty on that on that topic.

Exapmle:-

    

    From this exmple i have shown that the how to take the inputs through the  command line argument.As we are using the various methods or various classess to take the input from the user like this through the command line argument we  can take the input from the user but here we d ont have to import any classess and we dont have to use  any methods.Here at the time of the programs execution  we take the input fro  the user from which we  can do various operation.

Take the another example for the command line argument

Example 2:--

     Here in this program at the time of programs execution or after  the compilation of the program we can take the  command line arguments.Here to know the size of the array or the command line argumnets we can use the "length" keyword .

Example 3:-

Here some  another example of the command Line Argument

 class CommandLineArgumentDemo

{

public static void main(String args[])

{

int a=0;

int b=args.length;

while(a++<b)

{

System.out.println(args[a]);

}

}

}

Example 4:-

Pratice this programs on your computer we can get more clarity on this topic.My special suggesion is plz keep pratice all the java progarms beacuse it prety difficult to remember all the progarms we just have to keep some concept on your mind.So keep pratice and comment me if You are facing any problem in the code given.

Next--Constructos in java(click here)

        Polymorphis is feture of the java un wich the poly me ans many and merf means forms.In the polymorphism using one methd we can do various types of opeerations in different enviroments.

Types of Polymorphism:

There are two types of polymerphism in the java,

1.static polymephism

2.Dynamic polymerphism

what is polymorphism and it;s types in java|Polymerphism in java

Static polymorphism:-

        In the static polymophism the method cans be overloaded that means we can use the same method with the different parameters and  different return type.It is also know as the early binding.
Exapmle of methiod overloading:-
In the Methidd overloading gthe metiod argume ts should be different from each other
like this:-

public void add(int a)
public int sum(int a,int b)

programs:-

class Methodoverloading
{
public void sertData(char a)
{
system.out.pierntln("c");
}
public int setData(char a,int num)
{
System.out.println("+c+"+num);
}

public sratic  void main(STring args[])
{
Methodoverloading md=new Methodoverloading();
md.setData(a);
md.setData(a,4);

}
}


Dynamic Polymorphism:-
    In the Dynamic polymerphism the methods can be overrided thats means the method should have the same name and same metod return type and the same arguments.The Method ovveride is possible only in case of the inhertance.It is also known as the late binding.

Exapmle of method Overriding:

class X { public void showMessage(String msg) { System.out.println("base calss Massage is:"+msg); } } class Y extends X { @Override public void showMessage(String s) { System.out.println("child class Message is"+s); } } class Demo2 { public static void main(String args[]) { Y aa=new Y(); aa.showMessage("i am in the main"); } }

Exapmle 2:-
class A
{
int data;
A()
{
increment();
}
public void increment()
{
data++;
}
}
class B extends A
{
B()
{
increment();
}
public void increment()
{
data+=10;
}
}
class Demo1
{
public static void main(String args[])
{
B bb=new B();
bb.increment();
System.out.println("data value is"+bb.data);
}
}

Differenece between the method overloading and method overriding

Method Overloading	Method overriding
1.This is the part of the polymorphism 2.This is alos known as late binding 3.Methoid name may not be same 4,Independed  on the inheritance 5.Arguments of the methods shoud not be same	1.This is alos the part of the polymorphism 2.This is alos known as early binding 3.Method name should be same 4.Without inheritance the method overriding is not possible 5.Arguments of the method should be same

Next-Dynamic Method dispatch in java(click here)