To create a class variable or method, include the word static in front of the method’s name. The modifier static typically comes after any protection modifiers. Given below is an example that illustrates how a class variable may be created in a program. [Read more…] about Class variables and methods in Java
accessor methods in Java
Accessor methods are used for initializing and accessing the value of instance variables. The value of these instance variables can be used further in the program. For creating accessor methods, it is required to create two methods among which one method is used to initialize the value and other is used to retrieve the value. An accessor method makes the program more readable and understandable. Moreover, accessor methods are similar to any other method, as can be seen from Program.
Implementing accessor methods.
// A program to find area of a square.
import java.io.*;
class AccessorMethodClass
{
int side;
//This method is used for initializing the value of global variable ‘side’
public void setSideValue(int a)
{
side = a;
}
// This method is used for getting the value of the global value
public int getSideValue()
{
return side:
}
public static void main(String args[ ])
{
int area, side;
accessorMethodClass ob=new accessorMethodClass();
ob.setSideValue(10); // Initializing the value of global variable
side = ob.getSideValue(}; // Retrieving the value of Global variable
area = side * side; // Finding the area of square.
System.out.println(“The area of Square is” +area);
}
}
The output of Program is as shown below:
The area of Square is 100
In Program the global variable side is initialized by the method setSideValue(int a) and its value is retrieved by the method getSideValue(). Here, the words like set and get make the functionality of accessor methods more clear even though it is not a part of any rules or specifications.
Accessor methods can also have names similar to their instance variable and Java performs the appropriate operation based on the use of these methods and variables, as shown in Program.
Using accessor methods II.
// A program to find the area of a square which is equal to square of the side.
import java.io.*;
class AccessorMethodClass
{
int side;
// Note that method name and variable name is same
public void side(int a)
{
side = a;
}
public int getSideValue()
{
return side;
}
public static void main(String args[])
{
int area, sidevalue;
AccessorMethodClass ob = new AccessorMethodClass();
ob.side(10);
sidevalue = ob.getSideValue{);
area = sidevalue*sidevalue;
System.out.println(“The area of Square is”+area);
}
}
The output of Program is as shown below:
The area of Square is 100
There are some problems with the convention used for having same name as described in the above program.
• Using same name for the instance variable and method may make the program less readable and understandable. Providing meaningful names to the variables and methods with respect to their functionality is a good programming practice.
• Adopting this type of convention violates the essentials of structured programming.
What is Methods in Java ? – Definition (With Examples)
A Java method is a collection of statements, all performing a particular operation. Let’s say that you were calling the method called System.out.println(); Java executes some different statements that print a message to your console. We’re going to look at the creation of methods or, as they often called, functions. [Read more…] about What is Methods in Java ? – Definition (With Examples)
Example of Super Method in Java
Static Method and Static Variable in Java Example
Since the string variable str is static, it is initialized to “This is second line displayed” (static variables are initialized before an object is initiated). Then, the static block is executed which will invoke the disp() method displaying the message: “This is first line displayed”. Static() method can be invoked without the need of any object. In main(), again disp() method is called with the string str (This is second line displayed). After that an object SMV is made, and it will get a member str2 initialized to “This is last line displayed”. Then disp() is called with SMV. str2 which displays: This is last line displayed on the screen [Read more…] about Static Method and Static Variable in Java Example
Tail Recursion in java
Tail recursion occurring when the recursive call is at the end of the recursive instruction. This eliminates the potential problem of stack overflow. A call is tail recursive if nothing has to be done after the call returns. i.e. when the call returns, the returned value is immediately returned from the calling method.
Greatest Common Divisor Using Recursion Java Example
Reverse the Digits of a Number Using Recursion | Java Example
In this program, user is asked a number to enter which is stored in integer form in variable n. The value entered is say 1023.Now, this value of variable n is passed to parameter x by invoking revers() method. In revers() method, x is divided by 10 and the remainder is displayed (% returns remainder). When 1023 is divided by 10, the remainder will be 3 which is displayed on the screen. Then, again revers() is invoked with value 102/10 i.e. with 102 (because the output of dividing two integers is also an integer). 102 is assigned to variable x. Again, 102 is divided by 10 and the remainder is displayed. The remainder this time will be 2 which is displayed. Again revers() method is invoked with 10/10 i.e. which 1. And the process continues until value of x becomes 0.
Here is the Java Example for ReverseDigits:
import java.io.*;
class ReverseDigits
{
void revers(int x)
{
if(x==0) return;
else
{
System.out.print(x%10);
revers(x/10);
}
}
public static void main(String args[])
throws IOException
{
ReverseDigits Digit = new ReverseDigits();
BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
String h;
int n;
System.out.print("Enter a number to Reverse : ");
h=bf.readLine();
n=Integer.parseInt(h);
System.out.print("The Reverse Number is : ");
Digit.revers(n);
}
}
Recursion in Java with Example
Recursion occurs when a function calls itself in its own body. That is, in the body of the function definition there is a call to itself. When the function calls itself in its body, it results in an infinite loop. So, there has to be an exit condition in every recursive program.
The case in which the recursion ends is called a base case. In every recursive program, the problem is broken into small pieces so as to bring it closer to the base case.
Methods/Functions have locally defined variables (or objects) which have no existence outside the function. Each time a function is invoked recursively, a new set of variables (or objects) are created. Although they have the same names, their values are preserved till the end of the recursion. So, to implement recursion, the language has to take the help of stack to keep track of objects and statements of each recursive call.
Demonstrating the Concept of Recursion
class ConceptofRecursion
{
void display(int x,int y)
{
if(x<1) return;
System.out.println("Value of x : "+ x );
display(x-1,y+1);
System.out.println("Value of y :"+y);
}
public static void main(String args[])
{
ConceptofRecursion Recursion = new ConceptofRecursion();
Recursion.display(5,1);
}
}
As, we can see in the above program, that the method display () is invoked with two arguments 5 and 1 which will be assigned to parameters x and y respectively. In display () method, value of x is displayed which prints following message on the screen : Value of x: 5
Then again display () is invoked with values 4 and 2 (because value of x is decremented and value of y is incremented by 1 while invoking the display (). But because of the recursive call, one statement of the program couldn’t execute, that statement is:
System.out.println(“Value of y :”+y);
So, the message: Value of y : 1 is pushed on to the stack.
By the recursive call, the values 4 and 2 will be assigned to parameters x and y respectively. Here, value of x is displayed which prints following message on the screen:
Value of x: 4
Again, display () is invoked with values 3 and 3 (because value of x is decremented and value of y is incremented by 1 while invoking the display () . But again, because of the recursive call, the following statement couldn’t execute:
System.out.println(“Value of y :”+y);
So, the message: Value of y: 2 is pushed on to the stack (above the message Value of y : 1) and so on. Hence, 5 messages will be pushed onto the stack which couldn’t execute as shown:
Disadvantages of Recursion
1. The problem of stack overflow occurs in case of infinite recursion
2. Recursion can be slower to run than simple iteration.
3. The recursive version is usually less efficient because of having to push and pop values on and off the run-time stack, so iteration is quicker.
Advantages of Recursion
1. It is easier to code a recursive solution.
2. The recursive code is usually smaller, more concise, and more elegant.
3. There are some real time problems that are very difficult to solve without recursion.
Passing Arguments to a Method in Java Example
There are two ways of passing arguments to a method (function/subroutine):
1. Call by Value
This method copies the value of an argument into the formal parameter of the method. Therefore, changes made to the parameter of the method are limited to that method only and there is no impact of changes on the argument. That is, when control returns back to the caller method, earlier values of the arguments will be seen.
2. Call by Reference
In this method, a reference to an argument (not the value of the argument) is passed to the parameter. Inside the method, this reference is used to access the actual argument specified in the call. This means that changes made to the parameter will affect the actual argument also. When the control returns back to the caller method, the changes made in the method can be seen in the arguments in the caller method too.
In Java, when we pass a simple type to a method, it is passed by value. When we create a variable of a class, we are only creating a reference to an object. Thus, when we pass this reference method, the parameter that receives it will refer to the same object as that referred by the argument. This means that objects are passed to methods by reference.
Demonstration of Pass by Reference
class Passby
{
int a,b;
void setdata(int x, int y)
{
a = x;
b = y;
}
void display(Passby m)
{
m.a =m.a+10;
m.b=m.b-5;
}
}
class PassbyRef
{
public static void main(String args[])
{
Passby Ref =new Passby();
Ref.setdata(50,100);
System.out.println(“Before Function Call: a=” + Ref.a +” b= ” + Ref.b) ;
Ref.display(Ref);
System.out.println(“After Function Call: a=” + Ref.a +” b= ” + Ref.b) ;
}
}
Output
Before Function Call: a = 50 b= 100
After Function Call: a = 60 b= 95
In above program, first an instance of class Passbyby name Ref is made. The value of its data members a and b are set to 50 and 100 respectively by invoking setdata() method. After that by invoking display (), the instance Ref itself is sent as argument to parameter m. Since, we know that objects are passed to methods by reference, any changes made in the data members of parameter m will also effect the argument Ref. In the display (), the value of data member a is incremented by 10 and the value of data member is decremented by 5. The same effects will be seen in the argument Ref when the control returns back to the main() method.
Demonstration of Pass by Value
class PassbyValue
{
public static void main(String args[])
{
int a =50, b=100;
System.out.println(“Before Function Call : a = ” +a+ ” b = “+b);
chng(a,b);
System.out.println(“After Function Call : a = ” +a+ ” b = “+b);
}
static void chng(int x, int y)
{
x=x+10;
y=y-5;
}
}
Output:
Before Function Call: a= 50 b= 100
After Function call: a= 50 b= 100
When we pass a simple type to a method, it is passed by value. So, any changes made to the data in the method are limited to that method only and the data retains its older values when returns back to the caller.