Zitat von anpro

Ich hab 2 Beispiele zu lösen für einen Kurs auf der Uuni, aber ich steh leider an und weiß nicht weiter...vielleicht kann mir ja einer von euch ein paar tips geben bzw. weiter helfen.
Die Probleme:
--> Wir sollen einen Zinsrechner schreiben, der Schleifen verwendet. Das Programm soll folgende Ausgabe erzeugen:
Zu Beginn befinden sich 10000 Euro auf dem Konto
Dieser Betrag wird 10 Jahre lang mit 5% verzinst.
Jahr 0: 10000.0
Jahr 1: 10500.0
Jahr 2: 11025.0
Jahr 3: 11576.250000000002
Jahr 4: 12155.062500000002
Jahr 5: 12762.815625000003
Jahr 6: 13400.956406250005
Jahr 7: 14071.004226562505
Jahr 8: 14774.55443789063
Jahr 9: 15513.282159785162
Jahr 10: 16288.946267774423

Dann ist noch angegeben:
Zur Hilfe könnt Ihr in der Java API die Library Math ( die
Methode static double pow(double a,double b) nachschlagen.
Formel für die Zinsrechnung: Kn=Ko * 1/qn

Hier stehe ich nun mit meinenm kläglichen Versuch an(ich weiß leider nicht wo und wie ich die Formel einbauen muss):

public class schleife1 {
public static void main (String[]args){
{
int zielWert = 10;
for (int i=10000;i<=zielWert;i++) {
System.out.println(i + " mit 5% verzinst ergibt: " + (i++));

}
}
}
}

Alles anzeigen

Also die Schleife ist insofern falsch: du nimmst für i 10000 und sagst bei i <= 10 soll die schleife aufhören, das ist aber von anfang an bereits so, also wird die schleife gar nicht ausgeführt.

Einfachste lösung:

public class schleife1 {


	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Double j = 10000.0;
		for (int i = 0; i <= 10; i++){
			System.out.println(j + "mit 5% verzinst ergibt:" + (j + (j * 0.05)));
			j = j + (j * 0.05);

		}


	}


}

in dem fall brauchst du Double, da du sonst nicht mit 0.05 multiplizieren kannst. Int ist immer nur für ganze zahlen.

Zitat

-->Beim nächsten Beispiel sollen wir mit einer if-ANeisung 3 Matrikelnummern vergleichen von denen nur eine richtig ist. Hier sind nun 2 verschiedene Varianten von mir(ich scheitere glaub ich schon an der Deklaration einer matrikelnummer):

class Matrikelnummer {

public static void main(String[] arguments){

int Matrikelnummer=h0024664;

if (Matrikelnummer== "h0024664")
System.out.println("true");
else
if (Matrikelnummer == "h9943253")
System.out.println("wrong");
else
if (Matrikelnummer == "h0343453" )
System.out.println("wrong");

/* bitte geben Sie eine if Anweisung an zum Vergleichen, ob
die vergleichende matrikelnummer gegeben ist (true bzw.
false). */

}
}
class Hausuebung3 {
public static void main (String[]args)
{

String Matrikelnummer=h0024664;

if (matrikelnummer == h9943253) System.out.println ("true");
else if (matrikelnummer == h0024664) System.out.println("false");
else System.out.println("ok");

/* bitte geben Sie eine if Anweisung an zum Vergleichen, ob
die vergleichende matrikelnummer gegeben ist (true bzw.
false). */

}
}

Ich wäre euch für Hilfe und Hinweise jeglicher Art sehr sehr dankbar!!!!

Alles anzeigen

Fast richtig, aber du hast ein Problem. du versucht in einem INT einen char zu speichern (h vor der nummer). Wenn du statt Int - String nimmst, klappts:

class Matrikelnummer {


public static void main(String[] arguments){


String Matrikelnummer= "h0024664";




if (Matrikelnummer== "h0024664")
System.out.println("true");
else
if (Matrikelnummer == "h9943253")
System.out.println("wrong");
else
if (Matrikelnummer == "h0343453" )
System.out.println("wrong");
}


}

Und eines noch: ich weiß nicht ob du zu hause einrückungen machst, oder ob sie nur durchs Forum weg sind. Aber die sind extrem wichtig, gerade wenn die Programme größer werden. Wenn du Code im forum einspielst wickel einfach

