Java vs C++: The same output comes from different build paths

Equal output does not make Java and C++ source interchangeable

The completed Java program in Main.java and the completed C++ program in hello.cpp both produce exactly the same visible line: Hello, DSA. That shared output tells you what the two programs do for this run. It does not make their source code interchangeable. Main.java follows Java's rules and must be handled by a Java compiler. hello.cpp follows C++ rules and must be handled by a C++ compiler.

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, DSA");
    }
}

#include <iostream>

int main() {
    std::cout << "Hello, DSA" << std::endl;
    return 0;
}

A compiler does not accept every programming language. It reads source code according to one language's grammar and produces a result in that language's build process. Giving Main.java to a C++ compiler does not turn it into C++, and giving hello.cpp to a Java compiler does not turn it into Java. The matching source file and compiler are a pair.

A Java build and a C++ build produce different kinds of files

The Java build changes Main.java into Main.class. Main.class contains Java bytecode, an intermediate form intended to be accepted by a compatible Java runtime. The C++ build changes hello.cpp into a target-specific hello executable. That executable contains native instructions prepared for the operating system and processor target selected during the build.

Main.java  -- Java compiler -->  Main.class  -- compatible Java runtime -->  Hello, DSA
hello.cpp  -- C++ compiler  -->  hello executable for a target machine  -->  Hello, DSA

The distinction appears before either program runs. Main.class is not the same kind of file as a native executable, even though both are build results. The Java runtime reads the bytecode and provides the environment that runs it. The operating system loads the C++ executable as native code for the target for which it was built.

Java portability belongs to bytecode, not to every file with a Java name

Main.java is source code, so it is portable only when a suitable Java compiler can read and build it. Main.class is different: it is portable bytecode. If you copy Main.class to another machine that has a compatible Java runtime, that runtime can often run the same file without rebuilding it for that machine.

The existing hello executable is native code tied to the operating system and processor target used by the C++ compiler. Copying it to a machine with a different target may fail because that machine may not understand the executable format or processor instructions. You may need to compile hello.cpp again for the new target.

One run cannot prove that either language is always faster or better

Running both supplied programs and seeing Hello, DSA proves that both programs produced that output in those runs. It does not prove that Java and C++ are equally fast, or that one language is always faster or better. This program does almost no work, so its result tells you very little about how either language behaves on a larger workload.

Any observed timing depends on more than the language name. The compiler and its settings affect the build result. The Java runtime, operating system, processor, and native executable affect how the run behaves. The workload also matters: a tiny output operation does not test the same things as a computation that uses substantial memory or processing time.

For this supplied program, the sound conclusion is limited: Java and C++ can produce the same program output through different source and build paths. A broader performance or quality claim needs suitable workloads, controlled measurements, and the specific environments being compared.