Skip to main content Link Menu Expand (external link) Document Search Copy Copied
Syntax Savvy

Hands-on Projects to Apply Concepts Learned Throughout the Curriculum

Header Image

Ahoy, mateys! Now that ye’ve conquered the treacherous seas of Java programming, it be time to put that knowledge to the test. We be settin’ sail for a series of hands-on projects that’ll have ye applyin’ all that ye’ve learned throughout yer Java journey. For our first adventure, we’ll be buildin’ a calculator application that can perform basic arithmetic operations. So hoist the Jolly Roger, and let’s dive into the code!

Building a Calculator Application

A calculator be a trusty tool for pirates when dividin’ up their plunder. To build a calculator application, we’ll start with the basic arithmetic operations: addition, subtraction, multiplication, and division. Then, we’ll create a simple user interface where the user can input the numbers and choose the operation to perform. Finally, we’ll display the result of the calculation.

Designing the Calculator Class

First, let’s create a Calculator class that’ll house the basic operations. These be the methods we’ll use to perform our calculations:

public class Calculator {

    public double add(double a, double b) {
        return a + b;
    }

    public double subtract(double a, double b) {
        return a - b;
    }

    public double multiply(double a, double b) {
        return a * b;
    }

    public double divide(double a, double b) {
        if (b == 0) {
            throw new IllegalArgumentException("Division by zero be forbidden, matey!");
        }
        return a / b;
    }
}

Now we’ve got ourselves a trusty Calculator class that can perform our desired arithmetic operations. But, what good be a calculator without a way for our fellow pirates to use it?

Creating the User Interface

To build a simple user interface, we’ll use Java’s Scanner class to read input from the user. This way, our calculator can accept numbers and the operation to perform.

import java.util.Scanner;

public class CalculatorApp {

    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter the first number:");
        double a = scanner.nextDouble();

        System.out.println("Enter the second number:");
        double b = scanner.nextDouble();

        System.out.println("Choose an operation (+, -, *, /):");
        String operation = scanner.next();
        
        double result;
        switch (operation) {
            case "+":
                result = calculator.add(a, b);
                break;
            case "-":
                result = calculator.subtract(a, b);
                break;
            case "*":
                result = calculator.multiply(a, b);
                break;
            case "/":
                result = calculator.divide(a, b);
                break;
            default:
                throw new IllegalArgumentException("Invalid operation, me hearty!");
        }
        
        System.out.println("The result be: " + result);
        scanner.close();
    }
}

With this code in place, our fellow pirates can now input two numbers and choose an operation to perform. The calculator will then display the result of the chosen operation.

Congratulations, me hearty! Ye’ve successfully built a calculator application that can perform basic arithmetic operations. With this trusty tool in yer arsenal, dividin’ up yer treasure amongst the crew will be smooth sailin’. But don’t drop anchor just yet! More adventures await as we explore other hands-on projects like creatin’ a simple game and developin’ a web application. So batten down the hatches and keep a weather eye on the horizon, for there be more Java learnin’ to be had!

Creating a Simple Game

Arr, mateys! Now that ye’ve built a calculator to divvy up yer loot, let’s set sail for more adventurous waters. In this next project, we’ll be creatin’ a simple number-guessing game that’ll keep yer crew entertained during those long voyages at sea. The goal of the game be to guess a secret number within a given range, with a limited number of attempts. So batten down the hatches, and let’s dive into the code!

Designing the Game Class

First, let’s create a NumberGuessingGame class that’ll generate a random secret number, and allow the player to guess the number. We’ll also keep track of the number of attempts the player has left:

import java.util.Random;

public class NumberGuessingGame {
    private int secretNumber;
    private int attemptsLeft;

    public NumberGuessingGame(int min, int max, int attempts) {
        Random random = new Random();
        secretNumber = random.nextInt(max - min + 1) + min;
        attemptsLeft = attempts;
    }

    public boolean hasAttemptsLeft() {
        return attemptsLeft > 0;
    }

    public void decrementAttempts() {
        attemptsLeft--;
    }

    public int getAttemptsLeft() {
        return attemptsLeft;
    }

