Java program to swap two numbers

This java program swaps two numbers using a temporary variable. To swap numbers without using extra variable see another code below.

Swapping using temporary or third variable

import java.util.Scanner;   
class SwapNumbers { 
public static void main(String args[]) { 
int x, y, temp; 
System.out.println("Enter x and y"); 
Scanner in = new Scanner(System.in);   
x = in.nextInt(); 
y = in.nextInt();   
System.out.println("Before Swapping\nx = "+x+"\ny = "+y);   
temp = x; 
x = y; 
y = temp;   
System.out.println("After Swapping\nx = "+x+"\ny = "+y); 
} 
}

Output of program:

Swapping without temporary variable

import java.util.Scanner;   
class SwapNumbers { 
public static void main(String args[]) { 
int x, y; 
System.out.println("Enter x and y"); 
Scanner in = new Scanner(System.in);   
x = in.nextInt(); 
y = in.nextInt();   
System.out.println("Before Swapping\nx = "+x+"\ny = "+y);   
x = x + y; 
y = x - y; 
x = x - y;   
System.out.println("After Swapping\nx = "+x+"\ny = "+y); 
} 
}

Swapping is frequently used in sorting techniques such as bubble sort, quick sort etc.

Read More

Java exception handling tutorial with example programs

In this tutorial we will learn how to handle exception with the help of suitable examples. Exceptions are errors which occur when the program is executing. Consider the Java program below which divides two integers.

import java.util.Scanner;
 
class Division {
 public static void main(String[] args) {
 
 int a, b, result;
 
 Scanner input = new Scanner(System.in);
 System.out.println("Input two integers");
 
 a = input.nextInt();
 b = input.nextInt();
 
 result = a / b;
 
 System.out.println("Result = " + result);
 }
}

Now we compile and execute the above code two times, see the output of program in two cases:

In the second case we are dividing a by zero which is not allowed in mathematics, so a run time error will occur i.e. an exception will occur. If we write programs in this way then they will be terminated abnormally and user who is executing our program or application will not be happy. This occurs because input of user is not valid so we have to take a preventive action and the best thing will be to notify the user that it is not allowed or any other meaningful message which is relevant according to context. You can see the information displayed when exception occurs it includes name of thread, file name, line of code (14 in this case) at which exception occurred, name of exception (ArithmeticException) and it's description('/ by zero'). Note that exceptions don't occur only because of invalid input only there are other reasons which are beyond of programmer control such as stack overflow exception, out of memory exception when an application requires memory larger than what is available.

Java provides a powerful way to handle such exceptions which is known as exception handling. In it we write vulnerable code i.e. code which can throw exception in a separate block called as try block and exception handling code in another block called catch block. Following modified code handles the exception.

Java exception handling example

class Division { 
public static void main(String[] args) { 
int a, b, result;   
Scanner input = new Scanner(System.in); 
System.out.println("Input two integers");   
a = input.nextInt(); 
b = input.nextInt();   
// try block   
try { 
result = a / b; 
System.out.println("Result = " + result); 
}   
// catch block   
catch (ArithmeticException e) { 
System.out.println("Exception caught: Division by zero."); 
} 
} 
}

Whenever an exception is caught corresponding catch block is executed, For example above code catches ArithmeticException only. If some other kind of exception is thrown it will not be caught so it's the programmer work to take care of all exceptions as in our try block we are performing arithmetic so we are capturing only arithmetic exceptions. A simple way to capture any exception is to use an object of Exception class as other classes inherit Exception class, see another example below:

class Exceptions { 
public static void main(String[] args) { 
String languages[] = { "C", "C++", "Java", "Perl", "Python" }; 
try { 
for (int c = 1; c <= 5; c++) { 
System.out.println(languages[c]); 
} 
} 
catch (Exception e) { 
System.out.println(e); 
} 
} 
}

Output of program:

C++
Java
Perl
Python
java.lang.ArrayIndexOutOfBoundsException: 5

Here our catch block capture an exception which occurs because we are trying to access an array element which does not exists (languages in this case). Once an exception is thrown control comes out of try block and remaining instructions of try block will not be executed. At compilation time syntax and semantics checking is done and code is not executed on machine so exceptions can only be detected at run time.

Finally block in Java

Finally block is always executed whether an exception is thrown or not.

class Allocate { 
public static void main(String[] args) {   
try { 
long data[] = new long[1000000000]; 
} 
catch (Exception e) { 
System.out.println(e); 
}   
finally { 
System.out.println("finally block will execute always."); 
} 
} 
}

Output of program:

finally block will execute always.
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at Allocate.main(Allocate.java:5)

Exception occurred because we try to allocate a large amount of memory which is not available. This amount of memory may be available on your system if this is the case try increasing the amount of memory to allocate through the program.

Read More

Using multiple classes in Java program

Java program can contain more than one i.e. multiple classes. Following example Java program contain two classes: Computer and Laptop. Both classes have their own constructors and a method. In main method we create object of two classes and call their methods.

Using two classes in Java program

class Computer
{

Computer() { 
System.out.println("Constructor of Computer class."); 
}   
void computer_method() { 
System.out.println("Power gone! Shut down your PC soon..."); 
}   
public static void main(String[] args) { 
Computer my = new Computer(); 
Laptop your = new Laptop();   
my.computer_method(); 
your.laptop_method(); 
} 
}   
class Laptop { 
Laptop() { 
System.out.println("Constructor of Laptop class."); 
}   
void laptop_method() { 
System.out.println("99% Battery available."); 
} 
}

Output of program:


You can also create objects in method of Laptop class. When you compile above code two .class files will be created which are Computer.class and Laptop.class, this has the advantage that you can reuse your .class file somewhere in other projects without compiling the code again. In short number of .class files created will be equal to number of classes in code. You can create as many classes as you want but writing many classes in a single file is not recommended as it makes code difficult to read rather you can create single file for every class. You can also group classes in packages for easily managing your code.

Read More

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