Java 如何理解Object.getClass（）方法？

说：

返回此

对象的运行时类

。返回的

类

对象为 由的

静态同步

方法锁定的对象

---

代表阶级。实际结果类型为

Class
getClass
在运行时为对象的实际类提供
Class
实例，而不是您必须对其引用的类型

一个简单的例子可能会澄清这一点。假设我们有一个方法，它接受实现
List
的任何内容并转储其类名

static void foo(List l) {
    System.out.println(l.getClass().getName());
}

我们可以用各种不同类型的列表来称呼它：

foo(new LinkedList()); // Outputs "java.util.LinkedList"
foo(new ArrayList());  // Outputs "java.util.ArrayList"

由于
foo
可以通过任何
列表调用
，因此在极少数（！）不可避免的情况下，它可以使用
getClass
来计算给定实例的实际类

如何理解返回的类对象被静态同步方法锁定

static synchronized
方法在运行时表示加载类的
Class
实例上同步，因此对此类方法的调用不能重叠。假设我有一个类，
Foo
，带有一个静态方法
notThreadSafe
，我有两个线程需要调用它：

// On thread 1
Foo.notThreadSafe();

// On thread 2
Foo.notThreadSafe();

因为它不是线程安全的，
notThreadSafe
将被声明为
synchronized
：

public static synchronized void notThreadSafe() { 
    /* ... */
}

这实际上与

public static void notThreadSafe() { 
    synchronized (Foo.class) {
        /* ... */
    }
}

（
Foo.class
是加载的
Foo
类的
class
实例。）

因此，当线程1进入synchronized块时，如果线程2试图进入该块（或在
Foo.class
上同步的任何东西），它必须等待

不必对同一方法进行两次调用；我可以有两个
静态同步的
方法（
m1
和
m2
），其中线程1调用
m1
，线程2调用
m2
，对
m2
的调用必须等待对
m1
的调用完成，因为它们都在同一个实例上同步（用于
Foo
的
类
实例）

这与
getClass（）
有什么关系？因为相同的
Class
实例是
getClass
on
Foo
实例返回的：

System.out.println(Foo.class == (new Foo()).getClass()); // true

“运行时类”是与对象的有效类型关联的类对象。它表示如果您执行以下操作：

Object o = new String();
System.out.println(o.getClass());

您将获得
类java.lang.String
，因为
o
的实际运行时类是
String
。您无法在编译时预测这一点

至于“被同步静态方法锁定”，它实际上意味着，对于类
ThisClass
中声明的方法：

public static synchronized foo() {
    ...
}

…相当于：

public static foo() {
    synchronized(ThisClass.class) {
        ...
    }
}

也就是说，类对象被用作所有同步静态方法的锁。有关同步块和锁的详细信息。
对于第二个问题，这意味着：

class A {}
class B extends A {
  public static synchronized void f() {}
}
...
A a = new B();
Class <? extends A> c = a.getClass();

class A{}
B类扩展了A类{
公共静态同步的void f（）{}
}
...
A=新的B（）；
在运行时为类初始化。为什么投票关闭？这是非常清楚的。。。
class A {}
class B extends A {
  public static synchronized void f() {}
}
...
A a = new B();
Class <? extends A> c = a.getClass();