Java Syntax Cheat Sheet

When developing software at IOFLOOD, having a solid understanding of Java syntax and concepts is essential for creating the dedicated cloud hosting ecosystem that meet our clients’ needs. To streamline the learning process and help developers grasp Java fundamentals quickly, we’ve crafted this comprehensive Java Syntax Cheat Sheet.

This reference guide covers all the important uses of Java programming. It serves as a comprehensive Reference for the Java language and syntax, and offers practical code examples.

Let’s embark on this journey to unlock Java’s full potential. Let’s code!

Command Reference

Before providing the code example, we will list all of the essential Java Programming commands and concepts. These terms will be used in action in the code examples following this section. Utilize this reference to learn more about the example code as well as boost your Java development workflow.

Data Types

Operators

Relational Operators

Logical Operators

Assignment Operators

Unary Operators

String Manipulation

String Methods

StringBuilder Methods

Note: ‘String’ in Java is immutable, once created, it cannot be changed. Meanwhile StringBuilder offers a mutable character sequence, allowing for in-place modifications without creating new objects. This makes StringBuilder more efficient for operations that involve frequent changes to a string’s content.

Comments

Exception Handling

Common Exceptions

Object-Oriented Programming (OOP) Concepts

Access Modifiers

Note: Access modifiers in Java determine the visibility of classes, methods, and variables within other classes and packages.

Control Structures and Loops

Data Structures

Data Structure Methods

Sort Functions

Method Parameters

Variable Arguments (VarArgs)

Casting and Conversion

Web Development and Frameworks

Java Versions

Note: LTS stands for Long Term Support, indicating a version with extended support and updates.

Code Examples

In this segment, we will delve into a simple Java program designed to showcase how various Java Programming Concepts work together, encompassing everything from basic syntax to more complex concepts such as exception handling and streams. This reference can be used to gain more information about the code examples above.

Before the code examples, we will walk you through setting up a Java environment, in case you don’t have one set up already. The following instructions are for general use, so for OS specific instructions you can check out our Java Installation Guides!

Setting Up The Environment

1. Install Java Development Kit (JDK): The JDK is necessary for compiling and running Java applications. If you don’t have it installed, you can download it from the Oracle website or adopt an OpenJDK version from an open-source provider.

2. Set Up an Integrated Development Environment (IDE): While you can compile and run Java programs from the command line, using an IDE like IntelliJ IDEA, Eclipse, or NetBeans can simplify the process and provide additional tools for debugging and managing your projects. Download and install an IDE of your choice.

3. Create a New Java Project: Open your IDE and create a new Java project. This process will vary depending on the IDE, but generally, you’ll need to specify a project name and location on your filesystem.

4. Add Java Classes: Within your new project, create two new Java class files named JavaSyntaxReference.java and Book.java. Copy and paste the provided code for each class into the respective files.

5. Compile and Run: Use your IDE’s built-in features to compile and run the JavaSyntaxReference class. This class contains the main method, which serves as the entry point for the application.

Alternative: Command Line Compilation

For those who prefer working directly from the command line:

1. Save the Classes: Save the provided JavaSyntaxReference.java and Book.java code into two separate files within the same directory.

2. Open a Terminal/Command Prompt: Navigate to the directory where you saved the files.

3. Compile the Classes: Run the command javac JavaSyntaxReference.java Book.java to compile both files, producing .class files runnable on the Java Virtual Machine (JVM).

4. Run the Main Class: Execute the command java JavaSyntaxReference to run the compiled main class.

Note: The provided code is designed to be as dependency-free as possible, focusing on raw Java without external libraries. This ensures that a basic Java setup can compile and run the examples with minimal effort.

Sample Class

Before we dive into the main program, we begin with an example Java class. Defining and utilizing classes allows us to encapsulate data and behavior, promoting code reusability and scalability. This class, used in our main sample program, provides an example of Object Oriented Programming, one of the core principles in Java Programming.

public class Book {
    // Variables: Define attributes of the Book class
    private String title;
    private boolean isAvailable;

    // Constructor: Initializes a new instance of the Book class
    public Book(String title) {
        this.title = title;
        this.isAvailable = true; // By default, a new book is available
    }

    // Method: Gets the title of the book
    public String getTitle() {
        return title;
    }

