DEV Community: Muha-mmed

Building a Simple Bank App API with Spring Boot and Spring Data JPA

Muha-mmed — Fri, 19 Sep 2025 12:12:39 +0000

When learning backend development, one of the best ways to practice is by building something practical and relatable. For me, that turned out to be a Bank App API — a Spring Boot project where users can create accounts, deposit and withdraw money, check balances, and even close accounts.

This project gave me hands-on experience with Spring Boot, Spring Data JPA, and REST API design, while also teaching me how to think about real-world requirements like account numbers and user authentication.

🛠 Tech Stack

Spring Boot – for building the REST API.

Spring Data JPA – for interacting with the database.

Maven – build and dependency management.

Database – works with relational databases like MySQL (but could also run on H2 for testing).

📌 Features Implemented

The application exposes endpoints under /account. Here’s what you can do:

Create an account
POST /account – Add a new account to the system.

Get account by account number
GET /account/{accountNumber} – Fetch details for a specific account.

Get all accounts
GET /account – Retrieve all stored accounts.

Deposit money
PUT /account/deposit/{accountNumber}/{amount} – Increase the account balance.

Withdraw money
PUT /account/withdraw/{accountNumber}/{amount} – Deduct from the account balance.

Close an account
DELETE /account/delete/{id} – Remove an account from the system.

Here’s a snippet from the controller:

public class AccountController {

    @Autowired
    AccountService service;


    @PostMapping
    public ResponseEntity<Account> createAccount(@RequestBody Account account){
        Account createAccount =service.createAccount(account);
        return ResponseEntity.status(HttpStatus.CREATED).body(createAccount);
    }

    @GetMapping("/{accountNumber}")
    public Account getAccountDetailsByAccountNumber(@PathVariable Long accountNumber) {
        Account getAccountDetail = service.getAccountDetailsByAccountNumber(accountNumber);
        return getAccountDetail;
    }

    @GetMapping
    public List<Account> getAllAccountDetails() {
        List<Account> getAccountDetail = service.getAllAccountDetails();
        return getAccountDetail;
    }

    @PutMapping("/deposit/{accountNumber}/{amount}")
    public Account depositAmount(@PathVariable Long accountNumber,@PathVariable Double amount){
        Account account = service.depositAmount(accountNumber,amount);
        return account;
    }

    @PutMapping("/withdraw/{accountNumber}/{amount}")
    public Account withdrawAmount(@PathVariable Long accountNumber,@PathVariable Double amount){
        Account account = service.withdrawAmount(accountNumber,amount);
        return account;
    }

    @DeleteMapping("/delete/{accountNumber}")
    public ResponseEntity<String> closeAccount(@PathVariable Long accountNumber){
        return ResponseEntity.status(HttpStatus.NO_CONTENT).body(service.closeAccount(accountNumber));
    }
}

⚡ Challenges & Learning

Building this project gave me valuable practice with:

Structuring a Spring Boot project with controllers, services, and repositories.
Working with Spring Data JPA to simplify database operations.
Designing clean and RESTful API endpoints.
Testing endpoints using Postman.

I also realized how important it is to think ahead about real-world requirements. For example, account numbers should be standardized (e.g., 10-digit numbers) and authentication is needed to secure operations like deposit and withdrawal.

🔮 Future Improvements

This project is still growing, and here’s what I plan to add next:

Unique 10-digit account numbers (instead of relying on auto-generated IDs).
Login and Signup functionality, powered by Spring Security.
Improved error handling and validation (e.g., prevent overdrawing).

Transaction history and account statements.

🎯 Conclusion

The Bank App project may be simple, but it demonstrates core backend concepts:

Building REST APIs with Spring Boot.
Using JPA for database operations.
Structuring an application into layered components.

It’s a solid step in my Spring Boot journey, and I plan to keep improving it as I learn more about authentication, security, and production deployment.

🔗 Check it out on GitHub: Bank-App-Spring-Boot

How I Structure My FastAPI Projects for Clean, Scalable Code

Muha-mmed — Fri, 04 Jul 2025 22:30:19 +0000

When I started working with FastAPI, I quickly realized one thing:
Project structure matters.

A messy project becomes hard to scale, hard to maintain, and hard to debug — especially when you’re working on real-world APIs or collaborating with a team.

