/*==================================================================== Detta program hör ihop med dokumentet EXEMPEL_AVERAGE_POINTS.PDF där det finns förklaringar. ======================================================================*/ package java_medelbetyg; 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.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.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.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.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.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.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.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