| Year |
Balance |
| 0 |
$10,000 |
| 1 |
$10,500 |
| 2 |
$11,025 |
| 3 |
$11,576.25 |
| 4 |
$12,155.06 |
| 5 |
$12,762.82 |
| 1 | /** |
| 2 | A class to monitor the growth of an investment that |
| 3 | accumulates interest at a fixed annual rate |
| 4 | */ |
| 5 | public class Investment |
| 6 | { |
| 7 | /** |
| 8 | Constructs an Investment object from a starting balance and |
| 9 | interest rate. |
| 10 | @param aBalance the starting balanece |
| 11 | @param aRate the interest rate in percent |
| 12 | */ |
| 13 | public Investment(double aBalance, double aRate) |
| 14 | { |
| 15 | balance = aBalance; |
| 16 | rate = aRate; |
| 17 | years = 0; |
| 18 | } |
| 19 | |
| 20 | /** |
| 21 | Keeps accumulating interest until a target balance has |
| 22 | been reached. |
| 23 | @param targetBalance the desired balance |
| 24 | */ |
| 25 | public void waitForBalance(double targetBalance) |
| 26 | { |
| 27 | while (balance < targetBalance) |
| 28 | { |
| 29 | years++; |
| 30 | double interest = balance * rate / 100; |
| 31 | balance = balance + interest; |
| 32 | } |
| 33 | } |
| 34 | |
| 35 | /** |
| 36 | Gets the current investment balance. |
| 37 | @return the current balance |
| 38 | */ |
| 39 | public double getBalance() |
| 40 | { |
| 41 | return balance; |
| 42 | } |
| 43 | |
| 44 | /** |
| 45 | Gets the number of years this investment has accumulated |
| 46 | interest. |
| 47 | @return the number of years since the start of the investment |
| 48 | */ |
| 49 | public int getYears() |
| 50 | { |
| 51 | return years; |
| 52 | } |
| 53 | |
| 54 | private double balance; |
| 55 | private double rate; |
| 56 | private int years; |
| 57 | } |
| 1 | /** |
| 2 | This program computes how long it takes for an investment |
| 3 | to double. |
| 4 | */ |
| 5 | public class InvestmentTest |
| 6 | { |
| 7 | public static void main(String[] args) |
| 8 | { |
| 9 | final double INITIAL_BALANCE = 10000; |
| 10 | final double RATE = 5; |
| 11 | Investment invest = new Investment(INITIAL_BALANCE, RATE); |
| 12 | invest.waitForBalance(2 * INITIAL_BALANCE); |
| 13 | int years = invest.getYears(); |
| 14 | System.out.println("The investment doubled after " |
| 15 | + years + " years"); |
| 16 | } |
| 17 | } |
Example:
Purpose:To execute a statement while a condition is true |
do
statement
while (condition);
Example: Validate input
double value;
do
{
String input = JOptionPane.showInputDialog(
"Please enter a positive number");
value = Integer.parseInt(input);
}
while (input <= 0);
| 1 | /** |
| 2 | A class to monitor the growth of an investment that |
| 3 | accumulates interest at a fixed annual rate |
| 4 | */ |
| 5 | public class Investment |
| 6 | { |
| 7 | /** |
| 8 | Constructs an Investment object from a starting balance and |
| 9 | interest rate. |
| 10 | @param aBalance the starting balanece |
| 11 | @param aRate the interest rate in percent |
| 12 | */ |
| 13 | public Investment(double aBalance, double aRate) |
| 14 | { |
| 15 | balance = aBalance; |
| 16 | rate = aRate; |
| 17 | years = 0; |
| 18 | } |
| 19 | |
| 20 | /** |
| 21 | Keeps accumulating interest until a target balance has |
| 22 | been reached. |
| 23 | @param targetBalance the desired balance |
| 24 | */ |
| 25 | public void waitForBalance(double targetBalance) |
| 26 | { |
| 27 | while (balance < targetBalance) |
| 28 | { |
| 29 | years++; |
| 30 | double interest = balance * rate / 100; |
| 31 | balance = balance + interest; |
| 32 | } |
| 33 | } |
| 34 | |
| 35 | /** |
| 36 | Keeps accumulating interest for a given number of years. |
| 37 | @param n the number of years |
| 38 | */ |
| 39 | public void waitYears(int n) |
| 40 | { |
| 41 | for (int i = 1; i <= n; i++) |
| 42 | { |
| 43 | double interest = balance * rate / 100; |
| 44 | balance = balance + interest; |
| 45 | } |
| 46 | years = years + n; |
| 47 | } |
| 48 | |
| 49 | /** |
| 50 | Gets the current investment balance. |
| 51 | @return the current balance |
| 52 | */ |
| 53 | public double getBalance() |
| 54 | { |
| 55 | return balance; |
| 56 | } |
| 57 | |
| 58 | /** |
| 59 | Gets the number of years this investment has accumulated |
| 60 | interest. |
| 61 | @return the number of years since the start of the investment |
| 62 | */ |
| 63 | public int getYears() |
| 64 | { |
| 65 | return years; |
| 66 | } |
| 67 | |
| 68 | private double balance; |
| 69 | private double rate; |
| 70 | private int years; |
| 71 | } |
| 1 | /** |
| 2 | This program computes how much an investment grows in |
| 3 | a given number of years. |
| 4 | */ |
| 5 | public class InvestmentTest |
| 6 | { |
| 7 | public static void main(String[] args) |
| 8 | { |
| 9 | final double INITIAL_BALANCE = 10000; |
| 10 | final double RATE = 5; |
| 11 | final int YEARS = 20; |
| 12 | Investment invest = new Investment(INITIAL_BALANCE, RATE); |
| 13 | invest.waitYears(YEARS); |
| 14 | double balance = invest.getBalance(); |
| 15 | System.out.println("The balance after " + YEARS + |
| 16 | " years is " + balance); |
| 17 | } |
| 18 | } |
Example:
Purpose:To execute an initialization, then keep executing a statement and updating an expression while a condition is true |
| 1 | /** |
| 2 | This class describes triangle objects that can be displayed |
| 3 | as shapes like this: |
| 4 | [] |
| 5 | [][] |
| 6 | [][][] |
| 7 | */ |
| 8 | public class Triangle |
| 9 | { |
| 10 | /** |
| 11 | Constructs a triangle. |
| 12 | @param aWidth the number of [] in the last row of the triangle. |
| 13 | */ |
| 14 | public Triangle(int aWidth) |
| 15 | { |
| 16 | width = aWidth; |
| 17 | } |
| 18 | |
| 19 | /** |
| 20 | Computes a string representing the triangle. |
| 21 | @return a string consisting of [] and newline characters |
| 22 | */ |
| 23 | public String toString() |
| 24 | { |
| 25 | String r = ""; |
| 26 | for (int i = 1; i <= width; i++) |
| 27 | { |
| 28 | // make triangle row |
| 29 | for (int j = 1; j <= i; j++) |
| 30 | r = r + "[]"; |
| 31 | r = r + "\n"; |
| 32 | } |
| 33 | return r; |
| 34 | } |
| 35 | |
| 36 | private int width; |
| 37 | } |
| 1 | /** |
| 2 | This program tests the Triangle class. |
| 3 | */ |
| 4 | public class TriangleTest |
| 5 | { |
| 6 | public static void main(String[] args) |
| 7 | { |
| 8 | Triangle small = new Triangle(3); |
| 9 | System.out.println(small.toString()); |
| 10 | |
| 11 | Triangle large = new Triangle(15); |
| 12 | System.out.println(large.toString()); |
| 13 | } |
| 14 | } |
boolean done = false;
while (!done)
{
String input = read input;
if (end of input indicated)
done = true;
else
{
process input
}
}
"Loop and a half"
| 1 | /** |
| 2 | Computes the average of a set of data values. |
| 3 | */ |
| 4 | public class DataSet |
| 5 | { |
| 6 | /** |
| 7 | Constructs an empty data set. |
| 8 | */ |
| 9 | public DataSet() |
| 10 | { |
| 11 | sum = 0; |
| 12 | count = 0; |
| 13 | maximum = 0; |
| 14 | } |
| 15 | |
| 16 | /** |
| 17 | Adds a data value to the data set |
| 18 | @param x a data value |
| 19 | */ |
| 20 | public void add(double x) |
| 21 | { |
| 22 | sum = sum + x; |
| 23 | if (count == 0 || maximum < x) maximum = x; |
| 24 | count++; |
| 25 | } |
| 26 | |
| 27 | /** |
| 28 | Gets the average of the added data. |
| 29 | @return the average or 0 if no data has been added |
| 30 | */ |
| 31 | public double getAverage() |
| 32 | { |
| 33 | if (count == 0) return 0; |
| 34 | else return sum / count; |
| 35 | } |
| 36 | |
| 37 | /** |
| 38 | Gets the largest of the added data. |
| 39 | @return the maximum or 0 if no data has been added |
| 40 | */ |
| 41 | public double getMaximum() |
| 42 | { |
| 43 | return maximum; |
| 44 | } |
| 45 | |
| 46 | private double sum; |
| 47 | private double maximum; |
| 48 | private int count; |
| 49 | } |
| 1 | import javax.swing.JOptionPane; |
| 2 | |
| 3 | /** |
| 4 | This program computes the average and maximum of a set |
| 5 | of input values. |
| 6 | */ |
| 7 | public class InputTest |
| 8 | { |
| 9 | public static void main(String[] args) |
| 10 | { |
| 11 | DataSet data = new DataSet(); |
| 12 | |
| 13 | boolean done = false; |
| 14 | while (!done) |
| 15 | { |
| 16 | String input = JOptionPane.showInputDialog("Enter value, Cancel to quit"); |
| 17 | if (input == null) |
| 18 | done = true; |
| 19 | else |
| 20 | { |
| 21 | double x = Double.parseDouble(input); |
| 22 | data.add(x); |
| 23 | } |
| 24 | } |
| 25 | |
| 26 | System.out.println("Average = " + data.getAverage()); |
| 27 | System.out.println("Maximum = " + data.getMaximum()); |
| 28 | } |
| 29 | } |
StringTokenizer tokenizer
= new StringTokenizer();
while (tokenizer.hasMoreTokens())
{
String token = tokenizer.nextToken();
process token
}
| 1 | import java.util.StringTokenizer; |
| 2 | import javax.swing.JOptionPane; |
| 3 | |
| 4 | /** |
| 5 | This program computes the average and maximum of a set |
| 6 | of input values that are entered on a single line. |
| 7 | */ |
| 8 | public class InputTest |
| 9 | { |
| 10 | public static void main(String[] args) |
| 11 | { |
| 12 | DataSet data = new DataSet(); |
| 13 | |
| 14 | String input = JOptionPane.showInputDialog("Enter values:"); |
| 15 | StringTokenizer tokenizer = new StringTokenizer(input); |
| 16 | while (tokenizer.hasMoreTokens()) |
| 17 | { |
| 18 | String token = tokenizer.nextToken(); |
| 19 | |
| 20 | double x = Double.parseDouble(token); |
| 21 | data.add(x); |
| 22 | } |
| 23 | |
| 24 | System.out.println("Average = " + data.getAverage()); |
| 25 | System.out.println("Maximum = " + data.getMaximum()); |
| 26 | } |
| 27 | } |
for (int i = 0; i < s.length(); i++)
{
char ch = s.charAt(i);
process ch
}
int vowelCount = 0;
String vowels = "aeiouy";
for (int i = 0; i < s.length(); i++)
{
char ch = s.charAt(i);
if (vowels.indexOf(ch) >= 0)
vowelCount++;
}
| 1 | import java.util.Random; |
| 2 | |
| 3 | /** |
| 4 | This class models a die that, when cast, lands on a random |
| 5 | face. |
| 6 | */ |
| 7 | public class Die |
| 8 | { |
| 9 | /** |
| 10 | Constructs a die with a given number of sides |
| 11 | @param s the number of sides, e.g. 6 for a normal die |
| 12 | */ |
| 13 | public Die(int s) |
| 14 | { |
| 15 | sides = s; |
| 16 | generator = new Random(); |
| 17 | } |
| 18 | |
| 19 | /** |
| 20 | Simulates a throw of the die |
| 21 | @return the face of the die |
| 22 | */ |
| 23 | public int cast() |
| 24 | { |
| 25 | return 1 + generator.nextInt(sides); |
| 26 | } |
| 27 | |
| 28 | |
| 29 | private Random generator; |
| 30 | private int sides; |
| 31 | } |
| 1 | /** |
| 2 | This program simulates casting a die ten times. |
| 3 | */ |
| 4 | public class DieTest |
| 5 | { |
| 6 | public static void main(String[] args) |
| 7 | { |
| 8 | Die d = new Die(6); |
| 9 | final int TRIES = 10; |
| 10 | for (int i = 1; i <= TRIES; i++) |
| 11 | { |
| 12 | int n = d.cast(); |
| 13 | System.out.print(n + " "); |
| 14 | } |
| 15 | System.out.println(); |
| 16 | } |
| 17 | } |
| 1 | import java.util.Random; |
| 2 | |
| 3 | /** |
| 4 | This class simulates a needle in the Buffon needle experiment. |
| 5 | */ |
| 6 | public class Needle |
| 7 | { |
| 8 | /** |
| 9 | Constructs a needle. |
| 10 | */ |
| 11 | public Needle() |
| 12 | { |
| 13 | hits = 0; |
| 14 | generator = new Random(); |
| 15 | } |
| 16 | |
| 17 | /** |
| 18 | Drops the needle on the grid of lines and |
| 19 | remembers whether the needle hit a line. |
| 20 | */ |
| 21 | public void drop() |
| 22 | { |
| 23 | double ylow = 2 * generator.nextDouble(); |
| 24 | double angle = 180 * generator.nextDouble(); |
| 25 | |
| 26 | // compute high point of needle |
| 27 | |
| 28 | double yhigh = ylow + Math.sin(Math.toRadians(angle)); |
| 29 | if (yhigh >= 2) hits++; |
| 30 | tries++; |
| 31 | } |
| 32 | |
| 33 | /** |
| 34 | Gets the number of times the needle hit a line. |
| 35 | @return the hit count |
| 36 | */ |
| 37 | public int getHits() |
| 38 | { |
| 39 | return hits; |
| 40 | } |
| 41 | |
| 42 | /** |
| 43 | Gets the total number of times the needle was dropped. |
| 44 | @return the try count |
| 45 | */ |
| 46 | public int getTries() |
| 47 | { |
| 48 | return tries; |
| 49 | } |
| 50 | |
| 51 | private Random generator; |
| 52 | private int hits; |
| 53 | private int tries; |
| 54 | } |
| 1 | /** |
| 2 | This program simulates the Buffon needle experiment |
| 3 | and prints the resulting approximations of pi. |
| 4 | */ |
| 5 | public class NeedleTest |
| 6 | { |
| 7 | public static void main(String[] args) |
| 8 | { |
| 9 | Needle n = new Needle(); |
| 10 | final int TRIES1 = 10000; |
| 11 | final int TRIES2 = 100000; |
| 12 | |
| 13 | for (int i = 1; i <= TRIES1; i++) |
| 14 | n.drop(); |
| 15 | System.out.println("Tries / Hits = " |
| 16 | + (double)n.getTries() / n.getHits()); |
| 17 | |
| 18 | for (int i = TRIES1 + 1; i <= TRIES2; i++) |
| 19 | n.drop(); |
| 20 | System.out.println("Tries / Hits = " |
| 21 | + (double)n.getTries() / n.getHits()); |
| 22 | } |
| 23 | } |