I recently wrote a short program for an exercise in a textbook. After completion however I re-structured the program to use methods instead of one long main method.
My question:
Which way of programming should I be using? I am leaning more towards the methods as it is much more re-useable although longer.
Any help is much appreciated, thanks.
First attempt with one long main method:
/**
* Absolute Java 6.1
*
* A program that takes input: degree of difficulty and seven judges scores.
* Outputs the overall score for a particular dive where:
* Score = (7 judges score-maxscore-minscore) x score multipler of 0.6 x a degree of difficulty
*
*
*/
import java.util.Scanner;
public class DivingScores
{
public static final double MIN_DEGREE_SCORE = 1.2;
public static final double MAX_DEGREE_SCORE = 3.8;
public static final double SCORE_MULTIPLIER = 0.6;
public static final int MAX_DIVE_SCORE = 10;
public static final int MIN_DIVE_SCORE = 0;
public static final int JUDGES = 7;
public static void main(String[] args)
{
Scanner keyboard = new Scanner(System.in);
// Get degree of difficulty.
double degreeOfDifficulty;
do
{
System.out.print("Enter a degree of difficulty: ");
degreeOfDifficulty = keyboard.nextDouble();
if ((degreeOfDifficulty < MIN_DEGREE_SCORE) || (degreeOfDifficulty > MAX_DEGREE_SCORE))
{
System.out.println();
System.out.println("Degree must be between 1.2 and 3.8");
System.out.println();
}
} while ( (degreeOfDifficulty < MIN_DEGREE_SCORE) || (degreeOfDifficulty > MAX_DEGREE_SCORE) );
// Get each judges score.
double[] judgesScores = new double[JUDGES];
for ( int index = 0; index < JUDGES; index++ )
{
double score;
do
{
System.out.println();
System.out.print("Enter judge " + (index+1) + " score: ");
score = keyboard.nextDouble();
if ( (score < MIN_DIVE_SCORE) || (score > MAX_DIVE_SCORE) )
{
System.out.println();
System.out.println("Score must be between 0 - 10");
System.out.println();
}
} while ( (score < MIN_DIVE_SCORE) || (score > MAX_DIVE_SCORE) );
judgesScores[index] = score;
}
// Sort judges scores into ascending order.
for ( int index = 0; index < JUDGES; index++)
{
for ( int otherIndex = (index+1); otherIndex < JUDGES; otherIndex++ )
{
if ( judgesScores[otherIndex] < judgesScores[index] )
{
double temp = judgesScores[index];
judgesScores[index] = judgesScores[otherIndex];
judgesScores[otherIndex] = temp;
}
}
}
// Calculate the final dive score.
double finalScore = 0;
for ( int index = 1; index < (JUDGES-1); index++ )
{
finalScore += judgesScores[index];
}
System.out.println();
System.out.println("Dive score: " + (finalScore*degreeOfDifficulty*SCORE_MULTIPLIER));
}
}Second attempt with multple methods:
/**
* Absolute Java 6.1
*
* A program that takes input: degree of difficulty and seven judges scores.
* Outputs the overall score for a particular dive where:
* Score = (7 judges score-maxscore-minscore) x score multipler of 0.6 x a degree of difficulty
*
*
*/
import java.util.Scanner;
public class DivingScoresAlternate
{
public static final double MIN_DEGREE_SCORE = 1.2;
public static final double MAX_DEGREE_SCORE = 3.8;
public static final double SCORE_MULTIPLIER = 0.6;
public static final int MAX_DIVE_SCORE = 10;
public static final int MIN_DIVE_SCORE = 0;
public static final int JUDGES = 7;
/**
* Gets a degree score as user input and ensures the score is within correct range.
*
* @return double A degree score between 1.2 - 3.8.
*/
public static double getDegree()
{
Scanner keyboard = new Scanner(System.in);
double degreeOfDifficulty;
do
{
System.out.print("Enter a degree of difficulty: ");
degreeOfDifficulty = keyboard.nextDouble();
if ((degreeOfDifficulty < MIN_DEGREE_SCORE) || (degreeOfDifficulty > MAX_DEGREE_SCORE))
{
System.out.println();
System.out.println("Degree must be between 1.2 and 3.8");
System.out.println();
}
} while ( (degreeOfDifficulty < MIN_DEGREE_SCORE) || (degreeOfDifficulty > MAX_DEGREE_SCORE) );
return degreeOfDifficulty;
}
/**
* Gets 7 judges scores and ensures each score is within correct range.
*
* @return double[] array of 7 judges scores between 0 - 10.
*/
public static double[] getJudgesScores()
{
Scanner keyboard = new Scanner(System.in);
double[] judgesScores = new double[JUDGES];
for ( int index = 0; index < JUDGES; index++ )
{
double score;
do
{
System.out.println();
System.out.print("Enter judge " + (index+1) + " score: ");
score = keyboard.nextDouble();
if ( (score < MIN_DIVE_SCORE) || (score > MAX_DIVE_SCORE) )
{
System.out.println();
System.out.println("Score must be between 0 - 10");
System.out.println();
}
} while ( (score < MIN_DIVE_SCORE) || (score > MAX_DIVE_SCORE) );
judgesScores[index] = score;
}
return judgesScores;
}
/**
* Sorting algorithm for an array of doubles. Sorts into ascending order.
*
* @param array Is the array to be sorted.
* @return An array of doubles in ascending order
*/
public static double[] sortAscending(double[] array)
{
for ( int index = 0; index < array.length; index++)
{
for ( int otherIndex = (index+1); otherIndex < array.length; otherIndex++ )
{
if ( array[otherIndex] < array[index] )
{
double temp = array[index];
array[index] = array[otherIndex];
array[otherIndex] = temp;
}
}
}
return array;
}
/**
* Calculates the final score for a dive. Formula:
* Score = (Sum of all the judges scores - MAXscore - MINscore)* degree of difficulty * 0.6
*
* @param judgesScores Is the array of each judges scores.
* @param degreeOfDifficulty is a degree of difficulty for a dive.
* @return double The final score of a dive
*/
public static double getFinalScore(double[] judgesScores, double degreeOfDifficulty)
{
double finalScore = 0;
for ( int index = 1; index < (JUDGES-1); index++ )
{
finalScore += judgesScores[index];
}
return (finalScore*degreeOfDifficulty*SCORE_MULTIPLIER);
}
public static void main(String[] args)
{
double degree = getDegree();
double[] judgesScores = getJudgesScores();
double diveScore = getFinalScore(judgesScores, degree);
System.out.println();
System.out.println("Dive Score: " + diveScore);
}
}