SE 109 - Lecture 3: Introduction to Java

Outline of Lecture 3

• Introduction of Java
• Brief Description of Java
• History of Java
• Java Environment & Architecture
• Basic Java Program Elements & Structure
• Compiling and Running Java Programs

Introduction to Java

History of Java

Why Java was created?

• Troubles with C/C++ (memory management, portability issues).
• C/C++ are not inherently portable or platform-independent.
• Emergence of the WWW demanded portable programs (Applets).
• Need for improved Portability and Security.

Timeline Highlights:

(Slide 12 showed a detailed version history with specific release years for JDK versions, indicating Sun Microsystems origin and later Oracle acquisition).

Java Editions

Java technology comes in different editions tailored for specific types of development:

• Java SE (Standard Edition): (Formerly J2SE) For developing desktop applications, console applications, and applets. This is the core platform.

  (Slide 14 showed desktop/laptop computers).

• Java ME (Micro Edition): (Formerly J2ME) For developing applications for devices with limited resources, like mobile phones (older feature phones), set-top boxes, embedded devices, smart cards, Raspberry Pi.

  (Slide 15 showed mobile phones and a set-top box).

• Java EE (Enterprise Edition): (Formerly J2EE, now Jakarta EE) Builds on Java SE. Used for developing large-scale, multi-tiered, reliable, and secure enterprise applications, often server-side and distributed. Includes APIs for web services, servlets, JavaServer Pages (JSP), etc.

  (Slide 16 showed server hardware and a web browser interface).

How Java is Different from C++

• Pointers: Java does not support explicit pointers, reducing complexity and memory errors. It uses references managed by the JVM.
• Data Structures: Java doesn't include C++'s `struct`, `union`, or `enum` (though Java has its own `enum` type introduced later, which is more object-oriented).
• Operator Overloading: Java does not allow user-defined operator overloading (except for `+` for String concatenation).
• Global Variables: Java doesn't support global variables; all variables and methods must be declared within a class.
• Object Passing: Java passes object references by value. This means the method receives a copy of the reference, allowing modification of the object's state, but not changing which object the original variable refers to. C++ allows passing by value, reference, or pointer.
• Compilation Target: C++ compiles directly to native executable code for a specific platform. Java compiles to platform-independent Bytecode (`.class` file), which is then interpreted or JIT-compiled by the JVM on the target platform.

(Slide 19 showed a comparison diagram: `MyProg.java` -> `javac` -> `MyProg.class` (Bytecode) -> JVM -> OS, versus `MyProg.cpp` -> `gcc` -> `myprog.exe` (Executable) -> OS).

New Features Added in Java (Compared to C/C++)

