Can constructor be public in java

Constructors in Java – A Complete Guide

Constructor is a block of code that initializes the newly created object. A constructor resembles an instance method in java but it’s not a method as it doesn’t have a return type. In short constructor and method are different(More on this at the end of this guide). People often refer constructor as special type of method in Java.

Constructor has same name as the class and looks like this in a java code.

Note that the constructor name matches with the class name and it doesn’t have a return type.

How does a constructor work

To understand the working of constructor, lets take an example. lets say we have a class MyClass .
When we create the object of MyClass like this:

The new keyword here creates the object of class MyClass and invokes the constructor to initialize this newly created object.

You may get a little lost here as I have not shown you any initialization example, lets have a look at the code below:

A simple constructor program in java

Here we have created an object obj of class Hello and then we displayed the instance variable name of the object. As you can see that the output is BeginnersBook.com which is what we have passed to the name during initialization in constructor. This shows that when we created the object obj the constructor got invoked. In this example we have used this keyword, which refers to the current object, object obj in this example. We will cover this keyword in detail in the next tutorial.

public class Hello < String name; //Constructor Hello()< this.name = "BeginnersBook.com"; >public static void main(String[] args) < Hello obj = new Hello(); System.out.println(obj.name); >>

Types of Constructors

There are three types of constructors: Default, No-arg constructor and Parameterized.

Default constructor

If you do not implement any constructor in your class, Java compiler inserts a default constructor into your code on your behalf. This constructor is known as default constructor. You would not find it in your source code(the java file) as it would be inserted into the code during compilation and exists in .class file. This process is shown in the diagram below:

If you implement any constructor then you no longer receive a default constructor from Java compiler.

no-arg constructor:

Constructor with no arguments is known as no-arg constructor. The signature is same as default constructor, however body can have any code unlike default constructor where the body of the constructor is empty.

Although you may see some people claim that that default and no-arg constructor is same but in fact they are not, even if you write public Demo() in your class Demo it cannot be called default constructor since you have written the code of it.

Example: no-arg constructor

class Demo < public Demo() < System.out.println("This is a no argument constructor"); >public static void main(String args[]) < new Demo(); >>

Output:
This is a no argument constructor

Parameterized constructor

Constructor with arguments(or you can say parameters) is known as Parameterized constructor.

Example: parameterized constructor

In this example we have a parameterized constructor with two parameters id and name . While creating the objects obj1 and obj2 I have passed two arguments so that this constructor gets invoked after creation of obj1 and obj2.

public class Employee < int empId; String empName; //parameterized constructor with two parameters Employee(int id, String name)< this.empId = id; this.empName = name; >void info() < System.out.println("Id: "+empId+" Name: "+empName); >public static void main(String args[]) < Employee obj1 = new Employee(10245,"Chaitanya"); Employee obj2 = new Employee(92232,"Negan"); obj1.info(); obj2.info(); >>

Id: 10245 Name: Chaitanya Id: 92232 Name: Negan

Example2: parameterized constructor

In this example, we have two constructors, a default constructor and a parameterized constructor. When we do not pass any parameter while creating the object using new keyword then default constructor is invoked, however when you pass a parameter then parameterized constructor that matches with the passed parameters list gets invoked.

class Example2 < private int var; //default constructor public Example2() < this.var = 10; >//parameterized constructor public Example2(int num) < this.var = num; >public int getValue() < return var; >public static void main(String args[]) < Example2 obj = new Example2(); Example2 obj2 = new Example2(100); System.out.println("var is: "+obj.getValue()); System.out.println("var is: "+obj2.getValue()); >>

What if you implement only parameterized constructor in class

class Example3 < private int var; public Example3(int num) < var=num; >public int getValue() < return var; >public static void main(String args[]) < Example3 myobj = new Example3(); System.out.println("value of var is: "+myobj.getValue()); >>

Output: It will throw a compilation error. The reason is, the statement Example3 myobj = new Example3() is invoking a default constructor which we don’t have in our program. when you don’t implement any constructor in your class, compiler inserts the default constructor into your code, however when you implement any constructor (in above example I have implemented parameterized constructor with int parameter), then you don’t receive the default constructor by compiler into your code.