    public boolean isCorrectGuess(int guess) {
        return guess == secretNumber;
    }
}

Now that we’ve got a seaworthy NumberGuessingGame class, let’s create a way for our fellow pirates to play the game.

Creating the Game Interface

To build a simple game interface, we’ll use Java’s Scanner class again to read input from the player. The game will prompt the player to guess a number, and then provide feedback on whether the guess be too high, too low, or correct. The game continues until the player guesses the secret number or runs out of attempts.

import java.util.Scanner;

public class NumberGuessingGameApp {
    public static void main(String[] args) {
        int min = 1;
        int max = 100;
        int attempts = 10;

        NumberGuessingGame game = new NumberGuessingGame(min, max, attempts);
        Scanner scanner = new Scanner(System.in);

        System.out.println("Ahoy! Welcome to the Number Guessing Game!");
        System.out.printf("Guess the secret number between %d and %d, me hearty!%n", min, max);

        while (game.hasAttemptsLeft()) {
            System.out.printf("You have %d attempts left. Enter your guess: ", game.getAttemptsLeft());
            int guess = scanner.nextInt();

            if (game.isCorrectGuess(guess)) {
                System.out.println("Shiver me timbers! Ye guessed the secret number! Congratulations!");
                break;
            } else if (guess < game.secretNumber) {
                System.out.println("Yarr, yer guess be too low!");
            } else {
                System.out.println("Arr, yer guess be too high!");
            }

            game.decrementAttempts();
        }

        if (!game.hasAttemptsLeft()) {
            System.out.printf("Alas, ye've run out of attempts! The secret number was %d.%n", game.secretNumber);
        }
        scanner.close();
    }
}

With this code, our fellow pirates can now play the number-guessing game, testin’ their luck and intuition to find the secret number before their attempts run out.

Well done, me hearty! Ye’ve successfully created a simple number-guessing game to keep yer crew entertained on those long sea voyages. But don’t drop anchor just yet! More adventures await as we delvedeeper into Java and explore the world of web development in the next project. So, hoist the Jolly Roger, and let’s keep sailin’ through these Java seas, mateys!

Developing a Web Application

Ahoy, me hearties! Let’s embark on our final adventure for this curriculum: creatin’ a web application! In this project, we’ll be usin’ the powerful Spring Boot framework to create a web service that returns pirate-themed jokes. By the end of this section, ye’ll have a fully-functioning web app that can keep yer fellow pirates laughin’ all the way to Treasure Island.

Setting Up the Project

To get started with Spring Boot, we’ll use the Spring Initializr to generate a project skeleton. Choose the following options:

  • Project: Maven Project
  • Language: Java
  • Packaging: Jar
  • Java Version: 11 or higher

For dependencies, select “Web” to include the Spring Web starter. Download the generated project, extract the archive, and import it into your favorite IDE.

Creating the PirateJokeController

Our web application will have a single endpoint that returns a pirate-themed joke. First, let’s create a PirateJokeController class:

package com.example.piratejokes;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class PirateJokeController {

    @GetMapping("/joke")
    public String getPirateJoke() {
        return "Why did the pirate go to school? To improve his 'arrrrrrrticulation!";
    }
}

In this class, we’ve created a simple REST endpoint that returns a joke when accessed via the /joke path.

Running the Application

To start the application, find the main method in the PirateJokesApplication class and run it:

package com.example.piratejokes;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class PirateJokesApplication {

    public static void main(String[] args) {
        SpringApplication.run(PirateJokesApplication.class, args);
    }
}

Once the application is running, navigate to http://localhost:8080/joke in your favorite web browser. Ye should see the pirate joke displayed on the page!

Concluding Remarks

Yarrr, me hearties! Ye’ve successfully completed a swashbucklin’ journey through the Java seas, learnin’ how to create a calculator application, a simple number-guessin’ game, and a pirate-themed web application. With these newfound skills, ye be well-equipped to tackle any challengin’ coding quest that lies ahead.

As ye continue to explore the vast ocean of Java, remember to keep yer sense of adventure and curiosity, and never hesitate to dive into uncharted waters. Fair winds and followin’ seas, me hearties!