Java Tutorial

This Java tutorial is tailored for newcomers, offering a journey from basic principles to complex Java programming techniques. Completing this tutorial equips you with a solid understanding of Java, preparing you for advanced learning. You'll emerge ready to tackle the challenges of becoming a top-tier software engineer, with the skills to innovate and excel in the vast world of software development.

Constructors
Java Constructors
Java constructors are special types of methods that are used to initialize an object when it is created. It has the same name as its class and is syntactically similar to a method. However, constructors have no explicit return type.
Typically, you will use a constructor to give initial values to the instance variables defined by the class or to perform any other start up procedures required to create a fully formed object.
All classes have constructors, whether you define one or not because Java automatically provides a default constructor that initializes all member variables to zero. However, once you define your constructor, the default constructor is no longer used.
Rules for Creating Java Constructors
You must follow the below-given rules while creating Java constructors:
The name of the constructors must be the same as the class name.
Java constructors do not have a return type. Even do not use void as a return type.
There can be multiple constructors in the same class, this concept is known as constructor overloading.
The access modifiers can be used with the constructors, use if you want to change the visibility/accessibility of constructors.
Java provides a default constructor that is invoked during the time of object creation. If you create any type of constructor, the default constructor (provided by Java) is not invoked.
Creating a Java Constructor
To create a constructor in Java, simply write the constructor's name (that is the same as the class name) followed by the brackets and then write the constructor's body inside the curly braces ({}).
Syntax
Following is the syntax of a constructor 
class ClassName {
   ClassName() {
   }
}
Example to create a Java Constructor
The following example creates a simple constructor that will print "Hello world".
public class Main {
  // Creating a constructor
  Main() {
    System.out.println("Hello, World!");
  }
﻿
  public static void main(String[] args) {
    System.out.println("The main() method.");
﻿
    // Creating a class's object
    // that will invoke the constructor
    Main obj_x = new Main();
  }
}
This program will print:
The main() method.
Hello, World!
Types of Java Constructors
There are three different types of constructors in Java, we have listed them as follows:
Default Constructor
No-Args Constructor
Parameterized Constructor
﻿
1. Default Constructor
If you do not create any constructor in the class, Java provides a default constructor that initializes the object.
Example: Default Constructor (A Class Without Any Constructor)
In this example, there is no constructor defined by us. The default constructor is there to initialize the object.
public class Main {
  int num1;
  int num2;
﻿
  public static void main(String[] args) {
    // We didn't created any structure
    // a default constructor will invoke here
    Main obj_x = new Main();
﻿
    // Printing the values
    System.out.println("num1 : " + obj_x.num1);
    System.out.println("num2 : " + obj_x.num2);
  }
}
Output
num1 : 0
num2 : 0
2. No-Args (No Argument) Constructor
As the name specifies, the No-argument constructor does not accept any argument. By using the No-Args constructor you can initialize the class data members and perform various activities that you want on object creation.
Example: No-Args Constructor
This example creates no-args constructor.
public class Main {
  int num1;
  int num2;
﻿
  // Creating no-args constructor
  Main() {
    num1 = -1;
    num2 = -1;
  }
﻿
  public static void main(String[] args) {
    // no-args constructor will invoke
    Main obj_x = new Main();
﻿
    // Printing the values
    System.out.println("num1 : " + obj_x.num1);
    System.out.println("num2 : " + obj_x.num2);
  }
}
Output
num1 : -1
num2 : -1
3. Parameterized Constructor
A constructor with one or more arguments is called a parameterized constructor.
Most often, you will need a constructor that accepts one or more parameters. Parameters are added to a constructor in the same way that they are added to a method, just declare them inside the parentheses after the constructor's name.
Example 1: Parameterized Constructor
This example creates a parameterized constructor.
public class Main {
  int num1;
  int num2;
﻿
  // Creating parameterized constructor 
  Main(int a, int b) {
    num1 = a;
    num2 = b;
  }
﻿
  public static void main(String[] args) {
    // Creating two objects by passing the values 
    // to initialize the attributes.
    // parameterized constructor will invoke
    Main obj_x = new Main(10, 20);
    Main obj_y = new Main(100, 200);
﻿
    // Printing the objects values
    System.out.println("obj_x");
    System.out.println("num1 : " + obj_x.num1);
    System.out.println("num2 : " + obj_x.num2);
﻿
    System.out.println("obj_y");
    System.out.println("num1 : " + obj_y.num1);
    System.out.println("num2 : " + obj_y.num2);
  }
}
Output
obj_x
num1 : 10
num2 : 20
obj_y
num1 : 100
num2 : 200
Example 2: Parameterized Constructor
Here is a simple example that uses a constructor 
// A simple constructor.
class MyClass {
   int x;
   
   // Following is the constructor
   MyClass(int i ) {
      x = i;
   }
}
You would call constructor to initialize objects as follows −
public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass( 10 );
      MyClass t2 = new MyClass( 20 );
      System.out.println(t1.x + " " + t2.x);
   }
}
Output
10 20
Constructor Overloading in Java
Constructor overloading means multiple constructors in a class. When you have multiple constructors with different parameters listed, then it will be known as constructor overloading.
Example: Constructor Overloading
In this example, we have more than one constructor.
// Example of Java Constructor Overloading
// Creating a Student Class
class Student {
  String name;
  int age;
﻿
  // no-args constructor
  Student() {
    this.name = "Unknown";
    this.age = 0;
  }
﻿
  // parameterized constructor having one parameter
  Student(String name) {
    this.name = name;
    this.age = 0;
  }
﻿
  // parameterized constructor having both parameters
  Student(String name, int age) {
    this.name = name;
    this.age = age;
  }
﻿
  public void printDetails() {
    System.out.println("Name : " + this.name);
    System.out.println("Age : " + this.age);
  }
}
﻿
public class Main {
  public static void main(String[] args) {
    Student std1 = new Student(); // invokes no-args constructor
    Student std2 = new Student("Jordan"); // invokes parameterized constructor
    Student std3 = new Student("Paxton", 25); // invokes parameterized constructor
﻿
    // Printing details
    System.out.println("std1...");
    std1.printDetails();
﻿
    System.out.println("std2...");
    std2.printDetails();
﻿
    System.out.println("std3...");
    std3.printDetails();
  }
}
Output
td1...
Name : Unknown
Age : 0
std2...
Name : Jordan
Age : 0
std3...
Name : Paxton
Age : 25
﻿
﻿
﻿
﻿

Java Tutorial

Java Control Statements

Object Oriented Programming

Java Built-in Classes

Java File Handling

Java Error & Exceptions

Java Multithreading

Java Synchronization

Java Networking

Java Collections

Java List Interface

Java Queue Interface

Java Map Interface

Java Set Interface

Java Data Structures

Java Collections Algorithms

Java Miscellaneous

Java Tutorial

Constructors

Java Constructors

Rules for Creating Java Constructors

Creating a Java Constructor

Syntax

Example to create a Java Constructor

Types of Java Constructors

1. Default Constructor

Example: Default Constructor (A Class Without Any Constructor)

2. No-Args (No Argument) Constructor

Example: No-Args Constructor

3. Parameterized Constructor

Example 1: Parameterized Constructor

Example 2: Parameterized Constructor

Constructor Overloading in Java

Example: Constructor Overloading