对象是实例化的类，所以对象也叫做实例。

一个实例(对象)由 属性 (变量or数据)和 方法 (行为)构成

所以属性和方法叫做对象的 成员

对象的 属性 叫做 成员变量or实例变量(这俩也有点区别)

对象的 方法 叫做 成员方法

在面向对象编程中，成员变量和实例变量通常指的是相同的概念，但它们的使用和含义略有不同，具体取决于上下文：

  1. 成员变量：

    • 成员变量是类的一部分，它们定义了类的状态或属性。
    • 每个成员变量都是类的蓝图，用于创建对象时存储数据。
    • 成员变量可以是静态的或非静态的（实例变量）。

  2. 实例变量（非静态变量）：

    • 实例变量是成员变量的一种，它们属于类的特定实例（对象）。
    • 每个实例变量的副本都存储在创建的对象中，这意味着每个对象都有自己的实例变量副本。
    • 实例变量的值对于每个对象都是独立的，一个对象的实例变量改变不会影响另一个对象的相应变量。

  3. 静态变量（类变量）：

    • 静态变量也是成员变量的一种，但它们不属于任何特定的实例。
    • 静态变量只有单一的副本，所有类的实例共享这个副本。
    • 静态变量通常用于存储类级别的数据，如配置信息或计数器。

以下是一些关键点的对比：

  • 作用域：实例变量属于对象，每个对象都有其独立的副本；静态变量属于类，所有实例共享同一个副本。

  • 生命周期：实例变量随对象的创建而存在，随对象的销毁而消失；静态变量随类的加载而存在，随程序结束或类被卸载而消失。

  • 访问：实例变量可以通过对象的引用访问；静态变量可以通过类名直接访问，也可以通过对象引用访问。

下面是一个简单的Java类示例，展示了实例变量和静态变量的使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Car {
    // 实例变量，每个Car对象都有自己的颜色和速度
    String color;
    int speed;

    // 静态变量，所有Car对象共享同一个制造数量
    static int manufacturingCount = 0;

    public Car(String color) {
        this.color = color;
        // 每创建一个Car对象，制造数量增加
        manufacturingCount++;
    }

    public void drive() {
        // 实例方法，影响特定对象的速度
        speed += 10;
    }

    public static int getManufacturingCount() {
        // 静态方法，返回所有Car对象共享的制造数量
        return manufacturingCount;
    }
}

在这个例子中，color 和 speed 是实例变量，因为它们属于每个 Car 对象。而 manufacturingCount 是一个静态变量，因为它属于 Car 类本身，并且所有 Car 实例共享这个变量。drive 方法是一个实例方法，因为它操作特定 Car 对象的速度。getManufacturingCount 是一个静态方法，因为它返回的是类级别的信息。

在Java中，类（Class）是用来创建对象的模板或蓝图。类本身不直接持有数据，但类定义中可以包含成员变量（也称为字段或属性），这些成员变量是用来存储数据的。当你根据类创建一个对象（实例）时，每个对象都会有自己的成员变量副本，这些副本中存储的就是数据。

例如，假设有一个名为 Person 的类：

1
2
3
4
5
6
7
8
9
10
11
public class Person {
    String name;
    int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 其他方法...
}

在这个 Person 类中，name 和 age 就是成员变量，它们可以在类的实例中存储数据。当你创建 Person 类的对象时：

1
2
Person person1 = new Person("Alice", 30);
Person person2 = new Person("Bob", 25);

person1 和 person2 都是 Person 类的实例，它们各自拥有自己的 name 和 age 数据。person1 的 name 是 “Alice”，age 是 30；而 person2 的 name 是 “Bob”，age 是 25。

类本身只是一个定义，它不包含数据，但是它定义了如何创建可以包含数据的对象。

在面向对象编程（OOP）中，成员是类的一部分，它代表了类的特性（属性）或行为（方法）。成员是构成类的基本元素，它们定义了类的功能和数据结构。以下是成员的两种主要类型：

  1. 成员变量（属性）：

    • 成员变量是类的一部分，用于存储数据。它们是类的属性，通常用于描述对象的状态。
    • 成员变量可以是私有的（private），这意味着它们只能被类内部的方法访问，或者可以是公有的（public），这意味着它们可以被任何其他类访问。
    • 成员变量可以有默认的访问修饰符（没有显式指定），这通常是包级私有的（即同一个包内的其他类可以访问）。

  2. 成员方法（行为）：

    • 成员方法是类的一部分，定义了对象的行为。它们是类的操作，用于描述对象可以执行的动作。
    • 成员方法可以有不同的访问修饰符，如public、private或protected，这决定了它们可以被谁调用。
    • 方法还可以是静态的（static），这意味着它们属于类而不是类的实例，并且可以在不创建类实例的情况下被调用。