    // Method: Checks if the book is available
    public boolean isAvailable() {
        return isAvailable;
    }

    // Control Structure (if-else): Borrow the book if it is available
    public void borrow() {
        if (isAvailable) {
            isAvailable = false;
            System.out.println(title + " has been borrowed.");
        } else {
            System.out.println(title + " is not available for borrowing.");
        }
    }

    // Method: Return the book and make it available again
    public void returnBook() {
        isAvailable = true;
        System.out.println(title + " has been returned.");
    }
}

// Extending the Book class to create a Magazine subclass
class Magazine extends Book {
    public Magazine() {
        super("Generic Magazine Title"); // Magazines typically don't have authors like books do, so we use a generic title
    }

    // Overriding the borrow method to demonstrate polymorphism
    @Override
    public void borrow() {
        if (isAvailable()) {
            System.out.println(getTitle() + " has been borrowed. Remember, magazines have a shorter borrowing period!");
        } else {
            System.out.println(getTitle() + " is not available for borrowing.");
        }
    }
}

In the main program, we will create an instance of Book, then call its methods to simulate borrowing and returning the book.

Java Sample Code

Presented here is our main sample class, intended to showcase a variety of Java programming techniques. We invite you to explore and study its construction for a hands-on understanding of Java syntax and operations.

public class JavaSyntaxReference {
    // Import statements to insure package inclusion
    import java.util.Arrays;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Scanner;
    import java.io.File;
    import java.io.FileWriter;
    import java.io.FileReader;
    import java.io.BufferedReader;
    import java.io.FileNotFoundException;
    import java.io.IOException;

    public static void main(String[] args) {
    /* The above line of code is the entry point of a Java application. 
    "public" makes it accessible from anywhere; 
    "static" means it belongs to the class, not instances of the class; 
    "void" indicates it returns no value. 
    "main" is the name recognized by the JVM as the starting point, 
    "String[] args" allows the program to accept an array of strings from command line arguments. */

        // Data Types
        String text = "Hello Java";
        double doubleVar = 10.5;
        boolean booleanVar = true;
        int integerVar = 10;        
        char charVar = 'A';     
        System.out.println(integerVar); 
        // Output: 10
        System.out.println(charVar); 
        // Output: A

        // Logical Operators
        boolean result = (integerVar < 20) && (doubleVar > 5.0);
        System.out.println(result); 
        // Output: true

        // Stack Data Structures
        java.util.Stack<Integer> stack = new java.util.Stack<>();
        stack.push(10);
        System.out.println(stack.peek()); 
        // Output: 10

        // ArrayList and an example of an ArrayList method (add(), remove(), get(), set())
        ArrayList<String> books = new ArrayList<>();
        books.add("Java Basics");
        books.set(0, "Advanced Java"); // Replaces "Java Basics" with "Advanced Java"
        books.remove("Advanced Java"); // Removes "Advanced Java", the list is now empty
        books.add("Java Concurrency"); // Adds "Java Concurrency" to the list
        System.out.println("ArrayList example: " + books); 
        // Output: ArrayList example: [Java Concurrency]

        // HashMap and an example of an HashMap method (put(), get(), remove())
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "Java");
        map.put(2, "Python");
        String language = map.get(1);
        map.remove(2);
        System.out.println(language); 
        // Output: Java

        // Array Manipulation: Fill an array with a specific value using Arrays.fill()
        int[] myArray = new int[5]; // Initializes an array of length 5
        Arrays.fill(myArray, 9); // Fills the entire array with 9
        System.out.println(Arrays.toString(myArray)); 
        // Output: [9, 9, 9, 9, 9]

        // Java Sort Functions - Using Arrays.sort

        int[] numbers = {5, 3, 4, 1, 2};
        java.util.Arrays.sort(numbers);
        System.out.println(Arrays.toString(numbers)); 
        // Output: [1, 2, 3, 4, 5]

        // Bubble Sort - Method defined below
        int[] numbers = {5, 3, 8, 4, 2};
        bubbleSort(numbers);
        System.out.println("Bubble Sorted: ");
        for (int num : numbers) {
            System.out.print(num + " ");  
            // Expected output: 2 3 4 5 8
        }
        System.out.println();  // Moves to the next line after printing the array