drum, dann bleiben Einrückungen vorhanden und du bekommst lustige Farben.

Bei deinem zweiten Versuch für Bsp. 3 fehlen dir übrigens die " " bei den Strings.

Zitat von anpro

int Matrikelnummer=h0024664;

das klappt natrülich nicht, weil "h" keine zahl ist

Hmm.. Wo soll ich anfangen? Hast du irgendein Skriptum zum Programmieren mit Beispielen bekommen? Weil bis auf die Tatsache, dass du eine Schleife benutzt, passt leider an dem Programm nicht viel.

Ich würde dir das openbook Java ist auch eine Insel nahe legen, dort sind die grundlegenden Progammiermethoden recht einfach beschrieben.

ad Bsp 1:
Hier mal dein Code (ein wenig nachformatiert):

public class schleife1 {
    public static void main (String[]args) {
        int zielWert = 10;

        for (int i=10000;i<=zielWert;i++) {
            System.out.println(i + " mit 5% verzinst ergibt: " + (i++));
        }
    }
}

Ich erklär dir mal was dein Programmcode macht und was er eigentlich machen sollte.

Als erstes initalisierst du eine Ganzzahl zielWert mit dem Wert 10. (int zielWert = 10;)
Danach öffnest du eine Schleife die mit der Ganzzahl i=10000 intitialisiert wird, die Zahl i wird bei jedem Schritt um 1 erhöht und die Schleife endet wenn i <= zielWert ist, d.h. wenn i einen Wert von 10 oder größer erreicht. D.h. du kommst nie in die Schleife!

Im inneren der Schleife gibst du jeden Wert von i aus sowie erhöhst du i nochmals um 1 (d.h. insgesamt um 2).
Würde die Schleife also durchlaufen, würde die Ausgabe wie folgt lauten:
10000 mit 5% verzinst ergibt: 10002
10002 mit 5% verzinst ergibt: 10004
10004 mit 5% verzinst ergibt: 10006

Das ist offensichtlich nicht korrekt. Du programmierst hier ziemlich am Problem vorbei.

Was dein Programmcode machen soll:
Eine jährliche Verzinsung simulieren.

Das heißt du hast eine Zahl (zB. int kapital), die um 5% erhöht werden soll. Wobei sich die 5% Erhöhung durch neuesKapital = kapital * 1.05 berechnet. (Zinsrechnung wird eigentlich in jeder höheren Schule gelehrt, findest auch bei wikipedia, ..) Das ganze musst du 10 mal durchlaufen (Hinweis!), und bei jedem Durchlauf ausgeben, wie eben in der Angabe beschrieben.

zu Bsp 2 wurden bereits einige Tipps gegeben, aber ich denke es wäre wichtig, dass du erst einmal Bsp 1 verstehst...

damn, too slow...

benutz bitte die code-tags, wenn du code direkt postest, oder häng am besten ganze, testbare Dateien mit korrekter Benamsung an.

Stilistische Mängel:

• Klassen-Namen sollten englische Nomen sein, die möglichst gut beschreiben, was die Klasse darstellt und mit einem Großbuchstaben beginnen. z.B.: public class CompoundInterestCalculation { [...] } anstatt public class schleife1 { [...] }
• Variablennamen sollten auch englische Nomen sein, die allerings mit einem Kleinbuchstaben beginnen. Außer Konstanten (private/public static final ...), welche per Konvention immer zur gänze in Großbuchstaben zu schreiben sind. z.B.: int numberOfYears = 10; anstatt int zielwert = 10;
• Sowohl bei Klassen- als auch Variablennamen gilt, dass wenn du einen Namen aus mehreren Wörter (z.B. User Account Manager) zusammensetzt, du die einzelnen Silben mit Hilfe von Großbuchstaben kennzeichnen solltest. z.B.: UserAccountManager oder siehe oben.
• Kontrolliere die Anzahl Spitz-Klammern gleich beim Schreiben. Alleine bei deiner Klasse "schleife1" waren zwei Paar Klammern zu viel.
• Des weiteren empfiehlt es sich, durch Einrückung die verschiednen Code-Teile auszuzeichen. D.h. den Inhalt einer jeden Klasse, Methode, Schleife mittels Tabulator um eine Ebene weiter nach innen verschieben. Das hilft dir beim Erkennen der Zugehörigkeit der verschiedenen Anweisungen.
• Verwende am besten einen Editor mit Syntax-Highlighting (z.B.: JEdit wie er in EProg empfohlen wird), dann tust du dir schon wesentlich leichter mit den Klammern, etc.
• Wenn du Schwierigkeiten beim finden der passenden englischen Bezeichnungen hast, benütze ein Wörterbuch oder wende dich an dict.leo.org (so mach ich es immer, wenn mir Mal wieder ein Vokabel nicht einfällt)

