/*====================================================================
Detta program hör ihop med dokumentet EXEMPEL_AVERAGE_POINTS.PDF
där det finns förklaringar.
======================================================================*/
package java_medelbetyg;
import java.io.IOException;
public class main {
public static void main(String[] args) throws IOException {
//Använd main som ett "handtag" för att hålla ihop programmet.
//Själva programmet finns i övriga klasser.
//Klassen AveragePoints innehåller en metod som räknar ut medelvärdet
//av ett valfritt antal poängvärden, som användaren matar in.
//Det finns flera versioner av klassen, som förklaras i dokumentet
// exempel_average_points.pdf.
AveragePoints00 ap = new AveragePoints00();
//AveragePoints01 ap = new AveragePoints01();
//AveragePoints02 ap = new AveragePoints02();
//AveragePoints03 ap = new AveragePoints03();
//AveragePoints04 ap = new AveragePoints04();
//AveragePoints05 ap = new AveragePoints05();
//AveragePoints06 ap = new AveragePoints06();
ap.calculateAveragePoints(); // Rutan 'Medelpoäng för kurser' i JSP-diagrammet.
}
}
package java_medelbetyg;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class AveragePoints00 {
public void calculateAveragePoints() throws IOException {
// Utför rutan 'Medelpoäng för kurser' i JSP-diagrammet.
//Konstanter
final int ANTAL = 150; //Versaler för konstanter enligt konventionen för Java
//Variabler
int x, i = -1, sum; //x = talet som matades in, i = varvräknare, sum = summan av poängen.
String svar; //Användarens svar på frågor
//Designbeslut: Det ska få plats 150 tal. Två alternativ:
// 1. new int[ANTAL] ==> det första talet på index=0, det 150:e elementet har index 149 etc.
// 2. new int[ANTAL+1] ==> använd ej index 0, första talet på index = 1 och
//
det 150:e på index =150.
int[] tal = new int[ANTAL]; //Det 150:e elementet har index 149.
//IO (denna programmerare ogillar scanner bl.a. pga problemen när olika datatyper ska läsas).
// BufferedReader är entydig och tillförlitlig.
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
do { // En kurs
// Tomma rutan i JSP-diagrammet utgörs av allt inne i loopen
do { //Inmatning (användaren matar in poängen ett åt gången)
System.out.printf("Poäng följd av ENTER (0 och ENTER för att avsluta): ");
i = i + 1;
x = Integer.parseInt( br.readLine() ); //Inmatning en poäng
tal[i] = x;
// Programmeraren använder talet 0 för att representera att användaren vill
// avbryta inmatningen.
} while ( !(x == 0) || i == ANTAL ); // Avbryt?
//Programmeraren vet att det inte går att lägga in fler värden än vad arrayen är
//dimensionerad för och såg till att loopen avbryts om arrayen är full ( i === ANTAL).
//Ett tillägg i koden av något som inte finns i designen (JSP-diagrammet).
// Beräkning
//Summera
sum = 0;
for (int k = 0; k <= i; k++) {
sum = sum + tal[k];
}
//Medelvärde.
// 7 positioner för decimaltalet, varav 1 decimal (medför standardavrundning), högerjusterat.
// För att få decimalresultat av division av två integer:
// konvertera ett av talen till double.
System.out.print("Medelpoäng: ");
System.out.format("%7.1f%n", (double)(sum/(i + 1)));
//Sluta?
System.out.printf ("Sluta? (J/N) ");
svar = br.readLine();
} while (!svar.equals("J")); //Sluta?
System.out.println("Klart.");
} //END calculateAveragePoints00
}
package java_medelbetyg;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class AveragePoints01 {
//ÄNDRAT FRÅN VERSION 00:
// Lagt till antalInmatade.
// x och sum har nu datatypen Double - ändrat på flera platser
// Ändra brytvillkor i inmatningsloppen från 0 till -1.
// Medelpoängen räknas ut och skrivs ut som två separata operationer.
public void calculateAveragePoints() throws IOException {
// Utför rutan 'Medelpoäng för kurser' i JSP-diagrammet.
//Konstanter
final int ANTAL = 150; //Versaler för konstanter enligt konventionen för Java
//Variabler
int i = -1; //i = varvräknare, 1 lägre än det lägsta värdet som arrayindexet får ha
Double x, sum; //x = talet som matades in, sum = summan av poängen. Double för decimalpoäng
//och för att få decimaler i resulatet av divisionen.
int antalInmatade; //NYTT: Används för tydlighet för den som läser koden
String svar; //Användarens svar på frågor
Double medel; //Medelvärdet
Boolean avbryt, sluta; //NYTT: För tydlighet i looparnas brytvillkor
//Designbeslut: Det ska få plats 150 tal. Två alternativ:
// 1. new int[ANTAL] ==> det första talet på index=0, det 150:e elementet har index 149 etc.
// 2. new int[ANTAL+1] ==> använd ej index 0, första talet på index = 1 och
//
det 150:e på index =150.
Double[] tal = new Double[ANTAL]; //Det 150:e elementet har index 149.
//IO (denna programmerare ogillar scanner bl.a. pga problemen när olika datatyper ska läsas).
// BufferedReader är entydig och tillförlitlig.
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// 'Gör jobbet'-rutan i JSP-diagrammet utgörs av allt inne i loopen
do { // En kurs
//Inmatning (användaren matar in poängen ett åt gången)
do { //Inmatning en poäng (den tomma rutan i JSP-diagrammet)
System.out.printf("Poäng följd av ENTER (-1 för att avsluta): ");
i = i + 1;
x = Double.parseDouble( br.readLine() ); //Användaren skriver in ett tal
tal[i] = x;
// Programmeraren använder talet -1 för att representera att användaren vill
// avbryta inmatningen.
//
Om x är -1 sätts (x == -1) True, annars till False.
//
Om i = ANTAL, sätts i == ANTAL till True,annars till false.
//
Om det är minst ett True, sätts avbryt till True, annars till False.
avbryt = (x == -1) || i == ANTAL;
} while ( !avbryt); // Avbryt?
//Programmeraren vet att det inte går att lägga in fler värden än vad arrayen är
//dimensionerad för och såg till att loopen avbryts om arrayen är full ( i === ANTAL).
//Ett tillägg i koden av något som inte finns i designen (JSP-diagrammet).
antalInmatade = i + 1;
// Beräkning
//Summera
sum = 0.0;
for (int k = 0; k <= i; k++) {
sum = sum + tal[k];
}
//Medelvärde.
// 7 positioner för decimaltalet, varav 1 decimal (medför standardavrundning),
högerjusterat.
// För att få decimalresultat av division av två integer:
// konvertera ett av talen till double.
System.out.print("Medelpoäng: ");
medel = (double)(sum/antalInmatade);
// Utskrift
System.out.format("%7.1f%n", medel );
//Sluta?
System.out.printf ("Sluta? (J/N) ");
svar = br.readLine();
sluta = svar.equals("J");
} while (!sluta); //Sluta?
System.out.println("Klart.");
} //END calculateAveragePoints
}
package java_medelbetyg;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class AveragePoints02 {
//ÄNDRAT FRÅN VERSION 01:
// Korrekt uträkning av medelpoängen
public void calculateAveragePoints() throws IOException {
// Utför rutan 'Medelpoäng för kurser' i JSP-diagrammet.
//Konstanter
final int ANTAL = 150; //Versaler för konstanter enligt konventionen för Java
//Variabler
int i = -1; //i = varvräknare, 1 lägre än det lägsta värdet som arrayindexet får ha
Double x, sum; //x = talet som matades in, sum = summan av poängen. Double för decimalpoäng
//och för att få decimaler i resulatet av divisionen.
int antalInmatade; //NYTT: Används för tydlighet för den som läser koden
String svar; //Användarens svar på frågor
Double medel; //Medelvärdet
Boolean avbryt, sluta; //NYTT: För tydlighet i looparnas brytvillkor
//Designbeslut: Det ska få plats 150 tal. Två alternativ:
// 1. new int[ANTAL] ==> det första talet på index=0, det 150:e elementet har index 149 etc.
// 2. new int[ANTAL+1] ==> använd ej index 0, första talet på index = 1 och
//
det 150:e på index =150.
Double[] tal = new Double[ANTAL]; //Det 150:e elementet har index 149.
//IO (denna programmerare ogillar scanner bl.a. pga problemen när olika datatyper ska läsas).
// BufferedReader är entydig och tillförlitlig.
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// 'Gör jobbet'-rutan i JSP-diagrammet utgörs av allt inne i loopen
do { // En kurs
//Inmatning (användaren matar in poängen ett åt gången)
do { //Inmatning en poäng (den tomma rutan i JSP-diagrammet)
System.out.printf("Poäng följd av ENTER (-1 för att avsluta): ");
x = Double.parseDouble( br.readLine() ); //Användaren skriver in ett tal
avbryt = (x == -1); //avbryt blir True eller False
if( !avbryt ) {
i = i + 1;
tal[i] = x;
//Undvik att ändra 'avbryt' från True till False. Ändra bara om det är till True.
if (i == ANTAL) { avbryt = true;}
}
} while ( !avbryt); // Avbryt?
//Programmeraren vet att det inte går att lägga in fler värden än vad arrayen är
//dimensionerad för och såg till att loopen avbryts om arrayen är full ( i === ANTAL).
//Ett tillägg i koden av något som inte finns i designen (JSP-diagrammet).
antalInmatade = i + 1;
// Beräkning
//Summera
sum = 0.0;
for (int k = 0; k <= i; k++) {
sum = sum + tal[k];
}
//För testning
System.out.println("sum=" + sum + " antal=" + antalInmatade);
//Medelvärde.
// 7 positioner för decimaltalet, varav 1 decimal (medför standardavrundning), högerjusterat.
// För att få decimalresultat av division av två integer:
// konvertera ett av talen till double.
System.out.print("Medelpoäng: ");
medel = (double)(sum/antalInmatade);
// Utskrift
System.out.format("%7.1f%n", medel );
//Sluta?
System.out.printf ("Sluta? (J/N) ");
svar = br.readLine();
sluta = svar.equals("J");
} while (!sluta); //Sluta?
System.out.println("Klart.");
} //END calculateAveragePoints
}
package java_medelbetyg;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class AveragePoints03 {
//ÄNDRAT FRÅN VERSION 01:
// Korrekt uträkning av medelpoängen
public void calculateAveragePoints() throws IOException {
// Utför rutan 'Medelpoäng för kurser' i JSP-diagrammet.
//Konstanter
final int ANTAL = 3; //Versaler för konstanter enligt konventionen för Java
//Variabler
int i; //i = varvräknare
Double x, sum; //x = talet som matades in, sum = summan av poängen. Double för decimalpoäng
//och för att få decimaler i resulatet av divisionen.
int antalInmatade; //NYTT: Används för tydlighet för den som läser koden
String svar; //Användarens svar på frågor
Double medel; //Medelvärdet
Boolean avbryt, sluta; //NYTT: För tydlighet i looparnas brytvillkor
//Designbeslut: Det ska få plats 150 tal. Två alternativ:
// 1. new int[ANTAL] ==> det första talet på index=0, det 150:e elementet har index 149 etc.
// 2. new int[ANTAL+1] ==> använd ej index 0, första talet på index = 1 och
//
det 150:e på index =150.
Double[] tal = new Double[ANTAL]; //Det 150:e elementet har index 149.
//IO (denna programmerare ogillar scanner bl.a. pga problemen när olika datatyper ska läsas).
// BufferedReader är entydig och tillförlitlig.
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// 'Gör jobbet'-rutan i JSP-diagrammet utgörs av allt inne i loopen
do { // En kurs
//Inmatning (användaren matar in poängen ett åt gången)
i = -1; // i = ett lägre än det lägsta värdet som arrayindexet får ha
do { //Inmatning en poäng (den tomma rutan i JSP-diagrammet)
System.out.printf("Poäng följd av ENTER (-1 för att avsluta): ");
x = Double.parseDouble( br.readLine() ); //Användaren skriver in ett tal
avbryt = (x == -1); //avbryt blir True eller False
if( !avbryt ) {
i = i + 1;
tal[i] = x;
//Undvik att ändra 'avbryt' från True till False. Ändra bara om det är till True.
if (i == ANTAL) { avbryt = true;}
}
} while ( !avbryt); // Avbryt?
//Programmeraren vet att det inte går att lägga in fler värden än vad arrayen är
//dimensionerad för och såg till att loopen avbryts om arrayen är full ( i === ANTAL).
//Ett tillägg i koden av något som inte finns i designen (JSP-diagrammet).
antalInmatade = i + 1;
// Beräkning
//Summera
sum = 0.0;
for (int k = 0; k <= i; k++) {
sum = sum + tal[k];
}
//För testning
System.out.println("sum=" + sum + " antal=" + antalInmatade);
//Medelvärde.
// 7 positioner för decimaltalet, varav 1 decimal (medför standardavrundning), högerjusterat.
// För att få decimalresultat av division av två integer:
// konvertera ett av talen till double.
System.out.print("Medelpoäng: ");
medel = (double)(sum/antalInmatade);
// Utskrift
System.out.format("%7.1f%n", medel );
//Sluta?
System.out.printf ("Sluta? (J/N) ");
svar = br.readLine();
sluta = svar.equals("J");
} while (!sluta); //Sluta?
System.out.println("Klart.");
} //END calculateAveragePoints
}
package java_medelbetyg;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class AveragePoints04 {
//ÄNDRAT FRÅN VERSION 01:
// Korrekt uträkning av medelpoängen
public void calculateAveragePoints() throws IOException {
// Utför rutan 'Medelpoäng för kurser' i JSP-diagrammet.
//Konstanter
final int ANTAL = 3; //Versaler för konstanter enligt konventionen för Java
//Variabler
int i; //i = varvräknare
Double x, sum; //x = talet som matades in, sum = summan av poängen. Double för decimalpoäng
//och för att få decimaler i resulatet av divisionen.
int antalInmatade; //NYTT: Används för tydlighet för den som läser koden
String svar; //Användarens svar på frågor
Double medel; //Medelvärdet
Boolean avbryt, sluta; //NYTT: För tydlighet i looparnas brytvillkor
//Designbeslut: Det ska få plats 150 tal. Två alternativ:
// 1. new int[ANTAL] ==> det första talet på index=0, det 150:e elementet har index 149 etc.
// 2. new int[ANTAL+1] ==> använd ej index 0, första talet på index = 1 och
//
det 150:e på index =150.
Double[] tal = new Double[ANTAL]; //Det 150:e elementet har index 149.
//IO (denna programmerare ogillar scanner bl.a. pga problemen när olika datatyper ska läsas).
// BufferedReader är entydig och tillförlitlig.
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// 'Gör jobbet'-rutan i JSP-diagrammet utgörs av allt inne i loopen
do { // En kurs
//Inmatning (användaren matar in poängen ett åt gången)
i = -1; // i = ett lägre än det lägsta värdet som arrayindexet får ha
do { //Inmatning en poäng (den tomma rutan i JSP-diagrammet)
System.out.printf("Poäng följd av ENTER (-1 för att avsluta): ");
x = Double.parseDouble( br.readLine() ); //Användaren skriver in ett tal
avbryt = (x == -1); //avbryt blir True eller False
if( !avbryt ) {
i = i + 1;
//Undvik att ändra 'avbryt' från True till False. Ändra bara om det är till True.
if (i == ANTAL) { avbryt = true;}
else { tal[i] = x;
}
}
System.out.print ("LOOPEN INMATNING: i="+i ); //FÖR TESTNING
System.out.println("; tal[i]="+tal[i]); //FÖR TESTNING
} while ( !avbryt); // Avbryt?
antalInmatade = i + 1;
// Beräkning
//Summera
sum = 0.0;
for (int k = 0; k <= i; k++) {
System.out.println("K="+k); //FÖR TESTNING
sum = sum + tal[k];
}
//För testning
System.out.println("sum=" + sum + " antal=" + antalInmatade);
//Medelvärde.
// 7 positioner för decimaltalet, varav 1 decimal (medför standardavrundning), högerjusterat.
// För att få decimalresultat av division av två integer:
// konvertera ett av talen till double.
System.out.print("Medelpoäng: ");
medel = (double)(sum/antalInmatade);
// Utskrift
System.out.format("%7.1f%n", medel );
//Sluta?
System.out.printf ("Sluta? (J/N) ");
svar = br.readLine();
sluta = svar.equals("J");
} while (!sluta); //Sluta?
System.out.println("Klart.");
} //END calculateAveragePoints
}
package java_medelbetyg;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class AveragePoints05 {
//ÄNDRAT FRÅN VERSION 01:
// Korrekt uträkning av medelpoängen
public void calculateAveragePoints() throws IOException {
// Utför rutan 'Medelpoäng för kurser' i JSP-diagrammet.
//Konstanter
final int ANTAL = 3; //Versaler för konstanter enligt konventionen för Java
//Variabler
int i; //i = varvräknare
Double x, sum; //x = talet som matades in, sum = summan av poängen. Double för decimalpoäng
//och för att få decimaler i resulatet av
divisionen.
int antalInmatade; //NYTT: Används för tydlighet för den som läser koden
String svar; //Användarens svar på frågor
Double medel; //Medelvärdet
Boolean avbryt, sluta; //NYTT: För tydlighet i looparnas brytvillkor
//Designbeslut: Det ska få plats 150 tal. Två alternativ:
// 1. new int[ANTAL] ==> det första talet på index=0, det 150:e elementet har index 149 etc.
// 2. new int[ANTAL+1] ==> använd ej index 0, första talet på index = 1 och
//
det 150:e på index =150.
Double[] tal = new Double[ANTAL]; //Det 150:e elementet har index 149.
//IO (denna programmerare ogillar scanner bl.a. pga problemen när olika datatyper ska läsas).
// BufferedReader är entydig och tillförlitlig.
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// 'Gör jobbet'-rutan i JSP-diagrammet utgörs av allt inne i loopen
do { // En kurs
//Inmatning (användaren matar in poängen ett åt gången)
i = -1; // i = ett lägre än det lägsta värdet som arrayindexet får ha
do { //Inmatning en poäng (den tomma rutan i JSP-diagrammet)
System.out.printf("Poäng följd av ENTER (-1 för att avsluta): ");
x = Double.parseDouble( br.readLine() ); //Användaren skriver in ett tal
avbryt = (x == -1); //avbryt blir True eller False
if( !avbryt ) {
i = i + 1;
tal[i] = x;
//Undvik att ändra 'avbryt' från True till False. Ändra bara om det är till True.
if (i == ANTAL - 1) { avbryt = true;}
}
System.out.print ("LOOPEN INMATNING: i="+i ); //FÖR TESTNING
System.out.println("; tal[i]="+tal[i]); //FÖR TESTNING
} while ( !avbryt); // Avbryt?
antalInmatade = i + 1;
// Beräkning
//Summera
sum = 0.0;
for (int k = 0; k <= i; k++) {
System.out.println("K="+k); //FÖR TESTNING
sum = sum + tal[k];
}
//För testning
System.out.println("sum=" + sum + " antal=" + antalInmatade);
//Medelvärde.
// 7 positioner för decimaltalet, varav 1 decimal (medför standardavrundning), högerjusterat.
// För att få decimalresultat av division av två integer:
// konvertera ett av talen till double.
System.out.print("Medelpoäng: ");
medel = (double)(sum/antalInmatade);
// Utskrift
System.out.format("%7.1f%n", medel );
//Sluta?
System.out.printf ("Sluta? (J/N) ");
svar = br.readLine();
sluta = svar.equals("J");
} while (!sluta); //Sluta?
System.out.println("Klart.");
} //END calculateAveragePoints
}
package java_medelbetyg;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class AveragePoints06 {
//ÄNDRAT FRÅN VERSION 01:
// Korrekt uträkning av medelpoängen
public void calculateAveragePoints() throws IOException {
// Utför rutan 'Medelpoäng för kurser' i JSP-diagrammet.
//Konstanter
final int ANTAL = 3; //Versaler för konstanter enligt konventionen för Java
//Variabler
int i; //i = varvräknare
Double x, sum; //x = talet som matades in, sum = summan av poängen. Double för decimalpoäng
//och för att få decimaler i resulatet av divisionen.
int antalInmatade; //NYTT: Används för tydlighet för den som läser koden
String svar; //Användarens svar på frågor
Double medel; //Medelvärdet
Boolean avbryt, sluta; //NYTT: För tydlighet i looparnas brytvillkor
//Designbeslut: Det ska få plats 150 tal. Två alternativ:
// 1. new int[ANTAL] ==> det första talet på index=0, det 150:e elementet har index 149 etc.
// 2. new int[ANTAL+1] ==> använd ej index 0, första talet på index = 1 och
//
det 150:e på index =150.
Double[] tal = new Double[ANTAL]; //Det 150:e elementet har index 149.
//IO (denna programmerare ogillar scanner bl.a. pga problemen när olika datatyper ska läsas).
// BufferedReader är entydig och tillförlitlig.
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// 'Gör jobbet'-rutan i JSP-diagrammet utgörs av allt inne i loopen
do { // En kurs
//Inmatning (användaren matar in poängen ett åt gången)
i = -1; // i = ett lägre än det lägsta värdet som arrayindexet får ha
do { //Inmatning en poäng (den tomma rutan i JSP-diagrammet)
System.out.printf("Poäng följd av ENTER (-1 för att avsluta): ");
x = Double.parseDouble( br.readLine() ); //Användaren skriver in ett tal
avbryt = (x == -1); //avbryt blir True eller False
if( !avbryt ) {
i = i + 1;
tal[i] = x;
//Undvik att ändra 'avbryt' från True till False. Ändra bara om det är till True.
if (i == ANTAL - 1) { avbryt = true;}
}
System.out.print ("LOOPEN INMATNING: i="+i ); //FÖR TESTNING
System.out.println("; tal[i]="+tal[i]); //FÖR TESTNING
} while ( !(x==-1) && !(i==ANTAL-1)); // Avbryt?
antalInmatade = i + 1;
// Beräkning
//Summera
sum = 0.0;
for (int k = 0; k <= i; k++) {
System.out.println("K="+k); //FÖR TESTNING
sum = sum + tal[k];
}
//För testning
System.out.println("sum=" + sum + " antal=" + antalInmatade);
//Medelvärde.
// 7 positioner för decimaltalet, varav 1 decimal (medför standardavrundning), högerjusterat.
// För att få decimalresultat av division av två integer:
// konvertera ett av talen till double.
System.out.print("Medelpoäng: ");
medel = (double)(sum/antalInmatade);
// Utskrift
System.out.format("%7.1f%n", medel );
//Sluta?
System.out.printf ("Sluta? (J/N) ");
svar = br.readLine();
sluta = svar.equals("J");
} while (!sluta); //Sluta?
System.out.println("Klart.");
} //END calculateAveragePoints
}