Interest/Discount rate and loan calculator java

First of all, I'm coming from a C / C++ / C# and Haskell background and am not too familiar with Java.

However, the main focus of this review are general programming techniques that will help you write robust code that's easily understandable by your peers.

Mutable Global Variables

Making a field public static means that code outside your class can access it, so it essentially becomes a global variable. Global variables should never be mutable - use final to prevent code outside of your class from modifying them.

Howerver, since you only seem to be using these from inside your main method, why not make them local variables in there?

---

Separate computations from output

Also, comparing your main method and your getInfo - the latter is much easier to read because you don't intermingle your computations with those printf statements.

In your main method, I would do those 4 computations first - possibly storing their result in some structure / class - then insert a blank line and then your print statements. You already used descriptive variable names, which is great, and separating the computations from the output will not only make this more readable, but also help you in case you later want to refactor it to return results without printing them.

/Edit: when I first commented, I didn't realize that scanner.nextDouble() was a Java utility function that reads from standard input.

I would move that code into a separate method and insert some blank lines to make it a bit more readable.

 Scanner scanner = new Scanner(System.in); System.out.println("Provide the data for calculations:"); System.out.println("What is the starting capital: "); capital = scanner.nextDouble(); System.out.println("What is the rate of interest in %: "); interest = scanner.nextDouble(); System.out.println("What is the inflation rate in %: "); inflation = scanner.nextDouble(); System.out.println("How long is the duration in years: "); duration = scanner.nextDouble(); 

Put the above into a separate method and return these 4 values in a custom data type.

This will make your code much more composable because you can then easily swap out the interactive console input with something else - for instance when writing tests.

---

In your Calculator class, it is generally a good idea to sepatate inputs from data. What I mean by that is that any variables that are only assigned by your class constructor should be marked final - to make it clear that it is an input to your class and not something that your class computed.

Even just separating them with a blank line and marking the inputs final already makes it a bit easier to read:

public class Calculator { // Inputs final double capital; final double interest; final double duration; final double inflation; // Computed double sumOfPayments=0; double newValue=0; double newCashValue=0; 

---

Surprising Side-Effects

To make it easy for others to read and understand your code, never use two variables with the exact same same, but completely different meaning in different lexical scopes.

A computer program will understand that interest and this.interest are two distinct variables - but a human who has seen your outer definition may not realize that you're re-defining it it mean something completely different in an inner lexical scope.

This is also something that will really hurt you later on - imagine for instance that at some point, you need to add additional methods to your classes and also want to collaborate with other people on this. Well, it should be possible for somebody to just look at your class definition and one of it's methods to understand what that method does. For this to work, your other methods must not have any surprising side-effects - such as modifying class fields that look like read-only inputs.

---

Avoid copying class fiels into local variables:

void capitalIncrease() { double capital=this.capital; double inflation=this.inflation; double duration=this.duration; 

There is no need for doing so - it only leads to the following anti-pattern:

 capital=capital*((100+inflation)/100); 

As I explained above, this is a surprising side-effect as it is not immediately obvious to a reader, that capital no longer refers to the class field.

---

It is even worse in the creditPayments method, because first you have these assignments:

void creditPayments() { double capital=this.capital; double interest=this.interest/12; double duration=this.duration*12; 

and then this code in a loop:

monthlyInterest=(capital*((100+interest)/100) - capital); capital=capital+monthlyInterest; if (i > duration-2) { monthlyPayment = (capital/(duration-i)) + (monthlyInterest - (monthlyInterest/(duration/(i+1)))); //added this to avoid overpayment for last month } else { monthlyPayment = (capital/(duration-i)) + (monthlyInterest); } capital = capital - monthlyPayment; amountPaid = amountPaid + monthlyPayment; 

A person reading this is likely going to focus on these computations to understand what your code does - the hard math behind them, and not so much the variable declarations at the beginning of the method.

---

"Time-Scoped" Data

In this particular algorithm, you have several parameters that are "scoped" to a particular time interval - for instance "interest" could be a monthly or yearly value.

You already recognized this in the "math" loop above, where you're using variables such as monthlyPayment. This is really great and shows an understanding of the fundamental concept.

Just try to do it consistently over that code.

You're only making it much harder on yourself when you have a yearly interest called interest, then divide that by 12 and have a variable called monthlyInterest in that same function that's used for something else.