Java Online Editor

Let's start with Java basics and object-oriented programming:

public class HelloJava {
    public static void main(String[] args) {
        // Basic output
        System.out.println("Hello, Java!");

        // Variables and data types
        String name = "Java Programming";
        int number = 42;
        boolean isTrue = true;
        double pi = 3.14159;

        // String concatenation
        System.out.println("Welcome to " + name + "!");
        System.out.printf("Number: %d, Pi: %.2f%n", number, pi);
    }
}

Our editor provides real-time execution and syntax highlighting.

Learn object-oriented programming fundamentals:

// Define a class
public class Person {
    // Private fields
    private String name;
    private int age;

    // Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter methods
    public String getName() { return name; }
    public int getAge() { return age; }

    // Method
    public void greet() {
        System.out.println("Hello, I'm " + name + " and I'm " + age + " years old.");
    }
}

public class Main {
    public static void main(String[] args) {
        // Create objects
        Person person1 = new Person("Alice", 25);
        Person person2 = new Person("Bob", 30);

        // Use objects
        person1.greet();
        person2.greet();
    }
}

Practice object-oriented concepts in our interactive environment.

Master functional programming with Streams:

import java.util.*;
import java.util.stream.*;

public class StreamExample {
    public static void main(String[] args) {
        // Sample data
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Diana");

        // Stream operations
        List<Integer> evenNumbers = numbers.stream()
            .filter(n -> n % 2 == 0)
            .collect(Collectors.toList());

        List<Integer> squares = numbers.stream()
            .map(n -> n * n)
            .collect(Collectors.toList());

        int sum = numbers.stream()
            .mapToInt(Integer::intValue)
            .sum();

        // Display results
        System.out.println("Even numbers: " + evenNumbers);
        System.out.println("Squares: " + squares);
        System.out.println("Sum: " + sum);

        // Complex operations
        List<String> longNames = names.stream()
            .filter(name -> name.length() > 4)
            .sorted()
            .collect(Collectors.toList());

        System.out.println("Long names: " + longNames);
    }
}

Explore powerful functional programming capabilities.

Learn proper error handling patterns:

public class ExceptionExample {
    public static void main(String[] args) {
        // Basic try-catch
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Error: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("Unexpected error: " + e.getMessage());
        } finally {
            System.out.println("Cleanup code runs here.");
        }

        // Try-with-resources
        try {
            String input = "123";
            int number = Integer.parseInt(input);
            System.out.println("Parsed number: " + number);
        } catch (NumberFormatException e) {
            System.out.println("Invalid number format");
        }
    }

    public static int divide(int a, int b) throws ArithmeticException {
        if (b == 0) {
            throw new ArithmeticException("Cannot divide by zero");
        }
        return a / b;
    }
}

Practice robust error handling in our safe environment.

Master Java collections framework:

import java.util.*;

public class CollectionsExample {
    public static void main(String[] args) {
        // ArrayList
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        System.out.println("Fruits: " + fruits);

        // HashMap
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Alice", 25);
        ages.put("Bob", 30);
        ages.put("Charlie", 35);

        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue() + " years old");
        }

        // Set
        Set<String> uniqueNames = new HashSet<>();
        uniqueNames.add("Alice");
        uniqueNames.add("Bob");
        uniqueNames.add("Alice"); // Duplicate ignored
        System.out.println("Unique names: " + uniqueNames);
    }
}

Explore comprehensive collection types and operations.

Learn advanced OOP concepts:

// Interface
interface Drawable {
    void draw();
    default void print() {
        System.out.println("Printing shape...");
    }
}

// Abstract class
abstract class Shape implements Drawable {
    protected String color;

    public Shape(String color) {
        this.color = color;
    }

    public abstract double getArea();
}

// Concrete implementation
class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a " + color + " circle");
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle("red", 5.0);
        circle.draw();
        circle.print();
        System.out.printf("Area: %.2f%n", circle.getArea());
    }
}

Master inheritance and polymorphism concepts.

Our Java editor runs Java 8 via Doppio JVM (WebAssembly) with specific constraints:

Version & Environment:

• Java 8 via Doppio JVM (WebAssembly)
• Full Java 8 features including Stream API, Optional, LocalDateTime
• Memory limit: ~512MB for applications
• Console applications only

Key Limitations:

• No reflection or dynamic class loading
• No file I/O operations (java.io.*)
• No threading (java.util.concurrent.* disabled)
• No network operations (java.net.*)
• No JNI or native library access
• No serialization/deserialization
• No GUI frameworks (Swing/JavaFX)
• No database connections (JDBC)
• No subprocess execution

Available Features:

// Core Java libraries available
import java.util.*;
import java.lang.*;
import java.time.*;
import java.math.*;
import java.text.*;

// Collections, streams, algorithms supported

Focus on algorithms, data structures, and core Java concepts.

Explore these official resources and learning materials:

Official Documentation:

• Oracle Java 8 Documentation - Complete Java 8 reference
• Java Language Specification - Technical specification
• Oracle Java Tutorials - Official learning path
• Java 8 API Documentation - Standard library reference
• Java 8 Stream API Guide - Stream operations

Learning Resources:

• Google Java Style Guide - Code conventions
• Effective Java 2nd Edition - Best practices by Joshua Bloch
• Java Code Geeks - Tutorials and examples
• Baeldung Java - In-depth Java tutorials

Enterprise Development:

• Spring Framework 4.x - Compatible with Java 8
• Java EE 7 Tutorial - Enterprise edition guide
• Maven Documentation - Build and dependency management

WebAssembly & Doppio:

• Doppio JVM - WebAssembly JVM implementation
• LiveCodes Java Support - Browser-based Java development

These resources cover Java 8 from basics to enterprise-level development!