If we remove the parameterized constructor from the above code then the program would run fine, because then compiler would insert the default constructor into your code.

Constructor Chaining

When A constructor calls another constructor of same class then this is called constructor chaining. Read more about it here.

Super()

Whenever a child class constructor gets invoked it implicitly invokes the constructor of parent class. You can also say that the compiler inserts a super(); statement at the beginning of child class constructor.

class MyParentClass < MyParentClass()< System.out.println("MyParentClass Constructor"); >> class MyChildClass extends MyParentClass < MyChildClass() < System.out.println("MyChildClass Constructor"); >public static void main(String args[]) < new MyChildClass(); >>

MyParentClass Constructor MyChildClass Constructor

Constructor Overloading

Constructor overloading is a concept of having more than one constructor with different parameters list, in such a way so that each constructor performs a different task.

Refer constructor overloading with example for more details with example.

Java Copy Constructor

A copy constructor is used for copying the values of one object to another object. Java doesn’t have a concept of copy constructor like C++, however there are certain ways by which you can copy the values of one object to another object:

• By creating a parameterized constructor with class reference as parameter.
• By using clone() method of the Object class.
• By assigning the values from one object to another object.

class JavaExample < String web; JavaExample(String w)< web = w; >/* This is the Copy Constructor, it * copies the values of one object * to the another object (the object * that invokes this constructor) */ JavaExample(JavaExample je) < web = je.web; >void disp() < System.out.println("Website: "+web); >public static void main(String args[]) < JavaExample obj1 = new JavaExample("BeginnersBook"); /* Passing the object as an argument to the constructor * This will invoke the copy constructor */ JavaExample obj2 = new JavaExample(obj1); obj1.disp(); obj2.disp(); >>

Website: BeginnersBook Website: BeginnersBook

Quick Recap

1. Every class has a constructor whether it’s a normal class or a abstract class.
2. Constructors are not methods and they don’t have any return type.
3. Constructor name should match with class name .
4. Constructor can use any access specifier, they can be declared as private also. Private constructors are possible in java but there scope is within the class only.
5. Like constructors method can also have name same as class name, but still they have return type, though which we can identify them that they are methods not constructors.
6. If you don’t implement any constructor within the class, compiler will do it for.
7. this() and super() should be the first statement in the constructor code. If you don’t mention them, compiler does it for you accordingly.
8. Constructor overloading is possible but overriding is not possible. Which means we can have overloaded constructor in our class but we can’t override a constructor.
9. Constructors can not be inherited.
10. If Super class doesn’t have a no-arg(default) constructor then compiler would not insert a default constructor in child class as it does in normal scenario.
11. Interfaces do not have constructors.
12. Abstract class can have constructor and it gets invoked when a class, which implements interface, is instantiated. (i.e. object creation of concrete class).
13. A constructor can also invoke another constructor of the same class – By using this(). If you want to invoke a parameterized constructor then do it like this: this(parameter list).

More on Constructor:

Difference between Constructor and Method

I know I should have mentioned it at the beginning of this guide but I wanted to cover everything in a flow. Hope you don’t mind 🙂

1. The purpose of constructor is to initialize the object of a class while the purpose of a method is to perform a task by executing java code.
2. Constructors cannot be abstract, final, static and synchronised while methods can be.
3. Constructors do not have return types while methods do.

Top Related Articles:

About the Author

I have 15 years of experience in the IT industry, working with renowned multinational corporations. Additionally, I have dedicated over a decade to teaching, allowing me to refine my skills in delivering information in a simple and easily understandable manner.

Comments

concepts explained in a simple and effective manner, its very nice as all small minute discussions are also provided and explained in a systematic way with examples ,this site really helps beginners to have good knowledge of java .

Awesome tutorial you have explained all the concept with practically step by step:- keep it good work

hi sir,it’s very useful.easy to learn.can you explain more clearly about method overriding in java with example and it’s usage! please!!

What happens when super class only has parameterized constructors and child constructor does not evoke super(parameter) explicitly?

