不同对象上的同步语句是可以交错执行的。同步语句是通过锁机制来确保多个线程在访问共享资源时的安全性。每个对象都有一个与之关联的锁，称为监视器锁（也称为内部锁或互斥锁）。

下面是一个示例代码，说明了不同对象上的同步语句的交错执行：

public class SynchronizedExample {
    private Object lock1 = new Object();
    private Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            System.out.println("method1: Locking lock1");

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("method1: Releasing lock1");
        }
    }

    public void method2() {
        synchronized (lock2) {
            System.out.println("method2: Locking lock2");

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("method2: Releasing lock2");
        }
    }
}

在上述代码中，method1和method2是两个不同的同步方法，分别使用了lock1和lock2作为锁对象。

下面是一个示例的多线程程序，演示了不同对象上的同步语句的交错执行：

public class Main {
    public static void main(String[] args) {
        SynchronizedExample example1 = new SynchronizedExample();
        SynchronizedExample example2 = new SynchronizedExample();

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                example1.method1();
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                example2.method2();
            }
        });

        thread1.start();
        thread2.start();
    }
}

在上述代码中，创建了两个SynchronizedExample对象，分别调用了method1和method2。通过两个线程分别执行这两个方法，可以观察到不同对象上的同步语句的交错执行。因为每个对象都有自己的锁，所以它们可以独立地获取和释放锁，从而实现了交错执行的效果。

注意：虽然不同对象上的同步语句可以交错执行，但同一个对象上的同步语句会按照顺序执行，因为它们共享同一个锁。