Syntax:

datatype variable = value

There are three types of variables in java:

1. Local variable
2. Instance variable
3. Class/Static variable

1. Local Variables:

A variable declared within the body of a method or constructor is referred to as a local variable. This is because the scope of a local variable is limited to the method or constructor in which it is defined, and it cannot be accessed by other methods in the class.To declare a local variable within the method body, the “static” keyword is used.

For example:

public class variableType {
    public void localVariable() {
        String name = "Ben";
        int marks = 95;
        System.out.println(name + " Scored " + marks + "%.");
    }

    public static void main(String[] args) {
        variableType vt = new variableType();
        vt.localVariable();
    }
}

Output:

Ben Scored 95%.

If an attempt is made to access a local variable outside the method or constructor in which it was created, it will result in an error.

For example:

public class variableType {
    public void localVariable() {
        String name = "Ben";
        int marks = 95;
    }
    public void notLocalVariable() {
        System.out.println(name + " Scored " + marks + "%.");
    }

    public static void main(String[] args) {
        variableType vt = new variableType();
        vt.notLocalVariable();
    }
}

Output:

name cannot be resolved to a variable
marks cannot be resolved to a variable

The post Variables in Java-Part I first appeared on Student Projects.

• Variables declared within a function or a block of code are referred to as local variables. These variables are only accessible within the function in which they were declared. Local variables have a function-specific scope since they can only be accessed by statements that are included within that function or code block.

B. Worldwide Variables

• Global variables are those that have definitions separate from any and all functions. We can access global variables within any of the program’s declared functions to retrieve their values. The system initialises global variables when they are defined. When a name is defined for both local and global variables, the local variable is given preference.

C. Static Variables

• One definition of a static variable is one that keeps its value even after the programme leaves the scope in which it was declared. Static variables don’t need to be initialised afresh in the new scope; they keep their value. Static variables retain their memory until the program’s end, but regular variables are deleted when the function they were declared in is exited. Both inside and outside of the function they can be declared. The block is the local area for static variables. A static variable’s default value is zero. A static variable is declared with the word static.

Output:

static datatype variable_name = variable_value;

Static global variables differ from static local variables.

Static global variable

• Static global variables are any variables with the static keyword specified outside of a function. Any method in the application will allow access to this variable.

Static local variable

• Static local variables are any variables that are declared with the static keyword inside of a function. A static local variable has the same scope as a local variable, but its memory is accessible for the duration of the program’s execution.

The characteristics of static variables

• A static variable’s value will remain after the programme leaves the scope in which it was declared.
• A static variable’s allotted memory is accessible for the duration of the program’s execution.
• A static variable’s default value is 0 if we don’t initialise it.

The post C Static Variables first appeared on Student Projects.

A local variable is a variable that is declared inside of a function or loop. When we define a variable within a function, its scope is limited to the function. This is the case with functions. From the time it is defined until the function’s conclusion, it is accessible. It will endure while the function is running. Access to local variables from outside the function is prohibited. The function’s parameter names have the same behavior as local variables.

Example:

def sum():

      a=10 #local variable cannot be accessed outside the function

      b=20

      sum=a+b

      print( sum)

print(a) #this gives an error

It will give you an error if you attempt to access variable “a” outside of the function. It can only be accessed within the function.

Globe variable:

A global variable, on the other hand, is simpler to comprehend because it is accessible throughout the program and is not specified inside the function. It can alternatively be described as a variable that is defined in the program’s main body. Any loop or function may call it. Anywhere in the software is within its scope.

Example:

a=1  #global variable

def print_Number():

            a=a+1;

            print(a)

 print_number()

This is due to the fact that we can only access the global variable; inside the function, we are unable to change it.

The global keyword in Python enables us to change the global variable. It is employed to establish a global variable and make local changes to the variable.

Rules of the global keyword:

Unless specifically designated as global, any value we assigned to a variable within the body of a function would be considered local Implicitly global variables are those that are exclusively used inside of functions. The global keyword shouldn’t be used outside of functions.

The post Golbal and local variable first appeared on Student Projects.