Hi,
folgende Aufgabe:
Per Array werden der Name eines Schülers und seine Notenpunkte (0-15) eingegeben. Danach wird ein Notenspiegel gebildet und der Durchschnitt gebildet und Ausgegeben.
Die Eingabe und Ausgabe funzen problemlos, ich hab nur keinen Plan wie ich den Durchschnitt und den Notenspiegel berechnen soll.
Mein Code:
Code:
import java.util.*;
public class notendurch {
public int[] noten = new int[16];
public String[] namen = new String[8];
public double durchschnitt;
public int[] spiegel =new int[8];
public void eingabe() {
for (int x=0; x<namen.length;x++){
System.out.println("Geben sie eine Note ein:" );
noten[x]=StdIn.intInput();
System.out.println("Geben sie den Namen ein:" );
namen[x]=StdIn.stringInput();
StdIn.cls();
}
}
public void notenspiegel() {
for(int b = 0;b < noten.length;b++) {
switch(noten[b]) {
case 1:
spiegel[b]=spiegel[b]+1;
break;
} }
}
public void durchschnitt() {
durchschnitt=durchschnitt+(noten[0]*1);
durchschnitt=durchschnitt+(noten[1]*2);
durchschnitt=durchschnitt+(noten[2]*3);
durchschnitt=durchschnitt+(noten[3]*4);
durchschnitt=durchschnitt+(noten[4]*5);
durchschnitt=durchschnitt+(noten[5]*6);
durchschnitt=durchschnitt/8;
}
public void ausgabe() {
System.out.println("Schueler: " +namen[0]+ " Note: " +noten[0] );
System.out.println("Schueler: " +namen[1]+ " Note: " +noten[1] );
System.out.println("Schueler: " +namen[2]+ " Note: " +noten[2] );
System.out.println("Schueler: " +namen[3]+ " Note: " +noten[3] );
System.out.println("Schueler: " +namen[4]+ " Note: " +noten[4] );
System.out.println("Schueler: " +namen[5]+ " Note: " +noten[5] );
System.out.println("Schueler: " +namen[6]+ " Note: " +noten[6] );
System.out.println("Schueler: " +namen[7]+ " Note: " +noten[7] );
System.out.println(spiegel[3] );
}
public static void main (String[]args) {
notendurch no = new notendurch();
no.eingabe();
no.notenspiegel();
no.durchschnitt();
no.ausgabe();
}
}
Mal abgesehen davon, dass der Code in den Methoden durchschnitt() und notenspiegel() nicht richtig geht (weil ich nicht so richtig weiss, wie ich das realisieren soll), tut das Programm seinen Dienst. Also, hat jemand eine Idee, wie ich es schaffe den Notespiegel+Durchschnitt zu berechnen? Ich will nicht das Programm fertig geschrieben haben, ein paar Tipps oder Hinweise reichen mir schon.
Danke im vorraus.
also meine Java Kenntnisse sind begrenzt, da es lange her ist, aber da ich etwas C++ kann, sollte ich dir trotzdem helfen können, doch vorher eine kurze Frage:
Was ist mit "Notenspiegel" gemeint, das Wort kenne ich einfach ned...?
Und mit Durchschnitt meinste wohl den Schnitt der Noten oder wie?
Also generell berechnet man einen Durchschnitt ganz einfach, in dem man die Summe (also Addieren) aller Noten bildet und dann durch deren Anzahl teilt, das geht mit Arrays verdammt einfach:
Beispiel:
Code:
int werte[10]; // eine Array-Variable mit 10 Feldern
int durchschnitt=0, i; // 2 einfache ints
for (i = 0; i < 10; i++) // i < Feldgröße :)
{
durchschnitt = durchschnitt + wert[i]; //einfach dem aktuellen Wert in durchschnitt, das nächste Feld hinzu addieren
}
durchschnitt = durchschnitt / 10 //da ja 10 Felder
also so sollte das funzen, musste eben noch anpassen
nun verstehe ich aber noch was ned
Code:
public void notenspiegel() {
for(int b = 0;b < noten.length;b++) {
switch(noten[b]) {
case 1:
spiegel[b]=spiegel[b]+1;
break;
} }
}
was wird hier gemacht? dh. wenn es Note gibt, die 1 Punkt ist, dann wird also der Spiegel um 1 erhöht oder wie?
Was ist mit "Notenspiegel" gemeint, das Wort kenne ich einfach ned...?
Und mit Durchschnitt meinste wohl den Schnitt der Noten oder wie?
Echt nicht? Im Notenspiegel wird angeben welche Noten wie oft vorkommen. Also z.B. 3 Einser, 4 Zweier, 10 Dreier, 7 Vierer, 2 Fünfer und 1 Sechser
Durchschnitt: ja genau.
Zitat:
Beispiel:
Code:
int werte[10]; // eine Array-Variable mit 10 Feldern
int durchschnitt=0, i; // 2 einfache ints
for (i = 0; i < 10; i++) // i < Feldgröße :)
{
durchschnitt = durchschnitt + wert[i]; //einfach dem aktuellen Wert in durchschnitt, das nächste Feld hinzu addieren
}
durchschnitt = durchschnitt / 10 //da ja 10 Felder
Danke, funzt.
Zitat:
Code:
public void notenspiegel() {
for(int b = 0;b < noten.length;b++) {
switch(noten[b]) {
case 1:
spiegel[b]=spiegel[b]+1;
break;
} }
}
was wird hier gemacht? dh. wenn es Note gibt, die 1 Punkt ist, dann wird also der Spiegel um 1 erhöht oder wie?
Falls es ein Feld mit der Note 1 Punkt gibt, wird der Zähler für 1 Punkt um eins erhöht. Funzt nicht, sollte auch nur meinen bisherigen "Fortschritt" zeigen
Echt nicht? Im Notenspiegel wird angeben welche Noten wie oft vorkommen. Also z.B. 3 Einser, 4 Zweier, 10 Dreier, 7 Vierer, 2 Fünfer und 1 Sechser
Durchschnitt: ja genau.
Danke, funzt.
Falls es ein Feld mit der Note 1 Punkt gibt, wird der Zähler für 1 Punkt um eins erhöht. Funzt nicht, sollte auch nur meinen bisherigen "Fortschritt" zeigen
also ok das mit dem Notenspiegel klingt einfach und ist auch leicht zu realisieren, dein Anfang war schon ganz gut, wundert mich auch das er ned funzt
würde es in C++ so schreiben (zum Glück ist der Code wie ich sehe recht ähnlich):
Code:
int noten[10]; // Feld für die Noten
int spiegel[15]; // Anzahl der Notenpunkte 1-15, daher 15 Felder ;)
int i;
// spiegelfeld mit 0 vorbelegen, sonst haste ja Zufallswerte :(
for (i = 0; i < 15; i++)
spiegel[i] = 0;
for (i = 0; i < 10; i++)
{
spiegel[noten[i]-1]++;
}
ich weiss ist sehr kurz und bin mir grad ned
sicher ob ned der Compiler meckern würde, aber wenn es geht, wäre es
so imo am besten, denn du rufst einfach das richtige Feld des Spiegels mit Hilfe des Inhalts des Notenfeldes auf und un erhöhst damit den Wert im Spiegelfeld um 1. Wichtig ist das "-1" nur, wenn wie in C++ der Feldindex mit "0" beginnt.
Alternative, falls es nicht geht, ist dann eben so ne switch-Funnktion, die du schon hast und dann eben 15 cases
EDIT:
mir ist bewusst, dass du keinen fertigen Code wolltest, weil du es auch gerne selbst schreiben willst, aber imo ist Quellcode oft verständlicher als 5 Sätze drüber
import java.util.*;
public class notendurch {
public int[] noten = new int[16];
public String[] namen = new String[4];
public double durchschnitt;
public int[] spiegel =new int[16];
public void eingabe() {
for (int x=0; x<namen.length;x++){
System.out.println("Geben sie eine Note ein:" );
noten[x]=StdIn.intInput();
System.out.println("Geben sie den Namen ein:" );
namen[x]=StdIn.stringInput();
StdIn.cls();
}
}
public void notenspiegel() {
for (int i = 0; i <noten.length; i++){
spiegel[i] = 0;
for (i = 0; i <spiegel.length; i++)
{
spiegel[noten[i]]++;
}
}
}
public void durchschnitt() {
for ( int d = 0; d < noten.length; d++)
{
durchschnitt = durchschnitt + noten[d]; }
durchschnitt = durchschnitt / namen.length;
}
public void ausgabe() {
for ( int out = 0; out < namen.length; out++){
System.out.println("Schueler: " +namen[out]+ " Note: " +noten[out] );
}
System.out.println("Der Durchschnitt betraegt: "+durchschnitt );
for ( int r = 0; r < spiegel.length; r++){
System.out.println("Note: " +r+ " Anzahl: "+spiegel[r] );
}}
public static void main (String[]args) {
notendurch no = new notendurch();
no.eingabe();
no.notenspiegel();
no.durchschnitt();
no.ausgabe();
}
}
Allerdings werdem mit im Notenspiegel die 0 Punkte immer mit Anzahl
13 ausgegeben.
import java.util.*;
public class notendurch {
public int[] noten = new int[16];
public String[] namen = new String[4];
public double durchschnitt;
public int[] spiegel =new int[16];
ok der Teil scheint in Ordnung zu sein
Zitat:
Zitat von redfalcon
Code:
public void notenspiegel() {
for (int i = 0; i <noten.length; i++){
spiegel[i] = 0;
for (i = 0; i <spiegel.length; i++)
{
spiegel[noten[i]]++;
}
}
}
ich habe mal die problematischen Sachen rot markiert, wenn du nämlich genau hinsiehst, dann hast du die beiden for schleifen verschatelt, das ist aber keine gute Idee, da du in der äußeren For-Schleife immer eine Null-Zuweisung hast, verfälscht du damit das Ergbnis, außerdem wiederholst du die Spiegelberechnung so oft wie die Anzahl der Noten ist, dh. du berechnest nicht 16 Werte (0-15), sondern 16x16 (da 2 For-Schleifen), probiers mal so:
Code:
public void notenspiegel() {
for (int i = 0; i <noten.length; i++)
spiegel[i] = 0;
for (i = 0; i <spiegel.length; i++)
{
spiegel[noten[i]]++;
}
}
der Rest des codes sieht gut aus
wie das mit den Nullen kommt, kann ich mir aber grad auch ned erklären, behebe mal den Fehler da oben und dann schauen wir weiter
Sorry kann dir leider keine Tipps zur Problemdomäne geben, aber ein paar generelle Java Tipps bekommst du von mir (ob du willst oder nicht :P )
1. Klassennamen beginnen per Konvention mit einem Großbuchstaben
2. Methoden, die weder einen Rückgabewert, noch eine Signatur haben, brauchen keinen public modifier. (Was interssiert sonst ein externes Objekt was diese Methode macht?)
3. du solltest IMMER block-Klammern setzen, z.b.
Zitat:
Zitat von Jlagreen
Code:
public void notenspiegel() {
for (int i = 0; i <noten.length; i++)
spiegel[i] = 0;
for (i = 0; i <spiegel.length; i++)
{
spiegel[noten[i]]++;
}
}
hattest du ja vorher vertan, weil du die {} klamern weggelassen hast.
selbst bei einzeiligen Statements daher klammern setzen (alle anderen Programmierer danken dir, wenn sie den code lesen müssen )
4. Du kannst Arrays mit dynamischer Länge initialisieren z.b.
Code:
private int anzahlSchueler=0;
public int[] noten;
public void eingabe() {
System.out.println("Geben sie die Anzahl der Schueler ein" );
anzahlSchueler=StdIn.intInput();
noten = new int[anzahlSchueler];
for (int x=0; x<namen.length;x++){
System.out.println("Geben sie eine Note ein:" );
noten[x]=StdIn.intInput();
5. ich weiß nicht was hinter "StdIn.intInput();" steckt, aber ich wollte bloß mal nachfragen, ob diese methode selbst schon alle möglichen Exceptions fängt. Wenn nicht solltest du dringend (DAU-Sicherheit) diese Statements mit try-catch blöcken verzieren.
6. Aus Performance-Gründe rate ich davon ab, ganze Packages zu importieren
( import java.util.*; ) benutze stattdessen IDE features die den automatischen Import übernehmen (Organize Imports in Eclipse)
7. Welche IDE verwendest du?
8. Ebenfalls aus Performance Gründen, rate ich dir explizit einen Kontruktor zu formulieren. Ebenfalls solltest du den new Operator erst dort benutzen, nicht schon bei der Deklaration.
9. Warum sind die ganzen Member-Variablen
Code:
public class notendurch {
public int[] noten = new int[16];
public String[] namen = new String[8];
public double durchschnitt;
public int[] spiegel =new int[8];
nicht private? Aus gründen der Sicherheit und Datenkapselung würde ich dir das oder protected anraten. stelle lieber geeignete Getter und Setter methoden zur Verfügung (in Eclipse kannst du diese Generieren lassen)
10. Vergiss das switch statement - kannst du eh nur auf Primitives anwenden. Und im späteren richtigen leben hast du seeehr selten mit echten primitives zu tun. folgendes Kontrukt leistet äquivalentes:
2. Methoden, die weder einen Rückgabewert, noch eine Signatur haben, brauchen keinen public modifier. (Was interssiert sonst ein externes Objekt was diese Methode macht?)
Das hab ich schon in der Schule nicht gerafft. Was bringt es denn, Variablen oder Methoden als private zu kennzeichnen?
Zitat:
4. Du kannst Arrays mit dynamischer Länge initialisieren z.b.
Code:
private int anzahlSchueler=0;
public int[] noten;
public void eingabe() {
System.out.println("Geben sie die Anzahl der Schueler ein" );
anzahlSchueler=StdIn.intInput();
noten = new int[anzahlSchueler];
for (int x=0; x<namen.length;x++){
System.out.println("Geben sie eine Note ein:" );
noten[x]=StdIn.intInput();
Gut zu wissen, wusste nicht, dass es so geht.
Zitat:
5. ich weiß nicht was hinter "StdIn.intInput();" steckt, aber ich wollte bloß mal nachfragen, ob diese methode selbst schon alle möglichen Exceptions fängt. Wenn nicht solltest du dringend (DAU-Sicherheit) diese Statements mit try-catch blöcken verzieren.
Die StdIn fängt Eingaben ab, ist ne externe datei. Funzt auch mit String, double etc.
Zitat:
7. Welche IDE verwendest du?
JavaEditor. Ich probier aber auch grad eclipse aus.
Zitat:
9. Warum sind die ganzen Member-Variablen
Code:
public class notendurch {
public int[] noten = new int[16];
public String[] namen = new String[8];
public double durchschnitt;
public int[] spiegel =new int[8];
nicht private? Aus gründen der Sicherheit und Datenkapselung würde ich dir das oder protected anraten. stelle lieber geeignete Getter und Setter methoden zur Verfügung (in Eclipse kannst du diese Generieren lassen)
k.A. Das ist nur ne Übung für die Schule. Muss das dafür besonders sicher sein? Setter und Getter? Nie gehört.
Zitat:
10. Vergiss das switch statement - kannst du eh nur auf Primitives anwenden. Und im späteren richtigen leben hast du seeehr selten mit echten primitives zu tun. folgendes Kontrukt leistet äquivalentes:
Das hab ich schon in der Schule nicht gerafft. Was bringt es denn, Variablen oder Methoden als private zu kennzeichnen?
Es ist nicht immer sinnvoll den Zugriff auf alle Variablen und Methoden unkontrolliert zu erlauben.
z.b. bei einer Member-Variablen (attribute einer Klasse) die auf keinen Fall auf einen bestimmten wert zu ändern (z.b. unter 0) wenn du du dann dieses attribut als public markierst, kann jeder externe aufruf diese variable nach beliben ändern, senkst du jedoch die Sichtbarkeit und stellst eine Methode zur Verfügung die das überprüft erhälst du mehr sicherheit
bsp:
Code:
private int darfNichtUnterNull = 1;
public void setDarfNichtUnterNull(int zahl) throws NegativeZahlException{
if(zahl > 0){
this.darfNichtUnterNull = zahl;
} else{
throw new NegativeZahlException;
}
}
Zitat:
Zitat von redfalcon
Die StdIn fängt Eingaben ab, ist ne externe datei. Funzt auch mit String, double etc.
Ja das war mir auch klar, ich wollte nur wissen, ob die auch fehler in der eingabe abfängt.
Zitat:
Zitat von redfalcon
k.A. Das ist nur ne Übung für die Schule. Muss das dafür besonders sicher sein? Setter und Getter? Nie gehört.
je eher du sensibel codest desto mehr geht es in fleisch und blut über. Je eher du anfängst "ordentlich" zu coden, desto besser für jeden der mit dir mal an irgendwas arbeiten muss.
Getter und Setter Methoden sind MEthoden die einfach nur ein Attribut zurückgeben oder setzen z.b.:
Code:
private String test;
/**
* returns test
* @return a String representing test
*/
public String getTest(){
return this.test;
}
/**
* sets test
* @param a String with the new value for test
*/
public void setTest(String pTest){
this.test = pTest;
}
Das hab ich schon in der Schule nicht gerafft. Was bringt es denn, Variablen oder Methoden als private zu kennzeichnen?
Das kann auch sinnvoll sein - wenn Du mehrere interne Methoden baust - die einzeln von ausserhalb der Klasse nicht zugreifbar sein sollen!
Meist ist es günstiger (vor allem bei komplexeren Methoden) die Methode in Teile zu zerlegen - um die Wiederverwendbarkeit der einzelnen Methoden zu erhöhen.
Vor allem bei Applikationen die mit Datenbanken arbeiten - werden oft nur ID's als Schlüssel verwendet. Wenn man z.B.: Ein Objekt vom Typ Person hat - dann hat der meist nen Vornamen, nen Nachnamen, ne Anrede (Herr/Frau), nen Titel (Dr., Prof....)
Hier werden für den Titel sowie auch die Anrede in der DB nur die IDs hinterlegt.
Da jetzt an der Person als Titel nur 1 und als Anrede nur 2 steht - kann man jetzt eine PRIVATE Methode nehmen - die aus der 1 des Titels wieder (Dr.) und aus der 2. der Anrede wieder (Frau) macht.
![[Java]Notenspiegel+Durchschnitt berechnen](https://www.tweakpc.de/forum/iconimages/programmiersprachen/java-notenspiegel-durchschnitt-berechnen_ltr.gif)
[Java]Notenspiegel+Durchschnitt berechnen 
Linear-Darstellung
