什么是instance based member？是否等同于instance variable？如何区分变量类型？

Let’s clarify your questions one by one! #

First up: Is an instance-based member the same as an instance variable?
Not exactly—your understanding is a bit narrow here. Instance-based members are a broader category that includes both instance variables (the data tied to an object) and instance methods (the behaviors tied to an object). So instance variables are a type of instance-based member, but not the only one. For example, in a Car class, private String color; is an instance variable, and public void drive() is an instance method—both are instance-based members because they belong to individual Car instances, not the class itself.

How to tell instance variables apart from "regular" variables? #

Let’s break down the key differences:

• Definition location:

  • Instance variables are declared inside the class, but outside any method, constructor, or code block (and without the static keyword).
  • "Regular" variables usually refer to local variables—declared inside a method, constructor, or code block. They only exist within that scope.
  • There’s also class variables (marked with static), which belong to the class itself, not individual instances—these are another type of "non-instance" variable.

• Scope & lifetime:

  • Instance variables live as long as the object instance exists, and are accessible to all non-static methods in the class.
  • Local variables die as soon as their enclosing code block finishes executing—you can’t access them outside that method/constructor.
  • Class variables exist for the entire lifetime of the application, and are shared across all instances of the class.

• Initialization rules:

  • Instance variables get a default value (e.g., 0 for integers, null for objects) if you don’t explicitly initialize them.
  • Local variables must be explicitly initialized before use—otherwise, you’ll get a compile error.

• Storage:

  • Instance variables are stored in the heap memory, attached to their object instance.
  • Local variables live in the stack memory.

Do variables inside a constructor become instance variables? #

Only if you’re referring to the class’s pre-declared instance variables. Let’s use code examples to make this clear:

public class Dog {
    // This is an instance variable (declared at the class level)
    private String breed;

    public Dog() {
        // This is a LOCAL variable inside the constructor—NOT an instance variable
        String tempBreed = "Labrador";
        
        // Here, we're assigning the local variable's value to the instance variable
        this.breed = tempBreed;
    }
}

In the example above:

• tempBreed is a local variable in the constructor—it only exists while the constructor runs, and isn’t tied to the Dog instance.
• breed is the instance variable, declared at the class level. The constructor just assigns a value to it, but the variable itself isn’t created inside the constructor.

If you declare a variable only inside the constructor (like tempBreed), it’s just a local variable—never an instance variable.

内容的提问来源于stack exchange，提问作者W Lw