Java Methods Capstone Projects: 4 Production-Grade Modular Systems
📌 Covered in this chapter:
Javadoc Documentation (@param, @return, @throws) · Clean Code & Single Responsibility · Project 1: Scientific Calculator · Project 2: Student Academic & GPA Suite · Project 3: Core Banking Operations · Project 4: Enterprise CommonUtils Library
Building 4 complete, production-grade modular software systems in Java: an industrial scientific calculator, a comprehensive student academic grading and GPA calculator, a secure banking transactions engine, and an enterprise utility library, while mastering industry Javadoc documentation and clean method architecture.
1. Professional Javadoc Method Documentation Standards
In enterprise software, methods are documented using Javadoc comments (/** ... */) to generate official API documentation:
/**
* Calculates compound interest for a given principal and rate.
*
* @param principal The initial deposited amount in USD (must be > 0).
* @param annualRate The annual interest rate percentage (e.g. 7.5 for 7.5%).
* @param years The investment duration in years.
* @return The final compounded balance after the specified duration.
* @throws IllegalArgumentException if principal <= 0 or years < 1.
*/
public static double calculateCompoundInterest(double principal, double annualRate, int years) {
if (principal <= 0 || years < 1) {
throw new IllegalArgumentException("Invalid principal or years");
}
return principal * Math.pow(1 + (annualRate / 100.0), years);
}2. Clean Code Principles for Java Methods
1. Single Responsibility Principle (SRP): A method should do one thing and do it exceptionally well. If a method calculates tax, saves to database, and sends an email, split it into 3 separate methods!
2. Small Method Size: Ideal production methods are between 5 to 20 lines long.
3. Descriptive Verb-Noun Naming: Use clear intentions: sendNotification(), validatePassword(), calculateNetPay().
4. Minimize Parameter Count: Strive for 0 to 3 parameters. If you need 7 parameters, group them into a dedicated configuration object.
Beginner Example & Code Anatomy
☕ Main.java — Chapter 37 Core Example
import java.util.Arrays;
public class Main {
// -------------------------------------------------------------
// PROJECT 1: Modular Scientific Calculator Engine
// -------------------------------------------------------------
public static class Calculator {
public static double add(double a, double b) { return a + b; }
public static double subtract(double a, double b) { return a - b; }
public static double multiply(double a, double b) { return a * b; }
public static double divide(double a, double b) {
if (b == 0) {
System.out.println(" [ERROR] Cannot divide by zero!");
return Double.NaN;
}
return a / b;
}
public static double power(double base, double exp) { return Math.pow(base, exp); }
public static double modulus(double a, double b) { return a % b; }
}
// -------------------------------------------------------------
// PROJECT 2: Student Academic & GPA Suite
// -------------------------------------------------------------
public static class StudentGrader {
public static int calculateTotal(int[] marks) {
int total = 0;
for (int m : marks) total += m;
return total;
}
public static double calculatePercentage(int[] marks, int maxPerSubject) {
int total = calculateTotal(marks);
int maxTotal = marks.length * maxPerSubject;
return ((double) total / maxTotal) * 100.0;
}
public static char determineLetterGrade(double percentage) {
if (percentage >= 90) return 'A';
if (percentage >= 80) return 'B';
if (percentage >= 70) return 'C';
if (percentage >= 60) return 'D';
return 'F';
}
public static double calculateGPA(double percentage) {
return Math.min(4.0, (percentage / 100.0) * 4.0);
}
}
// -------------------------------------------------------------
// PROJECT 3: Core Banking Operations Engine
// -------------------------------------------------------------
public static class BankService {
public static double deposit(double currentBalance, double amount) {
if (amount <= 0) {
System.out.println(" [BANK ERROR] Invalid deposit amount: $" + amount);
return currentBalance;
}
return currentBalance + amount;
}
public static double withdraw(double currentBalance, double amount) {
if (amount <= 0 || amount > currentBalance) {
System.out.println(" [BANK ERROR] Withdrawal denied! Insufficient funds or invalid amount.");
return currentBalance;
}
return currentBalance - amount;
}
public static boolean transferFunds(double[] senderBalance, double[] receiverBalance, double amount) {
if (amount <= 0 || senderBalance[0] < amount) {
return false; // Transfer rejected
}
senderBalance[0] -= amount;
receiverBalance[0] += amount;
return true;
}
}
// -------------------------------------------------------------
// PROJECT 4: Enterprise CommonUtils Library
// -------------------------------------------------------------
public static class CommonUtils {
public static boolean isValidEmail(String email) {
if (email == null || email.isBlank()) return false;
return email.matches("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$");
}
public static String maskCreditCard(String cardNum) {
if (cardNum == null || cardNum.length() < 4) return "****";
String clean = cardNum.replaceAll("[^0-9]", "");
return "****-****-****-" + clean.substring(clean.length() - 4);
}
public static String formatCurrency(double amount) {
return String.format("$%,.2f", amount);
}
}
public static void main(String[] args) {
System.out.println("=== PROJECT 1: Calculator Engine ===");
System.out.println(" 10.5 + 4.5 = " + Calculator.add(10.5, 4.5));
System.out.println(" 15.0 / 3.0 = " + Calculator.divide(15.0, 3.0));
System.out.println(" 2.0 ^ 10.0 = " + Calculator.power(2.0, 10.0));
Calculator.divide(10.0, 0); // Tests error guard
System.out.println("
=== PROJECT 2: Student Academic & GPA Suite ===");
int[] studentMarks = {88, 92, 79, 95, 84};
int totalMarks = StudentGrader.calculateTotal(studentMarks);
double percentage = StudentGrader.calculatePercentage(studentMarks, 100);
char grade = StudentGrader.determineLetterGrade(percentage);
double gpa = StudentGrader.calculateGPA(percentage);
System.out.println(" Total Marks : " + totalMarks + "/500");
System.out.printf(" Percentage : %.2f%%%n", percentage);
System.out.println(" Grade : " + grade);
System.out.printf(" GPA (4.0) : %.2f%n", gpa);
System.out.println("
=== PROJECT 3: Core Banking Operations ===");
double myAccount = 1000.0;
myAccount = BankService.deposit(myAccount, 500.0);
myAccount = BankService.withdraw(myAccount, 200.0);
System.out.println(" Final My Account Balance: " + CommonUtils.formatCurrency(myAccount));
double[] alice = {1200.0};
double[] bob = {300.0};
boolean txStatus = BankService.transferFunds(alice, bob, 400.0);
System.out.println(" Transfer $400 from Alice to Bob : Success=" + txStatus);
System.out.println(" Alice New Balance : " + CommonUtils.formatCurrency(alice[0]));
System.out.println(" Bob New Balance : " + CommonUtils.formatCurrency(bob[0]));
System.out.println("
=== PROJECT 4: Enterprise CommonUtils ===");
System.out.println(" Email 'dev@google.com' Valid : " + CommonUtils.isValidEmail("dev@google.com"));
System.out.println(" Email 'invalid-email' Valid : " + CommonUtils.isValidEmail("invalid-email"));
System.out.println(" Masked CC Number : " + CommonUtils.maskCreditCard("4111-2222-3333-8945"));
System.out.println(" Formatted Large Currency : " + CommonUtils.formatCurrency(1250450.75));
}
}💻 Program Console Output
=== PROJECT 1: Calculator Engine ===
10.5 + 4.5 = 15.0
15.0 / 3.0 = 5.0
2.0 ^ 10.0 = 1024.0
[ERROR] Cannot divide by zero!
=== PROJECT 2: Student Academic & GPA Suite ===
Total Marks : 438/500
Percentage : 87.60%
Grade : B
GPA (4.0) : 3.50
=== PROJECT 3: Core Banking Operations ===
Final My Account Balance: $1,300.00
Transfer $400 from Alice to Bob : Success=true
Alice New Balance : $800.00
Bob New Balance : $700.00
=== PROJECT 4: Enterprise CommonUtils ===
Email 'dev@google.com' Valid : true
Email 'invalid-email' Valid : false
Masked CC Number : ****-****-****-8945
Formatted Large Currency : $1,250,450.75
🔍 Line-by-Line Code Explanation
Calculator.divide(15.0, 3.0);
Calls static division utility with zero-division validation guard.
StudentGrader.calculatePercentage(...)
Composes calculateTotal() to compute percentage and subsequent GPA mapping.
BankService.transferFunds(alice, bob, 400.0);
Demonstrates multi-party atomic transaction using array reference containers.
CommonUtils.maskCreditCard("4111-2222-3333-8945");
Strips non-digit characters and masks leading digits for security compliance.
Practical Real-World Example
☕ PracticalApplication.java — Industry Implementation
public class PracticalApplication {
public static void main(String[] args) {
// Industry Simulation: Payroll Disburser Service
String[] employees = {"Ravi Teja", "Priya Sharma", "Kiran Kumar"};
double[] baseSalaries = {4500.0, 6200.0, 3800.0};
double bonusRate = 0.15; // 15% bonus
System.out.println("=== Corporate Payroll Processing Engine ===");
for (int i = 0; i < employees.length; i++) {
double bonus = baseSalaries[i] * bonusRate;
double gross = baseSalaries[i] + bonus;
double tax = gross * 0.10; // 10% tax
double net = gross - tax;
System.out.printf("Employee: %-14s | Gross: %s | Net: %s%n",
employees[i],
Main.CommonUtils.formatCurrency(gross),
Main.CommonUtils.formatCurrency(net));
}
}
}💻 Practical Console Output
=== Corporate Payroll Processing Engine ===
Employee: Ravi Teja | Gross: $5,175.00 | Net: $4,657.50
Employee: Priya Sharma | Gross: $7,130.00 | Net: $6,417.00
Employee: Kiran Kumar | Gross: $4,370.00 | Net: $3,933.00
⚠️ Common Mistakes & Professional Best Practices
- Writing massive 200-line methods that mix business calculations, file I/O, and UI formatting.
- Ignoring division by zero edge cases in math utility methods.
- Failing to validate null or empty string parameters in public utility methods.
- Using vague method names like
doWork()orprocess()instead of descriptive verbs likecalculateNetPay().
🎯 Hands-on Coding Challenge
Test your understanding by writing the code directly in your editor or running in our online Java compiler:
☕ Challenge.java
// Coding Challenge:
// Add a method calculateMedian(double[] values) to CommonUtils:
// 1. Clones and sorts the array.
// 2. If length is odd, returns the middle element.
// 3. If length is even, returns the average of the two middle elements.
public class Challenge {
public static double calculateMedian(double[] values) {
if (values == null || values.length == 0) return 0.0;
double[] sorted = values.clone();
java.util.Arrays.sort(sorted);
int n = sorted.length;
if (n % 2 != 0) {
return sorted[n / 2];
}
return (sorted[(n / 2) - 1] + sorted[n / 2]) / 2.0;
}
public static void main(String[] args) {
System.out.println("Median (Odd) : " + calculateMedian(new double[]{5, 1, 9, 3, 7})); // 5.0
System.out.println("Median (Even): " + calculateMedian(new double[]{1, 2, 3, 4})); // 2.5
}
}💡 Frequently Asked Questions & Interview Insights
❓ What is a Pure Function in Java?
A pure function is a method that given the same inputs always returns the same output without causing observable side effects (like modifying static variables, changing database records, or printing to console).
❓ How does Javadoc generate HTML documentation?
The JDK includes a `javadoc` command line tool (`javadoc -d docs src/*.java`) that parses `/** ... */` comments and builds responsive HTML documentation web pages.
❓ Why should utility classes contain only static methods and private constructors?
Because utility classes (like `java.lang.Math` or `CommonUtils`) serve as stateless collections of helper methods. Adding a private constructor prevents accidental instantiation with `new CommonUtils()`.
🚀 Quick Chapter Recap
- Javadoc comments (
/** @param @return @throws */) provide industry standard API documentation. - Follow the Single Responsibility Principle: each method should accomplish one focused task.
- Modular systems compose small helper methods to build robust, testable software.
- Sanitize and validate all input arguments at method boundaries to prevent system crashes.
- Stateless utility libraries should encapsulate static methods with defensive edge-case guards.