Over time, I settled on a project structure that keeps things organized, clear, and ready to grow. In this post, I’ll walk you through the structure I use and why it works for me.

⸻

🗂 FastAPI Project Structure Example

Here’s what my folder structure looks like for a typical FastAPI project:

app/

├── admin/ → Admin operations (separate logic for admins)

├── models/ → SQLAlchemy database models

├── schemas/ → Pydantic request & response schemas

├── crud/ → Database operations (clean, reusable functions)

├── routes/ → API endpoints, cleanly separated by feature

├── core/ → Auth logic, password hashing, reusable dependencies

├── database.py → Database connection & session setup

├── config.py → App settings & environment variables

alembic/ → Database migrations (optional, recommended)

env/ → Virtual environment folder (optional)

.env → Secrets like DB URI, JWT keys

requirements.txt → Project dependencies

💡 Why I Like This Structure

✔️ Separation of Concerns — Each folder has a clear responsibility
✔️ Easy to Scale — As features grow, everything stays organized
✔️ Cleaner Routes — No messy logic inside route files
✔️ Team Friendly — Easy for new devs to onboard and understand
✔️ Good with Extensions — Works well with JWT auth, Alembic, etc.

📦 Quick Notes on Key Folders
• models/ — Pure database models using SQLAlchemy
• schemas/ — Pydantic schemas for validation and serialization
• crud/ — Handles database queries so routes stay clean
• routes/ — Your API endpoints organized by feature (e.g., auth.py, coffee.py)
• core/ — Authentication logic, password hashing, reusable dependencies like get_current_user
• admin/ — Optional, useful for admin-specific operations

✅ Conclusion

A clean project structure won’t solve all your problems — but it definitely saves you time and headaches down the road.

This structure works for me on both small and growing FastAPI projects, and I’m always open to improving it.

How do you structure your FastAPI apps?
I’d love to hear your suggestions, ideas, or different approaches in the comments! 🙌

fastapi #python #webdev #backend #projectstructure #softwarearchitecture

Create a Python GPT chatbot

Muha-mmed — Wed, 28 May 2025 08:05:53 +0000

Let’s create a simple Python script that uses GPT AI to give the user a response based on their input.

Step 1: Install the Required Package

First, make sure you have Python installed on your computer.

Then, run this command in your terminal:

pip install openai

Step 2: Get an API Key

Visit the OpenAI website, create an account, and request an API key.

Step 3: Write the Script

Now, let’s move on to writing the script.

import openai

openai.api_key = "your_api_key"

def chat_gpt(user_input):
    try:
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": user_input}]
        )
        return response.choices[0].message.content.strip()
    except Exception as e:
        return f"An error occurred: {str(e)}"

if __name__ == "__main__":
    while True:
        user_input = input("You: ")
        if user_input.lower() in ["quit", "exit", "bye"]:
            break
        response = chat_gpt(user_input)
        print("Chatbot:", response)

Step 4: Run the Script

Save the file as main.py, then run it with:

python main.py

Explaining the Code
• The chat_gpt() function allows the user to input a question. It sends the message to the GPT model and returns a response or an error message.
• The name == "main" block makes the script run in a loop. If the user types “bye”, “exit”, or “quit”, the program will stop. Otherwise, it sends the user’s input to GPT and prints the response.

How I Built an Anonymous Board API with FastAPI and SQLite

Muha-mmed — Tue, 08 Apr 2025 14:51:20 +0000

Introduction
As a fun privacy experiment and to help my fellow learners, I decided to create an anonymous board where users can post messages without any login or sign-up requirements. This simple API allows anyone to create and read posts via unique links—perfect for beginners who want to get hands-on with FastAPI and SQLite. source code here

In this article, I'll walk you through how I built the API, the tools I used, and the lessons I learned along the way.

Tools and Libraries Used
For this project, I used the following technologies:

FastAPI: A modern web framework for building APIs quickly and efficiently.

SQLAlchemy: An ORM (Object-Relational Mapping) library to interact with the SQLite database.

Pydantic: For validating and parsing data in Python.

Uvicorn: A fast ASGI server to run the FastAPI app.

SQLite: A lightweight database for storing posts.

