代码示例：

public class Hreflect {

    public static void main(String[] args) {
        try {
test t=new test();
        }catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }

}
class test{
    public test() throws InterruptedException {
        Thread one=new Thread(new Runnable() {
            @Override
            public void run() {
                 test.method1();
            }
        });
        one.start();

        Thread two=new Thread(new Runnable() {
            @Override
            public void run() {
                test.method2();
            }
        });
        two.start();

        Thread three=new Thread(new Runnable() {
            @Override
            public void run() {
                test.method3();
            }
        });
        three.start();



    }
   static void method1()
    {
        synchronized (test.class)
        {
            System.out.println("我是类方法一但是方法里的synchronized修饰，执行5秒");
            try{
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
   static void method2()
    {
        try{
            System.out.println("类方法2无synchronized但是我也被执行了，执行5秒");
            Thread.sleep(5000);
        }catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
    static synchronized  void method3()
    {
        try{
            System.out.println("我是类方法被synchronized修饰，开始执行5秒");
            Thread.sleep(5000);
        }catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

采用的线程同步对象来验证 类方法一保证占用当前对象来执行 因为要形成对比 类方法二没有加synchronized关键字 被执行是肯定的 为了验证类方法三，唯一同类方法二不同的是在其前面加上了synchronized关键字
如果类方法前，加上修饰符 synchronized，同步对象不是当前类对象
理应被执行 因为占用的同步对象不是当前类对象但是其结果只是类方法二执行了 而且是等待类方法一释放才执行的 因此得出——类方法前，加上修饰符 synchronized，同步对象是当前所获取的类对象