能够自我复制的程序

Question

是否可以制作一个 Java 程序，将其源代码打印到一个新文件中，然后对其进行编译，然后运行编译后的程序？

Answer 1

更新：

好的，不妨让它自动运行。享受疯狂。运行风险自负。

---

是的，这是可能的，因为我确实写了它。 它不执行 RUN 部分（这太疯狂了，因为正如其他人提到的，它会导致无限循环）， 但这里是：Quine.java

import java.io.*;
public class Quine {
   public static void main(String[] args) throws Exception {
      char q = 34;
      String out = "Quine$";
      String text = (
         "import java.io.*; " +
         "public class [OUT] { " +
           "public static void main(String[] args) throws Exception { " +
             "char q = 34; String out = `[OUT]
更新：
好的，不妨让它自动运行。享受疯狂。运行风险自负。

是的，这是可能的，因为我确实写了它。 它不执行 RUN 部分（这太疯狂了，因为正如其他人提到的，它会导致无限循环）， 但这里是：Quine.java
; String text = `[TEXT]`; " +
             "PrintWriter pw = new PrintWriter(out + `.java`); " +
             "pw.format(text, 34, out, text); " +
             "pw.close(); Runtime runtime = Runtime.getRuntime(); " +
             "runtime.exec(`javac ` + out + `.java`).waitFor(); " +
             "runtime.exec(`java ` + out); " +
           "} " +
         "}"
      ).replace("`", "%1$c").replace("[OUT]", "%2$s").replace("[TEXT]", "%3$s");
      PrintWriter pw = new PrintWriter(out + ".java");
      pw.format(text, 34, out, text);
      pw.close();
      Runtime runtime = Runtime.getRuntime();
      runtime.exec("javac " + out + ".java").waitFor();
      runtime.exec("java " + out);
   }
}

因此，这里是如何开始疯狂的：

• javac Quine.java 编译
• java Quine 来运行它
  • 它将生成、编译并运行 Quine$
• 我已确保 Quine.java 尽可能具有可读性，因此 主要 与 Quine$.java 的区别在于格式化和 3x 替换。 次要差异是 Quine$.java 将 out 设置为 Quine$$。
• Quine$ 将生成、编译并运行 Quine$$
• Quine$$ 将生成、编译并运行 Quine$$$Quine$$ 将生成、编译并运行 Quine$$$ code>
• Quine$$$ 将生成、编译并运行 Quine$$$$
• ...

请注意，这不会通过阅读进行任何逆向工程或作弊.java 源代码等。 Quine 是一个 quine 生成器，因为它生成不同格式的不同代码，但 Quine$ 几乎是一个真正的独立的 quine：它确实会自我复制，只是重新标记它 Quine$$ （它会自我复制并重新标记为 Quine$$$ 等）。

因此从技术上讲，不存在无限循环：当文件系统无法处理另一个 $ 时，它最终会停止。 我能够通过强制删除所有 Quine$* 文件来手动阻止这种疯狂行为，但运行风险需要您自担！！！

Answer 2

是的，这是可能的。
一个简单的实现是：让源代码将其自身包含在一个字符串中，将该字符串保存到一个文件中，并用相同的字符串填充它自己的字符串（否则，由于这种递归方式，初始字符串将具有无限大小）实现），编译该文件，并运行编译后的文件（反过来，这将执行相同的操作）。

重要的实现要困难得多。

Answer 3

当然可以 - 查看 rosetta 代码 并导航到 Quine，这是一个自无需任何外部访问即可输出其自己的源代码的参考程序。

Java 中有一个 quine 的例子。

Answer 4

自我复制或自我复制程序被称为Quine 程序 < /p>

示例程序位于 < Java 能够自我复制。

public class QuineProgram {

     public static void main(String[] args){
      String f = "public class QuineProgram { "
        + "public static void main(String[] args)"
        + "{ String f =%c%s%1$c;"
        + " System.out.printf(f,34,f);}} ";
      System.out.printf(f, 34, f);
     }

}

输出：

public class QuineProgram { public static void main(String[] args){ String f ="public class QuineProgram { public static void main(String[] args){ String f =%c%s%1$c; System.out.printf(f,34,f);}} "; System.out.printf(f,34,f);}} 

Answer 5

