Description
Objective To write a program that computes depreciation with Sum of Years Digits Method.
PROJECT DESCRIPTION
Write, compile and run a program that will display a depreciation schedule ( table ) using the sum – of – the – years – digits method. Your program should be written to receive asset information, such as asset cost and asset life, as input and then display a depreciation table as output.
The program is be written such that is implements the three types of program control:
Sequence, Selection and Repetition.
Test your program with various, different asset values and years.
Include, in your program code, comment statements having your name, course
information and current date.
Attach your source code to your submittal file for credit. Also, attach your program output for at least three different asset scenarios, from the example depreciation tables that follow.
Information about This Project
This project will focus on these programming topics: Numbers and Strings, expressions, statements and Blocks. Also the program will include reference to these Control flow statements: Sequence control, Selection control, Repetition control.
This project will illustrate the use of these programming topics by constructing source code that displays a depreciation schedule for a given asset.
Depreciation is the loss in value of a business – use asset. A common method for calculating deprecation is the sum – of – the – years – digits method. To illustrate it, consider depreciating a $ 60,000 asset over a 5 – year period. First, we calculate the
” sum of the years,” 1 + 2 + 3 + 4 + 5 = 15 . In the first year, 5 / 15 of the
$ 60,000 or $ 20,000 is depreciated; in the second year 4 / 15 of the $ 60,000 or
$ 16,000 is depreciated; and so on, giving the following depreciation table.
Year
Factor
Depreciation
Figure 1
1
5 / 15
$ 20,000
2
4 / 15
$ 16,000
3
3 / 15
$ 12,000
4
2 / 15
$ 8,000
5
1 / 15
$ 4,000
To understand the concept of depreciation, we can also consider the book value of the asset for the above example. The book value examines the current worth of the item by subtracting the prior book value by the current year’s depreciation.
Year
Depreciation
Book Value
Figure 2
1
$ 20,000
$ 40,000
2
$ 16,000
$ 24,000
3
$ 12,000
$ 12,000
4
$ 8,000
$ 4,000
5
$ 4,000
$ 0,000
PROJECT Control Structures in Java – Computing Depreciation
Steps To Complete This Project
STEP 1 Open Eclipse and Write the Program Code
Open Eclipse on your computer and start a new Java project. In your project, add in a Java file named SumOfYearsDepreciation.java and copy in the initial source code for this project shown in Figure 3 below.
STEP 2 Compile and Run Your Program
Build, compile and run the initial program. Test the operation of your program using the appropriate numbers / values for your input variable(s). You can use the sample data provided below.
Sample Program Run
STEP 3 Modify Your Initial Program Code
With your initial program code showing you an output similar to that given above, modify the program such that it will contain a definition for each of two additional methods and their respective calling statements. Notice that comment statements in the original initial source code show the location of their calling statements.
// call the ShowDepreciationSchedule() method
ShowDepreciationSchedule();
// call the CheckDepreciation() method
CheckDepreciation();
The ShowDepreciationSchedule() method is used to receive the data from the global class variables for the given asset details and then output, in professional tabular form, the depreciation schedule similar to what is shown in Figure 1 .
PROJECT Control Structures in Java – Computing Depreciation
The CheckDepreciation() method is used to receive the data from the global class variables for the given asset details and then verify that asset has not been depreciated below its salvage value.
This CheckDepreciation() method can be called within the aforementioned ShowDepreciationSchedule() method to perform its task.
The following MS Excel worksheet can be considered when coding the above methods to see how this depreciation method actually functions and how a schedule might be displayed.
Note: for accounting purposes we assume that the asset is placed into business service at the beginning of the year.
STEP 4 Test Your Program Code and Your Run Time Output
After you supplement the initial program code with the two new methods and their calling statements, test your program using at least three of the asset scenarios which follow and snapshot your results.
STEP 5 Submit Your Program Code and Your Run Time Output
Paste your completed program code and your output snapshots into an
MS Word document and submit the lab on Blackboard by the due date.
PROJECT Control Structures in Java – Computing Depreciation
Asset Scenarios ( for program testing )
Scenario I
asset type
Automobile
asset cost
$ 37,000.00
salvage value
$ 4,000.00
asset life
5 years
Scenario II
asset type
Office Furniture
asset cost
$ 23,000.00
salvage value
$ 1,500.00
asset life
7 years
Scenario III
asset type
Computing System
asset cost
$ 18,000.00
salvage value
$ 2,000.00
asset life
5 years
Scenario IV
asset type
Plant Asset
asset cost
$ 50,000.00
salvage value
$ 7,300.00
asset life
3 years
PROJECT Control Structures in Java – Computing Depreciation
Figure 3 Initial Source Code for the SumOfYears Program
import java.text.DecimalFormat;
import java.util.Scanner;
public class SumOfYearsDepreciation
{
// the global variables are declared
static double assetCost = 0;
static double salvageValue = 0;
static double depreciableAmount = 0;
static int assetLife = 0;
// declare a Scanner class object
static Scanner sc = new Scanner(System.in);
// declare a DecimalFormat class object
static DecimalFormat two = new DecimalFormat(“0.00”);
// method to receive asset information
public static void AssetInfo()
{
// declare and initialize a variable
String assetType = “”;
// display output block information
System.out.println(“[[ Asset Information ]]”);
// request, receive and echo the asset type
System.out.println(“please input the asset type”);
assetType = sc.nextLine();
System.out.println(“Asset Type: ” + assetType);
// request, receive, echo the asset cost, salvage value
System.out.println(“please input the asset cost”);
assetCost = sc.nextDouble();
System.out.println(“Asset Cost: ” +
two.format(assetCost));
System.out.println(“please input the salvage value”);
salvageValue = sc.nextDouble();
System.out.println(“Salvage Value: ” +
two.format(salvageValue));
// compute, echo depreciable amount as (cost – salvage)
depreciableAmount = assetCost – salvageValue;
System.out.println(“Depreciable Amount: ” +
two.format(depreciableAmount));
// request, receive and echo the asset life
System.out.println(“please input the asset life”);
assetLife = sc.nextInt();
System.out.println(“Asset Life: ” + assetLife);
}
PROJECT Control Structures in Java – Computing Depreciation
Figure 3 Initial Source Code for the SumOfYears Program ( Continued )
// method to sum the years
public static int GaussSum(int num)
{
// declare and initialize a variable
int sumOfYears = 0;
// use Gauss Formula to sum the years
sumOfYears = num * (num + 1) / 2;
// echo the sum of years
System.out.println(“sum of years: ” + sumOfYears);
// return the sum
return sumOfYears;
}
public static void main(String[] args)
{
// declare and initialize the local variable(s)
String userName = “”;
// display output block information
System.out.println(“<< Sum of Years Digits Program “);
// meet and greet the program user
System.out.println(“please enter your name: “);
userName = sc.nextLine();
System.out.println(“welcome: ” + userName + “\n”);
// call the AssetInfo() method
AssetInfo();
// call the GaussSum() method
GaussSum(assetLife);
// call the ShowDepreciationSchedule() method
// call the CheckDepreciation() method
}
}