        // Selection Sort - Method defined below
        int[] moreNumbers = {22, 11, 99, 88, 9, 7, 42};
        selectionSort(moreNumbers);
        System.out.println("Selection Sorted: ");
        for (int num : moreNumbers) {
            System.out.print(num + " ");  
            // Expected output: 7 9 11 22 42 88 99
        }
        System.out.println();  // Moves to the next line after printing the array

        // Casting or Conversion
        double myDouble = 9.78;
        int myInt = (int) myDouble; // Explicit casting from double to int
        System.out.println(myInt); 
        // Output: 9

        // String Conversions: Using toString(), String.valueOf()
        int numForString = 500;
        String fromInt = String.valueOf(numForString);
        System.out.println("String.valueOf(): " + fromInt); 
        // Output: String.valueOf(): 500

        // StringBuilder
        StringBuilder sb = new StringBuilder();
        sb.append("StringBuilder ").append("Example");
        System.out.println(sb.toString());  
        // Output: StringBuilder Example

        // String Manipulation - String Methods
        String text = "Hello Java";
        String upperText = text.toUpperCase();
        System.out.println(upperText); 
        // Output: HELLO JAVA

        // Java Math Library
        double sqrtResult = Math.sqrt(25); // Square root
        System.out.println(sqrtResult); 
        // Output: 5.0

        // Java Time Library
        java.time.LocalDate currentDate = java.time.LocalDate.now();
        System.out.println(currentDate); 
        // Output: [Current Date]

        // Java File Handling
        java.io.File myFile = new java.io.File("example.txt");
        // Creates a File object that represents a reference to "example.txt" in the file system.

        // Appending text to "example.txt" w/ FileWriter
        try (FileWriter writer = new FileWriter("example.txt", true)) { // true to append
            writer.write("\nI love Java!"); // Appends a new line with the text "I love Java!" to the file.
        } catch (IOException e) {
            System.out.println("An error occurred while writing to the file: " + e.getMessage());
        }

        // Reading from "example.txt" using Scanner and printing its contents
        try (Scanner scanner = new Scanner(new File("example.txt"))) {
            while (scanner.hasNextLine()) {
                String line = scanner.nextLine();
                System.out.println(line);
                /* Expected console output:
                Learning Java with IOFlood is a blast!
                I love Java! */
            }    
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        }

        // Reading from "example.txt" using Scanner and printing its contents
        try (Scanner scanner = new Scanner(new File("example.txt"))) {
            while (scanner.hasNextLine()) {
                String line = scanner.nextLine();
                System.out.println(line);
                /* Expected console output:
                Learning Java with IOFlood is a blast!
                I love Java! */
            }    
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        }

        // Java Regular Expressions
        String pattern = ".*Java.*";
        boolean matches = "Hello Java".matches(pattern);
        System.out.println(matches); 
        // Output: true     

        // Control Structure: if-else
        int a = 5, b = 10;
        if (a < b) {
            System.out.println("a is less than b");
        } else {
            System.out.println("a is not less than b");
        }
         // Output: a is less than b

        // Loop: for
        for (int i = 0; i < 3; i++) {
            System.out.println("for loop iteration: " + i);  // Output will show for each iteration
        }

        // Loop: while
        int whileCounter = 3;
        while (whileCounter > 0) {
            System.out.println("while loop iteration");  // Output shown for each iteration
            whileCounter--;
        }

        // Loop: do-while
        int doWhileCounter = 2;
        do {
            System.out.println("do-while loop iteration"); 
            doWhileCounter--;
        } while (doWhileCounter > 0);
        /* Expected output:
        do-while loop iteration
        do-while loop iteration */      

        // Loop: Enhanced for
        int[] numbers = {1, 2, 3};
        for (int number : numbers) {
            System.out.println("Enhanced for loop: " + number);
        }
        /* Expected output:
        Enhanced for loop: 1
        Enhanced for loop: 2
        Enhanced for loop: 3 */

        // Use of 'continue' in a Java loop
        for(int i = 0; i < 5; i++) {
            if(i == 2) continue; // Skips the rest of the loop when i is 2
            System.out.println(i);
        }
        /* Expected output:
        0
        1
        3
        4 */

        // Switch-case
        int month = 4;
        switch (month) {
            case 1:
                System.out.println("January");
                break;
            case 2:
                System.out.println("February");
                break;
            default:
                System.out.println("Other Month");
        }
        // Expected output:
        // Other Month