为此，您可以使用 Java 编译器 API (JSR-199)。下面是来自 JSR-199 的代码，该代码从字符串编译代码（稍微修改以使其编译）。该代码实际上将源代码从 String 编译为字节数组（即它不写入磁盘），加载它，然后通过反射执行它：

• MemoryFileManager.java：用于将字符串编译为字节数组的文件管理器。
• ByteArrayClassLoader.java：从字节数组加载类的类加载器。
• CompileFromString.java：将所有内容包装在一起的类。

这可能是一个起点（归功于原作者 Peter Van der Ahé）。

顺便说一句，您当然需要 JDK 才能使用此 API。

Answer 6

我不知道你到底想要什么，但我认为 BeanShell 是你可以使用的东西。
BeanShell 是一个解释器。您可以运行未编译的 Java 代码（因此您给它一个带有代码的字符串，然后他运行它）。

当然，如果你真的想做你写的事情，运行程序的机器需要有JDK来编译你的程序。

希望这有帮助

Answer 7

我认为它在 Java 中不起作用。这不会涉及覆盖正在运行的类文件吗？

假设你的程序在Quine.java中编译为Quine.class。

现在Quine.class将尝试将其输出写入Quine.java（到目前为止一切顺利），并将其编译为Quine.class。这将是一个问题，因为 Quine.class 已经在运行

Answer 8

是的 - 不要忘记使用 JDK 而不是 JRE：

1. 将应用程序的源代码文件与应用程序捆绑在一起。该应用程序会将源文件复制到一组新的源代码文件，编译新的源文件，将新的源代码与新的类文件捆绑到一个新的应用程序中，然后生成新的应用程序。

   或

2. 将反编译器与应用程序捆绑在一起。该应用程序将在自己的类文件上运行反编译器以生成新的源代码文件，编译新的源文件，将反编译器与新的类文件捆绑到新应用程序中，然后生成新应用程序。

Answer 9

这是一个使用预览文本块功能 (-source 13 --enable-preview) 的 Java Quine，其中输出的格式与输入相同：

package org.sample.quine;

public class QuineProgram
{
  public static void main(String...args)
  {
    String f ="""
package org.sample.quine;

public class QuineProgram
{
  public static void main(String...args)
  {
    String f =""%c%c%s%1$c"";
    System.out.printf(f, 34, 10, f);
  }
}
""";
    System.out.printf(f, 34, 10, f);
  }
}

输出：

package org.sample.quine;

public class QuineProgram
{
  public static void main(String...args)
  {
    String f ="""
package org.sample.quine;

public class QuineProgram
{
  public static void main(String...args)
  {
    String f =""%c%c%s%1$c"";
    System.out.printf(f, 34, 10, f);
  }
}
""";
    System.out.printf(f, 34, 10, f);
  }
}

大量评论版本：

package org.sample.quine;

public class Quine
{
  public static void main(String...args)
  {
    // Inside text block use "" followed by token or token followed by "" so that we don't prematurely close text block
    String f ="""
package org.sample.quine;

public class Quine
{
  public static void main(String...args)
  {
    // Inside text block use "" followed by token or token followed by "" so that we don't prematurely close text block
    String f =""%c%c%s%1$c"";
    /* Tokens in template text block, each prefixed with percent symbol
     * 1(c)   third quote (34) of open block delimiter
     * 2(c)   new line    (10) of open block delimiter
     * 3(s)   String f         text block that goes between two text block delimiters
     * 4(1$c) first quote (34) of close block delimiter,
     *        1$ means first argument after template argument
     *        2$ would be second argument after template argument
     */
     // Arguments - 1 template (String f); 2 "; 3 newline; 4 template again without replacing tokens
     System.out.printf(f, 34, 10, f);
  }
}
""";
    /* Tokens in template text block, each prefixed with percent symbol
     * 1(c)   third quote (34) of open block delimiter
     * 2(c)   new line    (10) of open block delimiter
     * 3(s)   String f         text block that goes between two text block delimiters
     * 4(1$c) first quote (34) of close block delimiter,
     *        1$ means first argument after template argument
     *        2$ would be second argument after template argument
     */
    // Arguments - 1 template (String f); 2 "; 3 newline; 4 template again without replacing tokens
    System.out.printf(f, 34, 10, f);
  }
}