Java constructor tutorial with code examples

Java constructors are the methods which are used to initialize objects. Constructor method has the same name as that of class, they are called or invoked when an object of class is created and can't be called explicitly. Attributes of an object may be available when creating objects if no attribute is available then default constructor is called, also some of the attributes may be known initially. It is optional to write constructor method in a class but due to their utility they are used.

Java constructor example

class Programming { 
//constructor method 
Programming() { 
System.out.println("Constructor method called."); 
} 
public static void main(String[] args) { 
Programming object = new Programming(); 
//creating object 
} 
}

Output of program:

This code is the simplest example of constructor, we create class Programming and create an object, constructor is called when object is created. As you can see in output "Constructor method called." is printed.

Java constructor overloading

Like other methods in java constructor can be overloaded i.e. we can create as many constructors in our class as desired. Number of constructors depends on the information about attributes of an object we have while creating objects. See constructor overloading example:

class Language {

 String name;
 
 Language() {
 System.out.println("Constructor method called.");
 }
 
 Language(String t) {
 name = t;
 }
 
 public static void main(String[] args) {
 Language cpp = new Language();
 Language java = new Language("Java");
 
 cpp.setName("C++");
 
 java.getName();
 cpp.getName();
 }
 
 void setName(String t) {
 name = t;
 }
 
 void getName() {
 System.out.println("Language name: " + name);
 }
}

Output of program:


When cpp object is created default constructor is called and when java object is created constructor with argument is called, setName method is used to set 'name' attribute of language, getName method prints language name.

Java constructor chaining

Constructor chaining occurs when a class inherits another class i.e. in inheritance, as in inheritance sub class inherits the properties of super class. Both the super and sub class may have constructor methods, when an object of sub class is created it's constructor is invoked it initializes sub class attributes, now super class constructor needs to be invoked, to achieve this java provides a super keyword through which we can pass arguments to super class constructor. For more understanding see constructor chaining example:

class GrandParent {

 int a;
 
 GrandParent(int a) {
 this.a = a;
 }
}
 
class Parent extends GrandParent {
 int b;
 
 Parent(int a, int b) {
 super(a);
 this.b = b;
 }
 
 void show() {
 System.out.println("GrandParent's a = " + a);
 System.out.println("Parent's b = " + b);
 }
}
 
class Child {
 public static void main(String[] args) {
 Parent object = new Parent(8, 9);
 object.show();
 }
}

Output of program:

Constructor method doesn't specify a return type, they return instance of class itself.

Read More

Java static method

Static methods in Java can be called without creating an object of class. Have you noticed why we write static keyword when defining main it's because program execution begins from main and no object has been created yet. Consider the example below to improve your understanding of static methods.

Java static method example program

class Languages { 
public static void main(String[] args) { 
display(); 
}
 static void display() {
 System.out.println("Java is my favorite programming language.");
 }
}

Output of program:

Java static method vs instance method

Instance method requires an object of its class to be created before it can be called while static method doesn't require object creation.

class Difference {
 public static void main(String[] args) {
 display(); //calling without object
 Difference t = new Difference();
 t.show(); //calling using object
 }
 
 static void display() {
 System.out.println("Programming is amazing.");
 }
 
 void show(){
 System.out.println("Java is awesome.");
 }
}

Output of code:

Using static method of another classes

If you wish to call static method of another class then you have to write class name while calling static method as shown in example below.

import java.lang.Math;
class Another {
 public static void main(String[] args) {
 int result;
 
 result = Math.min(10, 20); //calling static method min by writing class name
 
 System.out.println(result);
 System.out.println(Math.max(100, 200));
 }
}

Output of program:
10 200

Here we are using min and max methods of Math class, min returns minimum of two integers and max returns maximum of two integers. Following will produce an error:

min();

We need to write class name because many classes may have a method with same name which we are calling.

Read More

Java static block program

Java programming language offers a block known as static which is executed before main method executes. Below is the simplest example to understand functioning of static block later we see a practical use of static block.

