Java 类实例与静态方法的关系

类实例（例如，由static/final声明的变量）和静态方法（例如，类方法）之间是否有任何特定的关系

---

我希望你明白我的意思。

静态和非静态方法/类是完全不同的。让我们使用一个面向对象编程的例子。假设我有一个名为“Person”的类，其构造函数名为

Person（）

，实例变量声明为myAge（设置为0），方法名为

birth（）

：

在我的

main

方法中，此类的使用方式如下：

Person Sajjad = new Person();
Sajjad.Birthday();

当我创建一个新的人，也就是你，你的年龄是0，因为我们的构造函数的默认值是0，对于

myAge

。一旦我将

birth（）

方法应用到你身上，你的年龄就会增加一岁

至于

static

方法，它没有面向对象的原则。它是有用途的。。我通常用它来做简单的数学

public static double addValues(double a, double b){
    return a + b;
}

在my

main

中：

int sum;
sum = addValues(1, 2);
System.out.println(sum);

输出：

3

看看上面有没有必要声明一个新的对象？静态方法更容易原型化，但从长远来看，我肯定会采用面向对象的原则，因为从长远来看，它使维护代码变得更加容易。另外，我不需要用不必要的代码行来混乱我的主方法

---

另外，如果代码是错误的，那实际上只是我编写的一些伪代码。

静态和非静态方法/类是完全不同的。让我们使用一个面向对象编程的例子。假设我有一个名为“Person”的类，其构造函数名为

Person（）

，实例变量声明为myAge（设置为0），方法名为

birth（）

：

在我的

main

方法中，此类的使用方式如下：

Person Sajjad = new Person();
Sajjad.Birthday();

当我创建一个新的人，也就是你，你的年龄是0，因为我们的构造函数的默认值是0，对于

myAge

。一旦我将

birth（）

方法应用到你身上，你的年龄就会增加一岁

至于

static

方法，它没有面向对象的原则。它是有用途的。。我通常用它来做简单的数学

public static double addValues(double a, double b){
    return a + b;
}

在my

main

中：

int sum;
sum = addValues(1, 2);
System.out.println(sum);

输出：

3

看看上面有没有必要声明一个新的对象？静态方法更容易原型化，但从长远来看，我肯定会采用面向对象的原则，因为从长远来看，它使维护代码变得更加容易。另外，我不需要用不必要的代码行来混乱我的主方法

---

另外，如果代码是错误的，那实际上只是我编出来的一些伪代码。

我想你说的是静态变量，而不是类实例（不是这个术语），静态变量和静态方法之间的一个关联是，在你的静态方法中你只能访问静态变量，而不能访问实例变量

我想你说的是静态变量，而不是类实例（没有这个术语），静态变量和静态方法之间的一个关联是，在静态方法中只能访问静态变量，而不能访问实例变量

类实例是存储在内存中并通过类类型的变量引用的对象。每个元素都有自己的状态和方法。例如：如果我们有一个

Apple

类和一个

getColor

非静态元素：

Apple a = new Apple("green");
Apple b = new Apple("red");
a.getColor();//green
b.getColor();//red

Apple.tree; //Apple Tree

静态方法/变量是与该类相关并通过类名称加入的元素。无法从实例访问静态元素。例如：如果我们有一个

Apple

类和一个

size

静态元素：

Apple a = new Apple("green");
Apple b = new Apple("red");
a.getColor();//green
b.getColor();//red

Apple.tree; //Apple Tree

这是苹果课

class Apple {
    public static String tree = "Apple Tree"; // Class related
    private String color; //object instance related

    public Apple(String color) {
        this.color = color;
    }

    public String getColor() {
        return this.color;
    }
}

---

因此，该类的颜色取决于实例。

类实例是存储在内存中的对象，通过类类型的变量引用。每个元素都有自己的状态和方法。例如：如果我们有一个

Apple

类和一个

getColor

非静态元素：

Apple a = new Apple("green");
Apple b = new Apple("red");
a.getColor();//green
b.getColor();//red

Apple.tree; //Apple Tree

静态方法/变量是与该类相关并通过类名称加入的元素。无法从实例访问静态元素。例如：如果我们有一个

Apple

类和一个

size

静态元素：

Apple a = new Apple("green");
Apple b = new Apple("red");
a.getColor();//green
b.getColor();//red

Apple.tree; //Apple Tree

这是苹果课

class Apple {
    public static String tree = "Apple Tree"; // Class related
    private String color; //object instance related

    public Apple(String color) {
        this.color = color;
    }

    public String getColor() {
        return this.color;
    }
}

因此，该类的颜色取决于实例。

访问：

类实例（即由static/final声明的变量）

和

static

方法可以一起工作，而无需明确的对象引用。而要访问成员变量（又称实例变量），则需要通过对象引用进行访问

class Test {
    static String str = "asdf";
    int num = 10;

    static void methodA() {
        System.out.println("Static variable direct access: " + str);
        System.out.println("Member variable access : " + new Test().num);
    }
}

并发性： 另一个区别是，在并发访问或线程安全逻辑期间，

类级锁可以通过
静态方法中的
类变量
获取，而
对象级锁可以通过
成员方法中的
成员变量
获取，尽管您可以混用n匹配

class Test {
    static Object CLASS_LOCK = new Object();
    Object MEMBER_LOCK = new Object();
    Test sharedTest = new Test(); // or created in different manner

    static void methodA() {
        synchronized (CLASS_LOCK) {
            // .. thread-safe code
        }

        synchronized (sharedTest.MEMBER_LOCK) {
            // .. thread-safe code
        }
    }
}

访问：
类实例（即由static/final声明的变量）
和
static
方法可以一起工作，而无需明确的对象引用。而要访问成员变量（又称实例变量），则需要通过对象引用进行访问

class Test {
    static String str = "asdf";
    int num = 10;

    static void methodA() {
        System.out.println("Static variable direct access: " + str);
        System.out.println("Member variable access : " + new Test().num);
    }
}

并发性：
另一个区别是，在并发访问或线程安全逻辑期间，
类级锁可以通过
静态方法中的
类变量
获取，而
对象级锁可以通过
成员方法中的
成员变量
获取，尽管您可以混用n匹配

class Test {
    static Object CLASS_LOCK = new Object();
    Object MEMBER_LOCK = new Object();
    Test sharedTest = new Test(); // or created in different manner

    static void methodA() {
        synchronized (CLASS_LOCK) {
            // .. thread-safe code
        }

        synchronized (sharedTest.MEMBER_LOCK) {
            // .. thread-safe code
        }
    }
}

最终版本<