Intro to Java

• Computers understand machine code.

Chapter Objectives

• The chapter aims to introduce Java, including its execution, environment architecture, and setup.

Intro to Java

• Java is a high-level, versatile, and powerful programming language.
• Java was created by James Gosling at Sun Microsystems in 1995.
• The initial need for Java was to develop software for electronic devices like TVs and embedded systems.
• Java is designed around the concepts of Object-Oriented Programming (OOP).
• Java is portable to any OS with a JVM.
• Java has evolved to support web, enterprise, and mobile application development.
• Java offers a high level of security for safe execution in a distributed environment.

Java: Platforms

• Java is the programming language used to create applications that run on specific platforms.
• Java SE is for general-purpose programming.
• Java EE is for enterprise-level applications.
• Java ME is for embedded and mobile devices.
• Java FX is for rich desktop applications.
• Java Card is for smart cards and small devices.
• Android is for mobile applications.

Java: Key Features

• Java is object-oriented.
• Java is portable, meaning code works consistently across different hardware and OS.
• Java has built-in features to prevent unauthorized access and ensure safe execution in distributed environments.
• Java enables simultaneous execution of tasks using multithreading.
• Java provides strong memory management and exception handling, making it robust.
• Java promotes error-free programming through runtime checks and strict typing.
• Java enables faster development cycles and dynamic code updates, making it interpreted and dynamic.
• Java allows the development of applications that can perform multiple tasks simultaneously by being multithreaded.

Java: High Level Language

• Java is categorized as a high-level programming language.
• Java is closer to human language and abstracts complexities of the underlying hardware.
• High-level languages enable developers to write instructions that are easier to understand, read, and maintain.

High Level Language - Abstraction

• Java abstracts the underlying hardware and OS.
• Abstraction allows developers to focus on solving problems rather than managing low-level details such as memory allocation and processor instructions.

High Level Language - Simplified Syntax

• Java's syntax is human-readable and structured.
• The simplified syntax reduces the complexity of writing programs compared to low-level languages.

High Level Language - Automatic Memory Management

• Java includes garbage collection, which automates memory management.
• With Garbage collection it prevent memory leaks, which is a common challenge in low-level programming.

High Level Language - Platform Independence

• Programs written in Java can run on any system with a Java Virtual Machine (JVM).
• The JVM adheres to the "Write Once, Run Anywhere" principle.

High Level Language - Robust Standard Libraries

• Java provides an extensive set of prebuilt libraries.
• The libraries making it easier to implement common functionalities without reinventing the wheel.

Java: Portability

• Portability means platform-independent.
• Portability is often summarized as "Write Once, Run Anywhere" (WORA).
• A Java program can be executed on devices with different operating systems without modifying the original code.
• To execute the code, the target machine must acquire the necessary tools to run Java programs (JVM).

Interpreted vs Compiled Languages

• Compiled languages convert the entire source code into machine code via a compiler before execution.
• Interpreted languages translate source code into machine code line-by-line at runtime using an interpreter.
• Compiled languages have programs that run quickly but are platform-specific.
• Interpreted languages are more flexible but slower compared to compiled languages.

Java Compilation

• Java is compiled into bytecode using the javac compiler.
• Afterwards, bytecode is interpreted and run via a Java Virtual Machine (JVM).
• Java is one of the hybrid programming languages that uses both interpretation and compilation.
• Java source code is written in .java files and compiled into bytecode (.class files) using the javac compiler.
• The Java Virtual Machine (JVM) will take over, loading the bytecode and converting it into machine-specific code through interpretation or Just-In-Time (JIT) compilation.
• Finally, the JVM then executes the machine code on the hardware.

Java: Java Source Code

• Java source code is written in .java files.
• It is the starting point for creating Java applications.
• It is the human-readable program written by developers using the Java programming language.
• The source code contains instructions and logic that define how the program should behave.

Java: Compiler - Javac

• The Java Compiler JAVAC converts source code written in java files into bytecode.
• Bytecode is an intermediate, platform independent representation stored in .class files.
• It checks for syntax errors and ensures the code adheres to the Java language rules.

Java: Java Bytecode

• Java bytecode is generated by the javac compiler (javac).
• It is found in .class files.
• Java bytecode is a platform-independent intermediate format of the source code.
• Java bytecode is used to ensure the portability of the programs.
• Java programs can then be executed on any machine that has a Java Virtual Machine (JVM).
• This ensures Java programs are compatible across different platforms without modification.