In JAVA funktioniert es nicht, Strings mittels des Vergleichsoperators "==" zu vergleichen. Hier solltest du die Methode "equals()" Verwenden, die dir immer bei Strings zur Verfügung steht. Z.B.: so

public class Demonstration1 {
   public static void main(String []args) {
      String myString1 = "test";
      String myString2 = "test2";
      String myString3 = "test";


      System.out.println(myString1.equals(myString2)); // FALSE
      System.out.println(myString1.equals(myString3)); // TRUE
      System.out.println(myString3.equals("test2")); // TRUE
   }
}

Auch wenn ich jetzt vielleicht gehauen werd. Ich würd Eclipse empfehlen.

Es zeigt dir sofort was in deiner Syntax falsch ist/was fehlt. Aber ich glaub bei EPROG haben sie was gegen Eclipse..

Naja - das ist wie mit Kanonen auf Fliegen zu schießen. Du hast schon recht, Eclipse ist komfortabel und praktisch. ABER wenn du gerade erst programmieren lernst, erschlägt dich der Funktionsumfang schon ziemlich. Vorallem, weil dir Eclipse einen Haufen Arbeit abnimmt, die du eigentlich zumindest einmal machen solltest, um zu verstehen, wie die Dinge funktionieren

Ja das mag sein. Nur ich hab Eprog im Editor gemacht, und ich hab programmieren nie so gehasst wie damals

Wie gesagt. gerade bei den Fehlern die jetzt drin waren, hat eclipse halt den Vorteil dass es dir sagt was falsch ist.

Z.B dass man ein Int nicht mit 0.05 multiplizieren kannst
oder dass ein Int keinen Char verträgt. oder dass ein String "" braucht.

und Klammernvervollständigung is auch was schönes

Und die Fliegen sind dann 100%ig tot

Edit:

Muss dir übrigens widersprechen. Ich hab:

class Matrikelnummer {


public static void main(String[] arguments){


String Matrikelnummer= "h9943253";




if (Matrikelnummer== "h0024664")
System.out.println("true");
else
if (Matrikelnummer == "h9943253")
System.out.println("wrong");
else
if (Matrikelnummer == "h0343453" )
System.out.println("wrong");
}


}

laufen lassen, und es klappt. Hat mich auch verwundert.

Ernsthaft? Das war mir bis jetzt nicht bekannt - ich habe damit immer Fehlermeldungen erhalten. Freut mich. Damit ist das umständliche Java etwas komfortabler geworden...

Zitat von myAces

H
Als erstes initalisierst du eine Ganzzahl zielWert mit dem Wert 10. (int zielWert = 10;)
Danach öffnest du eine Schleife die mit der Ganzzahl i=10000 intitialisiert wird, die Zahl i wird bei jedem Schritt um 1 erhöht und die Schleife endet wenn i <= zielWert ist, d.h. wenn i einen Wert von 10 oder kleiner erreicht. --> i wird niemals kleiner als 10 werden --> Endlosschleife!

Kleine Anmerkung: Endlosschleife wird das nicht, er geht nicht mal in die Schleife, da die Zählervariable von haus aus größer ist als die Abbruchbedingung. Auch bricht die schleife bei i <= 10 nicht ab wenn i kleiner 10 ist, sondern erst wenn i auf 11 geht.

Zitat von Pannonian

Kleine Anmerkung: Endlosschleife wird das nicht, er geht nicht mal in die Schleife, da die Zählervariable von haus aus größer ist als die Abbruchbedingung. Auch bricht die schleife bei i <= 10 nicht ab wenn i kleiner 10 ist, sondern erst wenn i auf 11 geht.

