What is the difference between a static variable and an instance variable?

Static variables: Variables that exist independently, but are placed under a certain class, and can be used by adding dots to the class name to call the static variable name. And it is a project or program that resides memory directly when it is started and runs into the class.

You don't need to initialize the class to call the variable. Declared with the keyword static. The same goes for static methods, which can be called directly.

Instance variable: It is a property equivalent to the class, which needs to be initialized first, that is, the new class, before it can be called. However, if the class is not used again, and after it is garbage, the instance will no longer exist, that is, it is no longer in memory.

The differences are as follows:1The storage area is different: static variables are stored in the static storage area, and common variables are stored in the heap;

2.Static variables are class-related, while normal variables are instance-related.

3.Memory is allocated differently.

4.Life cycles are different.

Static variables belong to classes and already exist without instantiation, and all instances share the same static variable, which can be accessed by class name and instance name. Instance variables belong to instances, and each instance has its own variable, which can only be accessed by the instance name.

Static variables can be identified by the class name. The name of the method can be pointed out. The instance variable needs to be instantiated by that class before it can be obtained.

That is, one is stationary.

For example: private sub command1 click()static a as integer'Static variable a = a + 1

print a

end sub

Connect and click on command1, output 1 2 3 4 5....

Because it is a static variable, the value of a is preserved.

If private sub command1 click()dim a as integer

a = a + 1

print a

end sub

The result is always 1....Because every command1 click() is a newly created variable a, the variable default value is 0, so the result is 1

Static variablesThere is one more keyword static than a dynamic variable, e.g. int i for dynamic variables and static int i for static variables.

Dynamic variables are in subroutines, and each call starts from its initial value, and no matter what changes it undergoes in the function, static variables continue to change from the changed value.

Static variables

Static variables are programmed on a computer.

Domain refers to a class of variables that are statically allocated by the system before the program is executed, that is, the storage space allocation is no longer changed at runtime, and the corresponding automatic variables that only exist temporarily at runtime, that is, local variables and some objects that obtain storage space in a dynamic allocation way, in which the storage space of automatic variables is allocated and released on the call stack.

Static variables can also be used to store constants, specifically not to mention, static variables can be identified with keywords such as const, constant or final, and their values will be set at compile time and cannot be changed at runtime.

Compiler. Usually static constants.

The text is placed in the text area of the object search line, while the non-essential initialization data is placed in the data area, and some compilers may choose to create a dedicated area for it if desired, and to enable memory protection in this area to prevent constant variables from being overwritten by incorrect pointer writes.

Static variables are also known as class variables, and static methods are also known as class methods).

What is the difference between a static variable and an instance variable?

1. Static variables are modified with static keywords, and Gaozhizheng instance variables are not needed.

2. Static variables, which belong to the class, as long as the program is loaded, the static variables will be allocated space and can be used directly.

Instance variables are properties of an object that can only be used if the object is instantiated before space is allocated. (i.e. a new one is required to use it).

3. Class variables are common to all objects, one of the objects will change its value, and the other Luzhen objects will get the result after the change;

Instance variables, on the other hand, are private to the object, and the value of one object is changed without affecting other objects.

Example: public class staticclass {

static int i=5;Static variables

int j=5;Instance variables.

public static void main(string args) {

You can quote i directly

staticclass sc=new staticclass();J must be instantiated before it can be referenced;

1. The difference between copy in the syntax definition: static should be added before static variables, while du should not be added before instance variables. 2. The difference between the DAO when the program is running:

Instance variables are properties of an object that must be created for the instance variables to be allocated space in order to use them. Static variables do not belong to an instance object, but belong to a class, so they are also called class variables, as long as the program loads the bytecode of the class, without creating any instance objects, the static variable will be allocated space, and the static variable can be used. In short, instance variables must be created before they can be used by that object, while static variables can be referenced directly by class name.

Static variables do not change their values the next time they enter the function, while dynamic variables are set to zero the next time they enter the function (if they don't have an initial value).

Non-static variable: This variable is automatically allocated and initialized before the subroutine is executed, and the allocated storage space is automatically released after the subroutine is executed. That is, the storage space of a variable exists only during the execution of the subroutine in which it is located;

Static variable: This variable, like a global, assembly variable, is allocated to storage space that persists while the program is running and is initialized only once before the application starts running.