Java: Native Code

• Machine-dependent native code (or machine language) is the code that can be directly executed by a computer's hardware.
• Native code is specific to the OS and processor architecture of the machine.
• When the JVM runs a Java program, it converts the platform-independent bytecode into native code using Just-In-Time (JIT) compilation.
• Finally, the program can run efficiently on the specific hardware it is being executed on.

Java Bytecode Vs Native Code

• Java bytecode is an intermediate representation and output as a .class file of the Javac compiler.
• It Java bytecode is generated in the compile-time environment during software creation and is machine independent.
• Java machine native code is a final representation, and is generated by the JVM using the Java interpreter and JIT.
• Java native code is used by the JVM to execute the program and is machine dependent.

Java Development Kit (JDK)

• Java Development Kit (JDK) is a kit for Java software development.
• JDK is an environment for writing, compiling, and debugging Java programs.
• The JDK is platform-dependent, each platform requires its own JDK.
• The JDK enables developing and executing the java program.
• It includes the Java runtime environment JRE to run java programs and Development tools to create/compile and debug java programs.

Java Runtime Environment (JRE)

• Java Runtime Environment (JRE) provides the minimum environment for running Java applications.
• It provides tools to only-run the Java program on a machine.
• The JRE contains the Java virtual machine JVM.
• The JRE supports libraries, APIs and tools necessary to run Java programs.
• Libraries are essencial for running Java applications.
• APIs allow Java programs to interact with the runtime environment and external systems.
• Tools are what is used to run Java applications (e.g., java, javaw, keytool).
• The JRE is a platform dependent.
• JRE is only used when only running Java programs.

Java Virtual Machine (JVM)

• The JVM is the core component of the JRE. -The JVM enables the computer to execute the Java compiled bytecode (.class.)
• It ensures a platform-independent application by converting bytecode into machine-specific instructions.
• It contains only the runtime environment that helps in executing the Java bytecode.

JVM Detailed Architecture

• The Class Loader Hierarchy in Java is a structured system of class loaders responsible for loading classes into the JVM.
• The ByteCode Verifier ensures bytecode is valid, secure, and follows JVM rules.
• The Runtime Data Area contains Memory areas for class data, objects, methods, and threads.
• The Execution Engine executes bytecode (interprets or JIT-compiles to native code).
• The Native Method Interface (JNI) allows Java code to interact with native code (e.g., C/C++).
• The Native Method Library contains native code (e.g., C/C++) used by Java via JNI.

JVM - Class Loader Hierarchy

• The Class Loader Hierarchy in Java is a structured system of class loaders responsible for loading classes into the JVM.
• It consists of three main levels: Bootstrap, Extension, and Application Class Loader.
• This hierarchy follows a delegation model, where a class loader first delegates the request to its parent before attempting to load the class itself.
• This delegation model ensures security, prevents duplicate loading, and maintains a clear separation between core, extension, and application classes.

JVM - Runtime Data Area

• The Runtime Data Area in the JVM is the memory area where the JVM stores data during the execution of a Java program.
• It is divided into several components, each serving a specific purpose.
• The JVM provides structured memory areas for different types of data, manages the object lifecycle, and support multithreading within the Runtime Data Area

Java - Components of the Runtime Data Area

• Method Area stores class-level data, such as class structures, method code, constants, and static variables.
  • It is shared among all threads.
• Heap stores objects and arrays created during program execution.
  • It is shared among all threads and managed by the Garbage Collector.
• Stack has each thread has its own stack, which stores method frames.
  • Each frame contains local variables, method parameters, and return addresses.
  • Used for method invocation and execution.
• PC (Program Counter) Register stores the address of the current instruction being executed for each thread.
• Native Method Stack is used for native methods (e.g., methods written in C/C++).
  • Each thread has its own native method stack.

Native Method Interface(JNI)

• The Native Method Interface has a framework/API that allows Java code to interact with native code.
• Serves as bridge between Java and native code, so programs may to call native methods.
• The Native Method Library is a collection of pre-compiled native code that can be used by Java programs.
• Libraries provides native implementations of specific functionalities that Java programs can access via JNI.
• JNI is the interface/mechanism that enables communication between Java and native code, whereas the Native Method Library is the actual native code.