Great, pls I am a graphic designer and beginning to learn programming, can you pls help me understand the basics such as objects, methods

Hii,Chaitanya please provide next page option at the bottom.so that it will be easy for the readers.
Thank you

I am working on it. I am updating the old guides and tutorials with the latest info and diagrams. Along with this I am adding next and prev links at the end of each guide. It will take some time. Thanks for sharing the concern. Happy Learning!

Источник

Java Constructors

A constructor in Java is similar to a method that is invoked when an object of the class is created.

Unlike Java methods, a constructor has the same name as that of the class and does not have any return type. For example,

Here, Test() is a constructor. It has the same name as that of the class and doesn’t have a return type.

Example 1: Java Constructor

class Main < private String name; // constructor Main() < System.out.println("Constructor Called:"); name = "Programiz"; >public static void main(String[] args) < // constructor is invoked while // creating an object of the Main class Main obj = new Main(); System.out.println("The name is " + obj.name); >>

Constructor Called: The name is Programiz

In the above example, we have created a constructor named Main() . Inside the constructor, we are initializing the value of the name variable.

Notice the statement of creating an object of the Main class.

Here, when the object is created, the Main() constructor is called. And, the value of the name variable is initialized.

Hence, the program prints the value of the name variables as Programiz .

Types of Constructor

In Java, constructors can be divided into 3 types:

1. Java No-Arg Constructors

Similar to methods, a Java constructor may or may not have any parameters (arguments).

If a constructor does not accept any parameters, it is known as a no-argument constructor. For example,

Example 2: Java private no-arg constructor

class Main < int i; // constructor with no parameter private Main() < i = 5; System.out.println("Constructor is called"); >public static void main(String[] args) < // calling the constructor without any parameter Main obj = new Main(); System.out.println("Value of i: " + obj.i); >>

Constructor is called Value of i: 5

In the above example, we have created a constructor Main() . Here, the constructor does not accept any parameters. Hence, it is known as a no-arg constructor.

Notice that we have declared the constructor as private.

Once a constructor is declared private , it cannot be accessed from outside the class. So, creating objects from outside the class is prohibited using the private constructor.

Here, we are creating the object inside the same class. Hence, the program is able to access the constructor. To learn more, visit Java Implement Private Constructor.

However, if we want to create objects outside the class, then we need to declare the constructor as public .

Example 3: Java public no-arg constructors

class Company < String name; // public constructor public Company() < name = "Programiz"; >> class Main < public static void main(String[] args) < // object is created in another class Company obj = new Company(); System.out.println("Company name /java-programming/access-modifiers">Java Access Modifier
 
2. Java Parameterized Constructor
 
A Java constructor can also accept one or more parameters. Such constructors are known as parameterized constructors (constructor with parameters).
 
Example 4: Parameterized constructor
 
class Main < String languages; // constructor accepting single value Main(String lang) < languages = lang; System.out.println(languages + " Programming Language"); >public static void main(String[] args) < // call constructor by passing a single value Main obj1 = new Main("Java"); Main obj2 = new Main("Python"); Main obj3 = new Main("C"); >>
 
Java Programming Language Python Programming Language C Programming Language
 
In the above example, we have created a constructor named Main() . Here, the constructor takes a single parameter. Notice the expression,
 
Here, we are passing the single value to the constructor. Based on the argument passed, the language variable is initialized inside the constructor.
 
3. Java Default Constructor
 
If we do not create any constructor, the Java compiler automatically create a no-arg constructor during the execution of the program. This constructor is called default constructor.
 
Example 5: Default Constructor
 
Programming Language: Java Programming Language: Python
 
In the above example, we have two constructors: Main() and Main(String language) . Here, both the constructor initialize the value of the variable language with different values.
 
Based on the parameter passed during object creation, different constructors are called and different values are assigned.
 
It is also possible to call one constructor from another constructor. To learn more, visit Java Call One Constructor from Another.
 
Note: We have used this keyword to specify the variable of the class. To know more about this keyword, visit Java this keyword.
 
Table of Contents
 
Источник