• Multithreading: Built-in support for concurrent execution of different parts of a program.
• Packages: Mechanism for organizing related classes and interfaces, managing namespaces.
• Interfaces: Define contracts for classes, enabling a form of multiple inheritance of type.
• Automatic Garbage Collection: JVM automatically manages memory deallocation, preventing memory leaks common in C/C++.
• Boolean Data Type: Native `boolean` type (`true`/`false`).
• Exception Handling: Robust mechanism (similar to C++'s `try`/`catch`) for handling runtime errors.

Java Applications

Java is used in a wide variety of applications:

• Web-based applications and web development (e.g., backend systems for LinkedIn, Amazon, using frameworks like Spring).
• Big Data technology (e.g., Apache Hadoop framework is written in Java).
• Internet of Things (IoT) devices.
• Android Apps (Java is an official language for Android development, alongside Kotlin).
• Desktop Applications (using libraries like Swing or JavaFX).
• Computer games (e.g., Minecraft).
• Enterprise applications, scientific computing, financial trading platforms, etc.

Characteristics of Java (Summary)

1. Simple: Familiar C/C++ syntax, automatic memory management (garbage collection).
2. Object-Oriented: Everything (except primitives) is an object; programs structured around classes.
3. Distributed: Designed for network environments (supports TCP/IP, RMI, etc.).
4. Robust: Strong compile-time error checking, strict runtime checking, exception handling, garbage collection reduce errors.
5. Secure: Security features (Security Manager, bytecode verification, sandboxing for applets) prevent destructive actions.
6. Platform Independent (Architecture Neutral): Achieved through bytecode and JVM. WORA.
7. Portable: Platform independence plus standard library definitions ensure code runs similarly everywhere.
8. Interpreted: JVM interprets bytecode at runtime (though JIT compilation makes it fast).
9. High Performance: JIT compilers translate bytecode into native machine code for near-native speed.
10. Multithreaded: Built-in support for concurrent programming.
11. Dynamic: Classes loaded on demand; supports reflection.

Compiled and Interpreted Nature

Java Environment

JVM Components

• Class Loader: Dynamically loads `.class` files (bytecode) from disk or network into memory when needed.
• Bytecode Verifier: Checks the loaded bytecode for validity and security issues (e.g., proper format, no stack overflows, valid type conversions) before execution.
• Execution Engine: Executes the verified bytecode. This can be done via:
  • Interpreter: Reads and executes bytecode instructions one by one. Slower but starts faster.
  • Just-In-Time (JIT) Compiler: Compiles frequently used bytecode into native machine code during runtime for faster execution. There's an initial compilation delay, but subsequent calls are much faster.
• Garbage Collector: Automatically reclaims memory occupied by objects that are no longer referenced by the program.
• Other components: Runtime data areas (heap, stack, method area), native method interface, etc.

Java Program Types

• Application: A standalone program that runs directly on the host operating system using the JRE/JVM (like programs written in C/C++).
• Applet: (Largely obsolete now) A small Java program designed to be embedded within an HTML page and executed by a web browser's JVM plugin. Applets ran in a restricted "sandbox" environment for security.

Fundamental Language Elements

• Reserved Words (Keywords): Words with special meaning to the compiler (e.g., class, public, static, void, int, if, for). Cannot be used as identifiers. (Over 40 in Java).
• Identifiers: Names given by the programmer to classes, methods, variables, objects, etc. Must follow specific rules (e.g., start with letter, $, or _; contain letters, digits, $, _).
• Curly Braces {}: Define blocks of code (e.g., class bodies, method bodies, loop bodies). Always come in pairs.
• White Space: Spaces, tabs, newlines. Mostly ignored by the compiler but crucial for human readability. Required to separate identifiers and keywords. Indentation is used to show program structure.
• Comments: Ignored by the compiler, used for human explanation.
  • // Single-line comment
  • /* Multi-line comment */
  • /** Javadoc comment */ (Used by the javadoc tool to generate documentation).

The Simple Structure of a Method

Compiling and Running a Simple Program

// A program to print "hello, world".
class Hello {
    // main method - program execution begins here
    public static void main(String[] args) {
        // Print the text "hello, world" to the console
        System.out.println("hello, world");
    }
}

The Edit-Compile-Run Cycle:

1. Edit: Create/save the source code in a file named `Hello.java` (the filename must match the public class name).
2. Compile: Use the Java compiler:

   javac Hello.java

   This generates the bytecode file `Hello.class`. If there are errors, edit the code and recompile.
3. Run: Use the Java Virtual Machine (interpreter):

   java Hello

   (Note: Do not include the `.class` extension when running). The JVM loads `Hello.class`, finds the `main` method, and executes it.

Bytecode Files (`.class`)

• The Java compiler creates one `.class` file for each class defined in the source code.
• This file contains platform-independent bytecode.
• The same `.class` file can be run on any machine with a compatible JVM.

Simple Java Application Example Walkthrough

Let's re-examine the example from the slides:

// code1 The TestGreeting.java Application
// Sample “Hello World” Application
public class TestGreeting { // Class name matches filename

    public static void main (String [] args) { // Main method entry point

        // 1. Create an object (instance) of the Greeting class
        // 'new Greeting()' calls the constructor and allocates memory
        // 'hello' is a variable holding the reference (address) to the object
        Greeting hello = new Greeting();

        // 2. Send a message (call the greet() method) to the object
        // referred to by the 'hello' variable
        hello.greet();

    } // end main
} // end class TestGreeting

// Code 2-2 The Greeting.java class
public class Greeting { // Another class definition

    // Method definition for the greet behavior
    // 'public' means it can be called from other classes (like TestGreeting)
    // 'void' means it doesn't return any value
    public void greet() { // Between the parentheses, don’t write void

        // Use the System class's 'out' object (standard output stream)
        // and call its 'println' method to print text to the console
        System.out.println("Hello ALL");

    } // end greet method
} // end class Greeting

Explanation Notes:

• public class TestGreeting: Declares the class. Filename must be `TestGreeting.java`. Compilation creates `TestGreeting.class`.
• public static void main (String [] args): The entry point. The JVM starts execution here. The class containing `main` must have the same name as the `.java` file.
• Greeting hello = new Greeting();: Creates an object of the `Greeting` class. The `new` operator allocates memory and returns a reference, which is stored in the variable `hello`.
• hello.greet();: Calls the `greet()` method *on the specific `Greeting` object* that `hello` refers to.
• System.out.println("..."): Prints the string literal to the standard output console.
  • System: A built-in class in the java.lang package (imported automatically).
  • out: A `static` member variable of the `System` class. It's an object of type `PrintStream` representing the standard output. Being static, it's accessed via the class name (`System.out`).
  • println(...): A method of the `PrintStream` class (the object `out`) that prints the argument followed by a newline.
• Compilation: When you compile `TestGreeting.java` (e.g., `javac TestGreeting.java`), the compiler sees that it uses the `Greeting` class. If `Greeting.java` is in the same directory (or accessible via the classpath), it will also be compiled automatically, creating `Greeting.class`.
• Running: When you run `java TestGreeting`, the JVM loads `TestGreeting.class`, finds `main`, creates the `Greeting` object, and calls its `greet` method, resulting in "Hello ALL" being printed.

Working with Java Tools (Command Line)

• Setting the Path: To run `javac` and `java` from any directory, you need to add the JDK's `bin` directory (e.g., `C:\Program Files\Java\jdk-17\bin`) to your system's PATH environment variable.
• Compiling with Path: If not in the directory, you can specify the full path: `javac C:\path\to\your\code\TestGreeting.java`.
• Viewing Bytecode: `javap -c ClassName` (e.g., `javap -c TestGreeting`) disassembles the `.class` file and shows the bytecode instructions.
• Generating Documentation: `javadoc FileName.java` or `javadoc *.java` uses the `/** ... */` comments to generate HTML documentation for your code.