为何输出1234567 7654321？及跨方法创建已有对象新实例疑问

咱要在别的方法里给已有的对象造个新实例，核心就是基于原对象的属性复刻出一个独立的新对象，给你几种常用的实现方式：

• 写个拷贝构造函数（最直观的方式）：
  如果你是自定义的类，直接在类里加一个接收自身对象的构造函数，把原对象的属性值挨个赋值给新对象就行。比如：

  public class User {
      private String username;
      private int age;
  
      // 普通构造函数
      public User(String username, int age) {
          this.username = username;
          this.age = age;
      }
  
      // 拷贝构造函数，接收原对象
      public User(User originalUser) {
          this.username = originalUser.username;
          this.age = originalUser.age;
      }
  }
  

  然后在其他方法里这么用：

  public void createNewUser() {
      User original = new User("John", 30);
      // 基于原对象创建新实例
      User newUser = new User(original);
  }
  

• 实现Cloneable接口重写clone()方法：
  这种方式适合想快速实现拷贝的场景，但要注意默认是浅拷贝——如果类里有引用类型的属性（比如另一个对象），得自己处理深拷贝，不然新对象和原对象会共享同一个引用属性。示例：

  public class User implements Cloneable {
      private String username;
      private int age;
  
      // 构造函数、getter/setter...
  
      @Override
      protected Object clone() throws CloneNotSupportedException {
          // 浅拷贝直接调用父类方法
          return super.clone();
      }
  }
  

  调用的时候记得强制类型转换：

  User newUser = (User) original.clone();
  

• 序列化反序列化（深拷贝神器）：
  如果你的对象结构复杂，有多层引用属性，用序列化再反序列化的方式能直接生成完全独立的新对象。不过得让类实现Serializable接口，示例大概是这样：

  import java.io.*;
  
  public class User implements Serializable {
      // 属性、构造函数...
  
      public User deepCopy() throws IOException, ClassNotFoundException {
          ByteArrayOutputStream bos = new ByteArrayOutputStream();
          ObjectOutputStream oos = new ObjectOutputStream(bos);
          oos.writeObject(this);
  
          ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
          ObjectInputStream ois = new ObjectInputStream(bis);
          return (User) ois.readObject();
      }
  }
  

  调用deepCopy()方法就能得到原对象的深拷贝实例了。

虽然你没贴具体代码，但从输出结果来看，大概率是先输出正序的字符串/数组，再输出反转后的结果，我拿最常见的Java代码示例给你拆解执行过程：

假设代码是这样的：

public class ReverseDemo {
    public static void main(String[] args) {
        String originalStr = "1234567";
        // 输出原字符串+空格
        System.out.print(originalStr + " ");
        // 反转字符串并输出
        String reversedStr = new StringBuilder(originalStr).reverse().toString();
        System.out.println(reversedStr);
    }
}

具体执行步骤：

1. 程序启动后进入main方法，先创建字符串originalStr，值为"1234567"。
2. 执行System.out.print(originalStr + " ")：先把原字符串和空格拼接成"1234567 "，然后输出到控制台（注意这里用的是print，不会自动换行，所以控制台此时显示1234567 ）。
3. 接下来创建StringBuilder对象，把originalStr传入构造函数，StringBuilder会把不可修改的字符串转换成可修改的字符序列。
4. 调用reverse()方法：这个方法会直接反转字符序列里的顺序，原来的'1','2','3','4','5','6','7'瞬间变成'7','6','5','4','3','2','1'。
5. 调用toString()方法，把反转后的字符序列重新转换成字符串"7654321"，赋值给reversedStr。
6. 执行System.out.println(reversedStr)：输出反转后的字符串，并且自动换行，所以控制台接着输出7654321。
7. 最终控制台就会显示1234567 7654321。

如果是数组操作的代码（比如输出数组正序和逆序），执行逻辑也类似：

public class ArrayReverseDemo {
    public static void main(String[] args) {
        int[] nums = {1,2,3,4,5,6,7};
        // 输出正序数组
        for (int num : nums) {
            System.out.print(num);
        }
        System.out.print(" ");
        // 输出逆序数组
        for (int i = nums.length - 1; i >= 0; i--) {
            System.out.print(nums[i]);
        }
        System.out.println();
    }
}

步骤就是：先遍历数组正序输出每个元素得到1234567，输出空格后，从数组最后一个元素开始倒着遍历输出，得到7654321，组合起来就是你看到的结果。

内容的提问来源于stack exchange，提问作者Nazar Ahmed Amjad