python-dotenv: For handling environment variables like database URLs and other configurations.

Features
Here’s what the current version of the API allows you to do:

Create anonymous posts: Anyone can post a message.

Unique link generation: Each post has a unique link for retrieval.

Retrieve posts: You can fetch the content of a post using its unique link.

No login required: The board is fully anonymous, so no need for user accounts or authentication.

How It Works

Creating a Post: The POST /post endpoint allows you to submit content for a post. Once created, the API will return a unique link that you can use to view your post later.

Example request:

{
  "content": "This is an anonymous message!"
}

Example response:

{
  "content": "This is an anonymous message!",
  "link": "127.0.0.1:8000/read/anonymous-dd3c"
}

Reading a Post: The GET /read/{link} endpoint allows you to fetch the content of a post using the unique link provided during creation.

Example URL:

127.0.0.1:8000/read/anonymous-dd3c

Example response:

{
  "content": "This is an anonymous message!"
}

Setting Up the Project

If you want to follow along and set up this project yourself, here’s how to do it:

Install Dependencies: You can install the necessary libraries by running the following command:

pip install fastapi sqlalchemy uvicorn python-dotenv

Run the Application: Start the FastAPI app with Uvicorn:

uvicorn main:app --reload

🧑‍💻 Future Plans
While the API is functional for now, I plan to add a frontend using HTML, Materialize CSS, and JS. The frontend will allow users to post and view anonymous messages more easily. I also plan to introduce an anonymous comment section where other users can share their thoughts, still without requiring any login.

💬 Feedback and Contributions
I’d love to hear any feedback or suggestions for improvement. This project is still in the early stages, and I’m always open to contributions. If you have any ideas, feel free to open an issue or submit a pull request! project github here

Fastapi over Django for app developers

Muha-mmed — Fri, 14 Mar 2025 00:30:06 +0000

Hi👋, as an app developer looking to build your own backend with python, FastAPI is an excellent choice, especially if you prioritize speed, simplicity, and modern features. While Django is a powerful and mature framework, FastAPI has several advantages that make it a better fit for developers who want to quickly build efficient and scalable backends. Here's why FastAPI might be the right choice for you:

Why FastAPI is a Great Choice for App Developers

Performance:
- FastAPI is built on ASGI (Asynchronous Server Gateway Interface), which makes it much faster than Django (which uses WSGI).
- It’s one of the fastest Python web frameworks, comparable to Node.js and Go.
Asynchronous Support:
- FastAPI natively supports async/await, making it ideal for handling high-concurrency tasks (e.g., real-time apps, APIs with multiple requests).
- Django has added async support, but it’s not as seamless or performant as FastAPI.
Ease of Use:
- FastAPI is designed to be simple and intuitive. It uses Python type hints, which make your code cleaner and easier to understand.
- Automatic validation, serialization, and documentation (via Swagger UI and ReDoc) save you a lot of time.
Modern Features:
- FastAPI is built with modern web development in mind. It supports:
  - OpenAPI and JSON Schema for automatic API documentation.
  - WebSockets for real-time communication.
  - GraphQL (with third-party libraries).
Lightweight and Flexible:
- FastAPI is minimalistic and doesn’t come with the "batteries-included" approach of Django. This gives you more flexibility to choose the tools and libraries you need.
Great for APIs:
- If your app’s backend is primarily an API (e.g., for a mobile app or SPA), FastAPI is a perfect fit. It’s designed specifically for building APIs quickly and efficiently.

When to Choose Django Instead

While FastAPI is great, Django might be a better choice in certain scenarios:

Full-Stack Web Applications:
- If you’re building a traditional web app with server-side rendering, Django’s built-in templating engine and admin panel can save you time.
Batteries-Included Framework:
- Django comes with everything you need out of the box (ORM, authentication, admin panel, etc.), which can be helpful if you don’t want to configure third-party libraries.
Large Ecosystem:
- Django has been around for much longer and has a larger community and ecosystem of plugins.

Key Differences Between FastAPI and Django

Feature	FastAPI	Django
Performance	Very fast (ASGI-based)	Slower (WSGI-based)
Async Support	Native and seamless	Limited and less performant
Ease of Use	Simple and intuitive	Steeper learning curve
Flexibility	Lightweight and modular	Batteries-included
Use Case	APIs, microservices, real-time	Full-stack web apps

