**Member Variables**
A member variable is a variable that belongs to a class or object and represents a specific attribute of that class. It is used internally by systems like Analysis Services to identify members of a dimension. The `MemberKeyColumn` property defines the member variable for a dimension. For example, a number between 1 and 12 could represent a month in a year.
In Java, member variables are declared within the class body and are also known as fields. They can be instance variables, static (class) variables, or constants. Here’s an example from the `Clothes` class:
```java
package ch05.sample;
public class Clothes {
String id; // instance variable
private String colorType; // instance variable
private int size; // instance variable
private static String depart; // class variable
final String design = "yangzi"; // constant
}
```
These variables—instance variables, class variables, and constants—are all considered member variables. Their differences depend on modifiers such as `private`, `static`, and `final`.
**Global Variables**
A global variable is a variable that is accessible throughout the entire program. Unlike local variables, which are limited to a specific method or block, global variables can be accessed by any part of the program. However, in modern object-oriented languages like Java, C++, and C#, the use of true global variables has been largely replaced by static class variables. By declaring a class as `public static`, its member variables become globally accessible.
**Difference Between Member Variables and Global Variables**
While the term "global variable" is sometimes used interchangeably with "member variable," they are not exactly the same. In Java, member variables are divided into two types:
1. **Class Variables (Static):** Declared with the `static` keyword. They belong to the class rather than any individual object and are shared across all instances.
2. **Instance Variables:** Not modified by `static`. Each object has its own copy of these variables.
Local variables, on the other hand, are defined within methods or blocks and have a limited scope. If a local variable shares a name with a member variable, the local one takes precedence within that scope.
For example:
```java
public class Test {
int a = 0; // member variable
public static void main(String[] args) {
int b = 0; // local variable
}
}
```
**Key Differences Between Member and Local Variables**
- **Access Modifiers:** Member variables can have access modifiers like `public`, `private`, or `protected`, while local variables cannot.
- **Storage:** Member variables are stored in the heap, while local variables are stored in the stack.
- **Initialization:** Member variables have default values (e.g., `0` for integers, `null` for objects), but local variables must be explicitly initialized before use.
- **Lifetime:** Member variables exist as long as the object exists, while local variables are destroyed once the method or block completes.
**Example Code**
Here are two simple examples to illustrate the difference:
**Program 1:**
```java
public class Variable {
int i;
void test() {
int j = 8;
if (j == i)
System.out.println("equal");
else
System.out.println("not equal");
}
public static void main(String[] args) {
Variable v = new Variable();
v.test();
}
}
```
**Program 2:**
```java
public class Variable {
void test() {
int i;
int j = 8;
if (j == i)
System.out.println("equal");
else
System.out.println("not equal");
}
public static void main(String[] args) {
Variable v = new Variable();
v.test();
}
}
```
The second program will throw a compilation error because `i` is a local variable and has not been initialized.
**Summary**
Member variables are essential components of a class, providing state to objects. They come in different forms—instance, static, and final. Local variables, by contrast, are temporary and limited in scope. Understanding their differences helps in writing clean, efficient, and maintainable code. Whether you're working with instance variables or static variables, always remember that proper initialization and scoping are key to avoiding runtime errors.
36V Power Battery,Motorcycle Battery Pack,Custom Cruise Lithium Battery,Electric Motorcycle Lithium Battery
Sichuan Liwang New Energy Technology Co. , https://www.myliwang.com