Variables in java

Visit for java

http://javaforhelp.blogspot.com

Variables

The next example prints a part of the Fibonacci sequence, an infinite sequence whose first few terms are

1
1
2
3
5
8
13
21
34

The Fibonacci sequence starts with the terms 1 and 1, and each successive term is the sum of the previous two terms. A Fibonacci printing program is simple, and it demonstrates how to declare variables, write a simple loop, and perform basic arithmetic. Here is the Fibonacci program:

class Fibonacci {
/** Print out the Fibonacci sequence for values < lo =" 1;" hi =" 1;" hi =" lo" lo =" hi">
This example declares a Fibonacci class that, like  HelloWorld, has a main method. The first two lines of  main are statements declaring two local  variables: lo and hi. In this program hi is the  current term in the series and lo is the previous term. Local variables  are declared within a block of code, such as a method body, in contrast to  fields that are declared as members of a class. Every variable must have a type that precedes its name when the variable is  declared. The variables lo and hi are of type int,  32-bit signed integers with values in the range 231 through  2311.
 
The Java programming language has built-in "primitive" data  types to support integer, floating-point, boolean, and character values. These  primitive types hold numeric data that is understood directly, as opposed to  object types defined by programmers. The type of every variable must be defined  explicitly. The primitive data types are:
 
 
    
 
 
 
 
boolean
 
 
either TRue or false
 
 
 
char
 
 
16-bit Unicode UTF-16 character  (unsigned)
 
 
 
byte
 
 
8-bit integer (signed)
 
 
 
short
 
 
16-bit integer (signed)
 
 
 
int
 
 
32-bit integer (signed)
 
 
 
long
 
 
64-bit integer (signed)
 
 
 
float
 
 
32-bit floating-point (IEEE 754)
 
 
 
double
 
 
64-bit floating-point (IEEE  754)

For each primitive type there is also a corresponding object  type, generally termed a "wrapper" class. For example, the class  Integer is the wrapper class for int. In most contexts, the  language automatically converts between primitive types and objects of the  wrapper class if one type is used where the other is expected.
 
In the Fibonacci program, we declared hi and  lo with initial values of 1. The initial values are set by  initialization expressions, using the = operator, when the variables  are declared. The = operator (also called the assignment operator), sets the variable named on the  left-hand side to the value of the expression on the right-hand side.
 
Local variables are undefined  prior to initialization. You don't have to initialize them at the point at which  you declare them, but if you try to use local variables before assigning a  value, the compiler will refuse to compile your program until you fix the  problem.
 
As both lo and hi are of the same type, we  could have used a short-hand form for declaring them. We can declare more than  one variable of a given type by separating the variable names (with their  initialization expressions) by commas. We could replace the first two lines of  main with the single equivalent line
int lo = 1, hi = 1;

or the much more readable
int lo = 1,
hi = 1;
http://javaforhelp.blogspot.com
Notice that the presence of line breaks makes no difference to  the meaning of the statementline breaks, spaces, tabs, and other whitespace are purely for the programmer's  convenience.
 
The while statement in the example demonstrates one  way of looping. The expression inside the while is evaluatedif the  expression is true, the loop's body is executed and the expression is tested  again. The while is repeated until the expression becomes false. If it  never becomes false, the loop will run forever unless something intervenes to  break out of the loop, such as a break statement or an exception.
 
The body of the while consists of a single statement.  That could be a simple statement (such as a method invocation), another  control-flow statement, or a blockzero or more  individual statements enclosed in curly braces.
 
The expression that while tests is a boolean expression that has the value true or  false. Boolean expressions can be formed with the comparison operators (<, <=,  >, >=) to compare the relative magnitudes of two values  or with the == operator or != operator to test for equality or  inequality, respectively. The boolean expression hi< 50 in  the example tests whether the current high value of the sequence is less than  50. If the high value is less than 50, its value is printed and the next value  is calculated. If the high value equals or exceeds 50, control passes to the  first line of code following the body of the while loop. That is the  end of the main method in this example, so the program is finished.
 
To calculate the next value in the sequence we perform some  simple arithmetic and again use the = operator to assign the value of  the arithmetic expression on the right to the variable on the left. As you would  expect, the + operator calculates the sum of its operands, and the  - operator calculates the difference. The language defines a number of  arithmetic operators for the primitive integer and floating-point types  including addition (+), subtraction (-), multiplication  (*), and division (/), as well as some other operators we talk  about later.
 
Notice that the println method accepts an integer  argument in the Fibonacci example, whereas it accepted a string  argument in the HelloWorld example. The println method is one  of many methods that are overloaded so that they  can accept arguments of different types. The runtime system decides which method  to actually invoke based on the number and types of arguments you pass to it.  This is a very powerful tool.