How to Get Started with FastAPI

If you decide to go with FastAPI, here’s a roadmap to get started:

1. Learn the Basics

Install FastAPI: pip install fastapi
Install an ASGI server: pip install uvicorn

Create a simple "Hello World" API:

 from fastapi import FastAPI

 app = FastAPI()

 @app.get("/")
 def read_root():
     return {"message": "Hello, World!"}

Run the server: uvicorn main:app --reload

2. Learn Key Features

Path Parameters and Query Parameters:

 @app.get("/items/{item_id}")
 def read_item(item_id: int, q: str = None):
     return {"item_id": item_id, "q": q}

Request Body (using Pydantic models):

 from pydantic import BaseModel

 class Item(BaseModel):
     name: str
     price: float

 @app.post("/items/")
 def create_item(item: Item):
     return item

Error Handling:

 from fastapi import HTTPException

 @app.get("/items/{item_id}")
 def read_item(item_id: int):
     if item_id == 0:
         raise HTTPException(status_code=404, detail="Item not found")
     return {"item_id": item_id}

3. Integrate a Database

Use an ORM like SQLAlchemy or Tortoise ORM.

Example with SQLAlchemy:

 from sqlalchemy import create_engine, Column, Integer, String
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker

 SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"
 engine = create_engine(SQLALCHEMY_DATABASE_URL)
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 Base = declarative_base()

 class Item(Base):
     __tablename__ = "items"
     id = Column(Integer, primary_key=True, index=True)
     name = Column(String, index=True)
     price = Column(Integer)

 Base.metadata.create_all(bind=engine)

4. Add Authentication

Use OAuth2 with JWT tokens for secure authentication.

Example:

 from fastapi.security import OAuth2PasswordBearer

 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

 @app.get("/users/me")
 def read_current_user(token: str = Depends(oauth2_scheme)):
     return {"token": token}

5. Deploy Your Backend

Use platforms like Heroku, Render, or AWS to deploy your FastAPI app.

Best of luck 🤞. What do you think about this?

Building a Production-Ready To-Do API with FastAPI

Muha-mmed — Tue, 04 Mar 2025 22:19:01 +0000

Hey fellow Python devs! 👋

In this guide, we’ll build a To-Do API using FastAPI with production-ready features. If you're looking to sharpen your backend development skills or add a solid project to your portfolio, this tutorial is for you!

You'll learn how to:

✅ Set up a PostgreSQL database

✅ Define models with SQLAlchemy

✅ Validate data using Pydantic

✅ Implement CRUD operations with FastAPI

Let’s get started! 🚀

Project Setup

Step 1: Install Dependencies

Before we start coding, install the required dependencies:

pip install fastapi psycopg2 pydantic SQLAlchemy uvicorn python-dotenv

Step 2: Project Structure

Your project should be structured like this:

📂 todo_api_project
 ┣ 📜 main.py        # Entry point of the application
 ┣ 📜 database.py    # Database configuration
 ┣ 📜 model.py       # Database models
 ┣ 📜 schema.py      # Pydantic schemas
 ┣ 📜 route.py       # API routes
 ┗ 📜 requirements.txt # Dependencies

Step 3: Setting Up the Database

We’ll use PostgreSQL as our database. Create a file called database.py and add the following code:

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "postgresql://yourusername:yourpassword@localhost/todo_db"

engine = create_engine(DATABASE_URL)

sessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

BASE = declarative_base()

def get_db():
    db = sessionLocal()
    try:
        yield db
    finally:
        db.close()

Explanation

We use create_engine to connect to the PostgreSQL database.
sessionLocal manages database sessions.
BASE = declarative_base() allows us to define database models.
The get_db function provides a database session when needed.

Step 4: Creating the To-Do Model

In model.py, define the structure of your To-Do items using SQLAlchemy:

from sqlalchemy import Column, Integer, String, Boolean, TIMESTAMP, text
from database import BASE

class Todo(BASE):
    __tablename__ = "todos"

    id = Column(Integer, primary_key=True, index=True)
    title = Column(String, nullable=False)
    description = Column(String, nullable=True)
    published = Column(Boolean, server_default=text("False"))
    created_at = Column(TIMESTAMP(timezone=True), server_default=text("now()"))