Java static block program

class StaticBlock { 
public static void main(String[] args) { 
System.out.println("Main method is executed.");
} 
static { 
System.out.println("Static block is executed before main method."); 
} 
}

Output of progam:


Static block can be used to check conditions before execution of main begin, Suppose we have developed an application which runs only on Windows operating system then we need to check what operating system is installed on user machine. In our java code we check what operating system user is using if user is using operating system other than "Windows" then the program terminates.

class StaticBlock {
 public static void main(String[] args) {
 System.out.println("You are using Windows_NT operating system.");
 }
 
 static {
 String os = System.getenv("OS");
 if (os.equals("Windows_NT") != true) {
 System.exit(1);
 }
 }
}

We are using getenv method of System class which returns value of environment variable name of which is passed an as argument to it. Windows_NT is a family of operating systems which includes Windows XP, Vista, 7, 8 and others.

Output of program on Windows 7:

Read More

Java methods

Java program consists of one or more classes and a class may contain method(s). A class can do very little without methods. In this tutorial we will learn about Java methods.Methods are known as functions in C and C++ programming languages. A method has a name and return type. Main method is a must in a Java program as execution begins from it.

Syntax of methods

"Access specifier" "Keyword(s)" "return type" methodName(List of arguments) {
// Body of method
}

Access specifier can be public or private which decides whether other classes can call a method.
Kewords are used for some special methods such as static or synchronized.
Return type indicate return value which method returns.
Method name is a valid Java identifier name.

Access specifier, Keyword and arguments are optional.Examples of methods declaration:

public static void main(String[] args);
void myMethod();
private int maximum();
public synchronized int search(java.lang.Object);

Java Method example program

class Methods { 
// Constructor method
Methods() { 
System.out.println("Constructor method is called when an object of it's class is created");
} 
// Main method where program execution begins
public static void main(String[] args) { 
staticMethod(); 
Methods object = new Methods(); 
object.nonStaticMethod(); 
}  
// Static method  
static void staticMethod() { 
System.out.println("Static method can be called without creating object"); 
}  
// Non static method  
void nonStaticMethod() { 
System.out.println("Non static method must be called by creating an object"); 
} 
}

Output of program:

Java methods list

Java has a built in library of many useful classes and there are thousands of methods which can be used in your programs. Just call a method and get your work done :) . You can find list of methods in a class by typing following command on command prompt:

javap package.classname

For example

javap java.lang.String // list all methods and constants of String class.
javap java.math.BigInteger // list constants and methods of BigInteger class in java.math package

Java String methods

String class contains methods which are useful for performing operations on String(s). Below program illustrate how to use inbuilt methods of String class.

Java string class program

class StringMethods { 
public static void main(String args[]) { 
int n; 
String s = "Java programming", t = "", u = "";   
System.out.println(s);   

// Find length of string   

n = s.length(); 
System.out.println("Number of characters = " + n);   

// Replace characters in string   

t = s.replace("Java", "C++"); 
System.out.println(s); 
System.out.println(t);   

// Concatenating string with another string   

u = s.concat(" is fun"); 
System.out.println(s); 
System.out.println(u); 
} 
}

Output of program:

Read More

Java program to convert Fahrenheit to Celsius

Java program to convert Fahrenheit to Celsius: This code does temperature conversion from Fahrenheit scale to Celsius scale.

Java programming code

import java.util.*;

class FahrenheitToCelsius { 
public static void main(String[] args) { 
float temperatue; Scanner in = new Scanner(System.in);   
System.out.println("Enter temperatue in Fahrenheit"); 
temperatue = in.nextInt();   
temperatue = ((temperatue - 32)*5)/9;   
System.out.println("Temperatue in Celsius = " + temperatue); 
} 
}

Output of program:



For Celsius to Fahrenheit conversion use
T = 9*T/5 + 32
where T is temperature on Celsius scale. Create and test Fahrenheit to Celsius program yourself for practice.

Read More