JVM - How it Works

• Loads Bytecode: The JVM loads .class files (bytecode) into memory using the Class Loader.
• Verifies Bytecode: The JVM verifies the bytecode to ensure it is valid, secure, and adheres to JVM specifications.
• Prepares Runtime Environment:: Prepares and organizes memory using Runtime Data Areas (Method Area, Heap, Stack, PC Registers, Native Method Stack)
• Executes Bytecode: The JVM interprets the bytecode line by line or compiles it into native machine code using the Just-In-Time (JIT) Compiler for faster execution.
• Manages Runtime Tasks:: The JVM handles memory management, including garbage collection to reclaim unused memory.
• It also manages threads, synchronization, and exception handling.
• Interacts with Native Libraries: The JVM uses the Java Native Interface (JNI) to interact with native code (e.g., C/C++ libraries).

JVM: Key Features

• The JVM handles memory allocation and automatically releases unused memory using the garbage collector to prevent memory leaks.
• The Just-In-Time (JIT) compiler dynamically compiles frequently executed bytecode into native machine code to improve performance.
• The JVM enhances security by operating within a controlled environment, known as the sandbox, ensuring that external code cannot tamper with or execute alongside the main program.

JVM: How the execution engine work

• Inital Interpretation: When a Java application is run, the JVM initially interprets the bytecode. -This is slower compared to direct machine code execution but avoids the upfront cost of compilation.
• Monitoring and Profiling: As the JVM interprets the bytecode, it monitors which parts of the code are executed frequently; profiling.
• Just-In-Time (JIT) Compilation: The JVM identifies "hot spots" in the code—sequences of bytecode that are executed frequently and compiles them into native machine code by the JIT compiler.
• Selective Compilation: Bytecode that is executed only a few times is not compiled but continues to be interpreted.
  • This saves initial compilation time and latency.
• Optimization: The JIT compiler can perform various optimizations based on the execution statistics collected during the interpretation phase.
• Execution: Hot spots already being compiled, the application runs faster because the most frequently executed parts of the code are in native machine code.

JVM Interpret Bytecode

• The JVM interpreters bytecode intially to reduce latency.
• Leaves infrequently executed code interpreted to save resources.

JVM Compiles Bytecode

• Compiles frequently executed code (hot spots) using JIT for speed.
• Uses multiple compilation levels for balance.
• Tools can allow pre- runtime compilation.

JVM: Common Errors

• Common errors will be related to :
  • Memory,Class Loading, Native Code ,ThreadErrors, Configuration and argument issues

JRE Vs JDK

• The JRE only offers an environment for running compiled Java program, whereas the JDK offers a kit of tools to develop and run java programs.

JRE Vs JVM

• The JRE only offers an environment for running Java program, whereas the JVM offers tools to execute the Java bytecode.
• It has all the components that comprise the runtime environment, such as, JIT, interpreter, garbage collection, etc.

Environment Requirement

• The Java Development Kit (JDK) is needed if you want to code in JAVA.
• It offers tools to create, compile and debug Java softwares

Setup Steps:

• Install Java Development Kit (JDK) - System dependent.
• Install an Integrated Development Environment (IDE) - Makes Java programming easier.
• Test the environment: Run a sample program to ensure correct installation.

JDK Setup in Windows

• Download the latest JDK installer from Oracle's or OpenJDK website.
• Run the installer and note the installation path.
• Set environment variables by opening Control Panel, going to System and Security, then System, and Advanced system settings.
• Verify installation by opening command prompt and running java -version then javac -version.

JDK Setup: Mac

-Download the macOS installer from Oracle or OpenJDK website. -Setup homwbrew (optional). -Run it and follow the promts. -Verify the installation

JDK - Ubunut

• Update Package list and install OpenJdk
• Sudo apt update and Sudo apt install open jdk-2.1jdk Verify Installation
• Using the console write java -version and javac -version

IDE

Steps. to properly setting up on either

• VS and Intellij

First Java Program

• Create a java file
• Compile the code and run.
• View Output in Console, the basic setup is successful

Summary of Java steps

• Write source code, compile, load, execute, manage the program and then finally terminate
• Compile the class which will generate a Class file and then output the class to run the start statement.