Explanation

id: Auto-generated primary key.
title: Required (nullable=False).
description: Optional field (nullable=True).
published: Boolean field with a default value of False.
created_at: Stores the creation timestamp.

Step 5: Creating Pydantic Schemas

In schema.py, define how Pydantic will validate incoming request data:

from typing import Optional
from pydantic import BaseModel

class Todo(BaseModel):
    title: str
    description: Optional[str] = None
    published: bool = False

    class Config:
        orm_mode = True

class UpdateTodo(BaseModel):
    title: Optional[str] = None
    description: Optional[str] = None
    published: Optional[bool] = None

Explanation

Todo: Used for creating new tasks.
UpdateTodo: Used for updating tasks.
orm_mode = True: Ensures compatibility with SQLAlchemy models.

Step 6: Creating API Routes

Now, let’s create the API endpoints in route.py:

from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session
from database import get_db, engine
from schema import Todo, UpdateTodo
import model
from typing import List

# Create tables
model.BASE.metadata.create_all(bind=engine)

route = APIRouter()

1️⃣ Get All To-Dos

@route.get("/getalltodos")
def get_all_todo(db: Session = Depends(get_db)):
    todos = db.query(model.Todo).all()
    return todos if todos else []

✅ Fetches all tasks from the database.

2️⃣ Create a New To-Do

@route.post("/todo/create")
def create_todo(todo: Todo, db: Session = Depends(get_db)):
    todo_item = model.Todo(**todo.model_dump())
    db.add(todo_item)
    db.commit()
    db.refresh(todo_item)
    return todo_item

✅ Takes JSON input and adds a new task to the database.

3️⃣ Update a To-Do

@route.put("/todo/update/{post_id}", response_model=UpdateTodo)
def update_todo(new_post: UpdateTodo, post_id: int, db: Session = Depends(get_db)):
    todo = db.query(model.Todo).filter(model.Todo.id == post_id).first()
    if not todo:
        return {"error": "To-do not found"}

    update_data = new_post.model_dump(exclude_unset=True)

    for key, value in update_data.items():
        setattr(todo, key, value)

    db.commit()
    db.refresh(todo)
    return todo

✅ Updates an existing task based on post_id.

4️⃣ Get Published To-Dos

@route.get("/published_todo")
def get_published_todos(db: Session = Depends(get_db)):
    return db.query(model.Todo).filter(model.Todo.published == True).all()

✅ Fetches only published to-do items.

5️⃣ Get Draft To-Dos

@route.get("/draft_todo")
def get_draft_post(db: Session = Depends(get_db)):
    return db.query(model.Todo).filter(model.Todo.published == False).all()

✅ Fetches only unpublished (draft) tasks.

6️⃣ Get a To-Do by ID

@route.get("/getbyid/{todo_id}")
def get_by_id(todo_id: int, db: Session = Depends(get_db)):
    return db.query(model.Todo).filter(model.Todo.id == todo_id).first()

✅ Fetches a specific task by its id.

7️⃣ Search To-Dos

@route.get("/search", response_model=List[Todo])
def search_todo(name: str = Query(None), db: Session = Depends(get_db)):
    query = db.query(model.Todo)

    if name:
        query = query.filter(model.Todo.title.like(f"%{name}%") | model.Todo.description.like(f"%{name}%"))
        todos = query.all()
        return todos if todos else {"error": "No post found"}

    return []

✅ Searches tasks by title or description.

8️⃣ Delete a To-Do

@route.delete("/delete/{todo_id}")
def delete_post(todo_id: int, db: Session = Depends(get_db)):
    todo = db.query(model.Todo).filter(model.Todo.id == todo_id).first()
    db.delete(todo)
    db.commit()

✅ Deletes a task from the database.

Step 7: Running the API

Create main.py to start the server:

from fastapi import FastAPI
from route import route  

app = FastAPI()

@app.get("/")
def root():
    return {"hello": "world!!!"}

app.include_router(route)

Run the server:

uvicorn main:app --reload

Visit http://127.0.0.1:8000/docs to test the API! 🎉

Conclusion

You've built a To-Do API with FastAPI, PostgreSQL, and SQLAlchemy! This is a great project to showcase in your portfolio. Keep exploring and refining your skills! 🚀