        // Simple Method Call - Method defined below        
        System.out.println("Calling printMessage with a single string:");
        printMessage("This is a method call.");
        // Output: This is a method call.

        //VarArgs Method Call
        System.out.println("Calling printVarArgs with multiple strings:");
        printVarArgs("VarArgs Example:", "One", "Two", "Three");
        /* Output:
        VarArgs Example:
        One
        Two
        Three */

        // Exception Handling: try-catch
        try {
            int result = a / 0;
        } catch (ArithmeticException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
        // Expected output:
        // Exception caught: / by zero

        // Java 8 Stream
        int[] streamNumbers = {4, 5, 6};
        java.util.Arrays.stream(streamNumbers).forEach(System.out::println);
        /* Expected output:
        4
        5
        6 */

        // Note: The System.out::println syntax is used in within Java 8 Streams as a method reference,
        // a shorthand notation used when passing methods as arguments.

        // Object Instantiation with Constructors
        Book myFavoriteBook = new Book("The Art of Java");
        System.out.println("Book created: " + myFavoriteBook.getTitle()); 
        // Output: Book created: The Art of Java

        // Demonstrating Inheritance and Polymorphism
        Book myMagazine = new Magazine();
        myMagazine.borrow(); 
        // Output: Generic Magazine Title has been borrowed. Remember, magazines have a shorter borrowing period!

        // Method invocation: Borrowing the book
        System.out.println("Attempting to borrow the book...");
        myFavoriteBook.borrow(); 
        // Output: The Art of Java has been borrowed.

        // Checking if the book can be borrowed again (condition checking)
        System.out.println("Attempting to borrow the book again...");
        myFavoriteBook.borrow(); 
        // Output: The Art of Java is not available for borrowing.

        // Returning the book
        System.out.println("Returning the book...");
        myFavoriteBook.returnBook(); 
        // Output: The Art of Java has been returned.

        // Attempting to borrow the book after returning it
        System.out.println("Attempting to borrow the book after returning...");
        myFavoriteBook.borrow(); 
        // Output: The Art of Java has been borrowed.

        // Exception Handling with try-catch: Handling a NullPointerException
        try {
            Book myBook = null; // Intentionally set to null to trigger a NullPointerException
            System.out.println(myBook.getTitle()); // Attempting to access a method on a null reference
        } catch (NullPointerException e) {
            System.out.println("Caught a NullPointerException. Make sure your Book object is initialized before use.");
        }

    }

    // Method Definition
    static void printMessage(String message) {
        System.out.println(message);
    }

    // VarArgs Method
    static void printVarArgs(String... args) {
        for (String arg : args) {
            System.out.println(arg);
        }
    }


    // Bubble Sort method
    static void bubbleSort(int[] arr) {
        boolean swapped;
        for (int i = 0; i < arr.length - 1; i++) {
            swapped = false; // Track if a swap occurred
            // Iterate through the array, excluding the last sorted elements
            for (int j = 0; j < arr.length - i - 1; j++) {
                // Compare adjacent elements
                if (arr[j] > arr[j + 1]) {
                    // Swap if elements are in wrong order
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true; // Mark swap occurred
                }
            }
            // If no swap occurred, the array is sorted
            if (!swapped) break;
        }
    }


    // Selection Sort method
    static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIdx = i; // Assume current index as minimum
            // Find the minimum element in unsorted part
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIdx]) {
                    minIdx = j; // Update minimum index
                }
            }
            // Swap the found minimum element with the first element
            int temp = arr[minIdx];
            arr[minIdx] = arr[i];
            arr[i] = temp;
        }
    }

}

Our example code tackles a range of Java fundamentals and advanced concepts, from variable declaration and control structures to method definition and lambda expressions. Remember to utilize the reference section, and other java tutorials for more info on the concepts used in the example!

Conclusion

Java’s versatility and robustness as a programming language underscore the importance of mastering Object-Oriented Programming (OOP) and its concepts. This cheat sheet aims to equip you with a solid understanding of Java syntax and best practices. Whether you’re a novice stepping into the world of programming or a seasoned developer brushing up on Java, this guide is a valuable resource in your journey. We wish you good luck as you continue to excel in the realm of Java programming!