- Bytecode is a highly optimized set of instructions designed to be executed by what is called the Java Virtual Machine (JVM), which is part of the Java Runtime Environment (JRE). JVM was initially designed as an interpreter for bytecode.
- Translating a Java program into bytecode makes it much easier to run a program in a wide variety of environments because only the JVM needs to be implemented for each platform. Once a JRE exists for a given system, any Java program can run on it.

Compiled Code

: The programmer writes the code, a different program called the Compiler translates that into machine code (instructions specific to that CPU in the computer) before the programmer written code ever runs. Think of an .exe file. The pro is that since the computer can execute the instructions instantaneously, it is incredibly fast. The con being that it becomes platform-specific. The same .exe file won't run on a Mac and you would have to re-translate the original program again.

Interpreted Code

: In a purely interpreted language (like Python or early Ruby), there is no pre-translation. Instead, a program called an Interpreter reads your code line-by-line while the program is running, converts it into machine code, and then the machine runs it. The pro is that the same programmer-written code can now run on any computer as long as that computer has the right interpreter installed. The con is that it is slower. The computer has to "waste" time translating while it's trying to work. If you have a loop that runs 1,000 times, the interpreter translates those same lines 1,000 times.

What Java does

: Java combines the two steps:
1) Compile to Bytecode: Compile your Java code into Bytecode by running javac HelloWorld.java. This will output HelloWorld.class intermediate file that can't be directly understood by you or the computer. Only the JVM can understand this.
2) JIT: When you run the program using java HelloWorld, the JVM interprets the bytecode, converting it into machine code that the computer can understand. If the compiler sees a piece of bytecode being used a lot, it will use the JVM (HotSpot) JIT to compile that specific part into native machine code on the fly so that it doesn't have to interpret it every time.

Ahead-of-Time compilation

: Java also has tried Ahead-of-Time compilation. Java must be turned into Bytecode first. AOT is the process of taking that universal Bytecode and converting it into a native binary before you ship it. The most significant way AOT lives in Java today is through GraalVM. Why? In "Serverless" computing (like AWS Lambda), you want your code to start in milliseconds. A traditional JIT-based Java app might take seconds to start - which is too slow. GraalVM AOT makes Java competitive with languages like Go or Rust for these tasks.
- Also see notes on the other page.

- An object-oriented program can be characterized as data controlling access to code. The data is wrapped in a protective shell, and it "owns" the code that is allowed to touch it. For instance, the data says, "I am a BankAccount object. I contain a private 'Balance.' If you want to change me, you must use my specific deposit() or withdraw() methods. You cannot touch the balance directly." - The three OOP principles are:
a)

Polymorphism

: Meaning 'many forms', this is the ability for objects of different classes to be treated as objects of a common superclass, allowing a single action (like a method call) to be performed in different ways depending on the object's actual type.
b)

Inheritance

: A mechanism that allows a new class (the subclass) to acquire the properties and behaviors of an existing class (the superclass), promoting code reuse and establishing a hierarchy of objects.
c)

Encapsulation

: bundle data and the methods that operate on that data together within a single unit - the Class, hiding the internal state from the outside world.

- For some computer languages, the name of the file that holds the source code to a program is immaterial. However, this is not the case with Java. The first thing that you must learn about Java is that the name you give to a source file is very important.
- In Java, a source file is officially called a compilation unit. The Java compiler requires that a source file use the .java filename extension. It is a text file that contains (among other things) one or more class definitions.
- You are allowed at max one public class per .java file and, if the public class is present, then the name of the .java file must match the name of the public class. Because of this rule, the compiler can instantly locate the source code for a class (e.g., ProcessPayload will always be in ProcessPayload.java), drastically speeding up compilation times for large projects.
-

Compile the program

: javac Example.java. This creates a file called Example.class that contains the compiled bytecode.
-

Run the Program

: java Example. Invokes the JVM to execute the bytecode. Note that you are passing the class name, and not the file name. ie you are not using java Example.class.
- Java also has Nested classes, where a class can have another class. In this case too java will create a separate .class file for every single inner class. Because they don't have unique top-level names, Java names them using a $ symbol:

• Outer.class
• Outer$Inner.class (For member inner classes)
• Outer$1LocalInner.class (For local/anonymous classes, using a number to distinguish them)

// Saved in a file named Outer.java
class Outer {
    // 1. Member Inner Class
    // Compiles to: Outer$Inner.class
    class Inner {
        void display() {
            System.out.println("Inside member inner class.");
        }
    }

    void someMethod() {
        // 2. Local Inner Class inside a method
        // Compiles to: Outer$1LocalInner.class
        class LocalInner {
            void print() {
                System.out.println("Inside local inner class.");
            }
        }
        // Instantiating and using the local class within the method
        LocalInner local = new LocalInner();
        local.print();
    }
}