Full code on my GitHub here

What do you think? Does this structure work for your blog? 😊

Building a Simple Rock, Paper, Scissors Game in Go

Muha-mmed — Mon, 03 Feb 2025 15:06:48 +0000

Rock, Paper, Scissors is a classic game that has been played for generations. In this blog, we will walk through how to build a simple command-line version of the game in Go.

Prerequisites

Before we dive into the code, ensure you have the Go programming language installed on your system. You can download it from Go's official website.

Understanding the Code

Let's break down the code and understand its structure.

Importing Necessary Packages

import (
    "fmt"
    "math/rand"
)

Here, we import the fmt package for handling input and output operations and math/rand to generate random choices for the computer.

Defining Variables

playerScore := 0
computerScore := 0
option := []string{"rock", "paper", "scissors"}
var playerChoice string

playerScore and computerScore are initialized to keep track of the game scores.
option is a slice containing the three possible choices: rock, paper, and scissors.
playerChoice is a variable that stores the player's choice.

Running the Game Loop

for {
    computerChoice := option[rand.Intn(len(option))]

This loop runs indefinitely, allowing players to continue playing until they manually stop the program.

rand.Intn(len(option)) generates a random index to select the computer’s choice.

Taking Player Input

fmt.Print("choose an option, rock, paper and scissors: ")
fmt.Scan(&playerChoice)
fmt.Printf("Computer Choice:  %v \n", computerChoice)
fmt.Printf("player Choice:  %v  \n", playerChoice)

fmt.Print() prompts the player to enter a choice.
fmt.Scan(&playerChoice) captures the user's input.
The selected choices for both the player and the computer are displayed.

Determining the Winner

if playerChoice == computerChoice {
    fmt.Println("no winner(tie)")
    fmt.Printf("game score Player %v, computer %v \n", playerScore, computerScore)

If both choices are the same, it results in a tie, and scores remain unchanged.

Player Wins Condition

} else if playerChoice == "rock" && computerChoice == "scissors" ||
          playerChoice == "paper" && computerChoice == "rock" ||
          playerChoice == "scissors" && computerChoice == "paper" {
    fmt.Println("player wins")
    playerScore++

The player wins if:

Rock beats scissors
Paper beats rock
Scissors beat paper

The player’s score is incremented accordingly.

Computer Wins Condition

} else {
    fmt.Println("computer Wins")
    computerScore++
    fmt.Printf("game score Player %v, computer %v \n", playerScore, computerScore)
}

If none of the conditions above are met, the computer wins, and its score increases.

Running the Game

Save the code in a file, say main.go, and run it using:

go run main.go

You can play multiple rounds until you choose to stop the game manually (Ctrl + C).

Fixing an Error in the Code

There's a small typo in the condition checking for the player's win. The condition:

playerChoice == "scissor" && computerChoice == "paper"

should be corrected to:

playerChoice == "scissors" && computerChoice == "paper"

Since "scissors" is the correct string defined in the option slice, fixing this ensures the program works correctly.

Conclusion

This simple Rock, Paper, Scissors game demonstrates basic Go programming concepts such as loops, conditionals, and user input handling. You can enhance the game by adding features like a limit on rounds, an option to exit, or even integrating a graphical interface.

the full code also on my github here

Try modifying the code and share your improvements! 🚀

Fastapi

Muha-mmed — Tue, 24 Dec 2024 20:52:56 +0000

Rock Paper Scissors Game - Flutter

Muha-mmed — Sun, 17 Nov 2024 00:48:12 +0000

In this article, I'll show you how I built a simple Rock Paper Scissors game using Flutter. The app allows you to play the classic game against the computer. You can check out the full code on GitHub here.

How the Game Works

The game has a simple structure:

The player selects either Rock, Paper, or Scissors.
The computer makes a random choice.
A comparison is made to determine the winner:
- Rock beats Scissors
- Scissors beats Paper
- Paper beats Rock

The game shows the results and updates the score.

Code Walkthrough

Here's the function that generates the computer's choice:

String getComputerChoice() {
    List<String> choices = ['Rock', 'Paper', 'Scissors'];
    return choices[Random().nextInt(3)];
}