:horror: Was für ein arger Fehler von mir. Danke! Sofort ausgebessert.

Zitat von Paulchen

Vielleicht verwaltet der Java Compiler gleiche Zeichenkettenkonstanten in einer Datei als ein Objekt.

Tut er wohl, alles andere waere Platzverschwendung im class-File. (Obs eine offizielle Garantie gibt, ist eine andere Frage.) Man beachte an dieser Stelle auch, dass die Klasse String eleganterweise keine Methoden zur Verfuegung stellt, um ein konkretes String-Objekt zu veraendern. Damit kann es nicht zu Problemen fuehren, wenn mehrere Referenzen auf denselben konstanten String zeigen.

Zitat von Paulchen

Woran es liegt, dass

PHP

String abc="a";
String def=new String("a");
System.out.println(abc==def);

funktioniert, weiß ich nicht genau. Vielleicht verwaltet der Java Compiler gleiche Zeichenkettenkonstanten in einer Datei als ein Objekt.

Was heißt funktioniert? Bei mir (Sun javac 1.6.0_03) gibt dieser Code wie erwartet "false" aus.

Zitat von Plantschkuh!

Tut er wohl, alles andere waere Platzverschwendung im class-File. (Obs eine offizielle Garantie gibt, ist eine andere Frage.) Man beachte an dieser Stelle auch, dass die Klasse String eleganterweise keine Methoden zur Verfuegung stellt, um ein konkretes String-Objekt zu veraendern. Damit kann es nicht zu Problemen fuehren, wenn mehrere Referenzen auf denselben konstanten String zeigen.

Das "a" ist im Classfile dasselbe, nur wird in der zweiten Zeile damit ein neues Objekt erzeugt, was über den Daumen 7 Byte kostet. Ist zwar auch nicht nichts, aber dafür das, was der Programmierer hingeschrieben hat, inklusive Zerstörung der Identität der Objekte.

Zitat von Java Language Specification

While == may be used to compare references of type String, such an equality test determines whether or not the two operands refer to the same String object. The result is false if the operands are distinct String objects, even if they contain the same sequence of characters. The contents of two strings s and t can be tested for equality by the method invocation s.equals(t).

Zitat von Paulchen

Mein Fehler. Ich meinte eigentlich Folgendes:

PHP

String abc="a";
String def="a";
System.out.println(abc==def);

Auch das ist in der Java Language Specification genau so definiert. Nicht alles ist intuitiv bzw. gut gelöst in Java, aber zumindest ist mir kein Fall bekannt, zu dem es keine Spezifikation gäbe. (Nebenbemerkung: Das Java Memory Model ist kaputt und auf einigen Intel Architekturen nicht implementierbar, aber wie gesagt, es gibt zumindest etwas.)

Java ist doch eine Halbinsel!

Zitat von jeuneS2

Das Java Memory Model ist kaputt und auf einigen Intel Architekturen nicht implementierbar, aber wie gesagt, es gibt zumindest etwas.)

Wieso das? Und welche Intel-Architekturen meinst du?

Ich hab mich in den letzten Monaten im Zuge meiner Diplomarbeit recht intensiv damit beschäftigt, und mir ist jetzt nichts bewusst, was auf Intel wirklich ein Problem wäre. Und das JMM ist beeindruckend gut durchdacht (da haben sich ja auch ziemlich viele Leute ziemlich lang den Kopf darüber zerbrochen…). In Bezug auf die Zulässigkeit mancher Compilertransformationen herrscht nicht 100% Einigkeit bzw. Zufriedenheit, aber sonst ist das JMM ein Meisterstück ;).

Die einzige Mainstream-Architektur, auf der es wirklich schwierig zu implementieren ist, ist Alpha; und die ist am Aussterben.

Simples Reordering kann das JMM verletzen (siehe Sevcik and Aspinall, On Validity of Program Transformations in the Java Memory Model, Seite 5), und z.B. Itanium macht das in Hardware. Ich rudere insofern zurück, dass das JMM wahrscheinlich nur sehr ineffizient zu implementieren wäre.

Ja ok, das Paper kenne ich. Das war das, was ich mit der Uneinigkeit über Compilertransformationen gemeint habe.

Ad Itanium - interessant; habe mit dem Teil leider keine praktische Erfahrung.