除了成员变量和成员方法，类的成员还可以包括：

  • 构造方法：特殊的方法，用于创建类的对象。它们的名字必须与类名相同，并且没有返回类型。

  • 静态初始化块：用于初始化静态变量的代码块，它在类加载时执行一次。

  • 实例初始化块：用于初始化非静态变量的代码块，它在每次创建类的新实例时执行。

  • 内部类：定义在另一个类内部的类，它可以访问外部类的成员，包括私有成员。

成员变量和方法的可见性和行为可以通过使用不同的访问修饰符和非访问修饰符来控制。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class ExampleClass {
    // 成员变量
    private int privateVar;
    protected int protectedVar;
    int packageVar; // 默认访问修饰符，也称为包级私有
    public int publicVar;

    // 构造方法
    public ExampleClass() {
        // 构造逻辑
    }

    // 成员方法
    public void publicMethod() {
        // 方法逻辑
    }

    private void privateMethod() {
        // 私有方法逻辑
    }

    // 静态方法
    public static void staticMethod() {
        // 静态方法逻辑
    }

    // 实例初始化块
    {
        // 实例初始化逻辑
    }

    // 静态初始化块
    static {
        // 静态初始化逻辑
    }
}

在这个例子中，ExampleClass 包含了不同类型的成员，包括私有和公有的成员变量，一个构造方法，公有和私有的成员方法，以及静态方法。静态初始化块和实例初始化块分别用于初始化静态成员和非静态成员。

在Java语言中，this 是一个特殊的关键字，它指向当前对象的引用。每个对象都有一个隐式的 this 引用，指向它自己。以下是 this 关键字的一些常见用法：

  1. 区分成员变量和局部变量：当局部变量名与成员变量名相同时，可以使用 this 关键字来区分它们。

    1
    2
    3
    4
    5
    6
    public class MyClass {
        private int number;
        public MyClass(int number) {
            this.number = number; // 使用 this 来引用成员变量
        }
    }

  2. 在构造函数中调用另一个构造函数：可以使用 this() 来调用同一个类中的另一个构造函数。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class MyClass {
        private int number;
        public MyClass() {
            this(0); // 默认构造函数调用带参数的构造函数
        }
        public MyClass(int number) {
            this.number = number;
        }
    }

  3. 在方法中返回当前对象的引用：有时，方法需要返回调用该方法的对象的引用，这时可以使用 this。

    1
    2
    3
    4
    5
    6
    public class MyClass {
        public MyClass getNext() {
            // 一些逻辑...
            return this; // 返回当前对象的引用
        }
    }

  4. 在参数中传递当前对象：当需要将当前对象作为参数传递给另一个方法时，可以使用 this。

    1
    2
    3
    4
    5
    6
    7
    8
    public class MyClass {
        public void doSomething(MyClass other) {
            other.copy(this); // 将当前对象作为参数传递
        }
        public void copy(MyClass other) {
            // 复制逻辑...
        }
    }

  5. 在匿名类和内部类中引用外部类的实例：在匿名类或内部类中，可以使用 this 关键字来引用外部类的实例。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class OuterClass {
        public void doSomething() {
            new Thread(new Runnable() {
                public void run() {
                    OuterClass.this.doWork(); // 调用外部类的 doWork 方法
                }
            }).start();
        }
        public void doWork() {
            // 工作逻辑...
        }
    }

  6. 在重载方法中使用：当类中有多个同名方法但参数列表不同时，可以使用 this 调用其他重载的方法。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class MyClass {
        public void print(int number) {
            System.out.println("Number: " + number);
        }
        public void print(String text) {
            System.out.println("Text: " + text);
        }
        public void printAll(int number, String text) {
            this.print(number); // 调用第一个 print 方法
            this.print(text); // 调用第二个 print 方法
        }
    }

this 关键字是Java中一个非常有用的工具，它允许程序员在各种情况下引用当前对象。