Java Scripts

.nAno · 12/02/2009, 21:45

Also, nachdem ich mich mit AutoIT befasst hab wollte ich mich jetzt mal an was "richtiges" wagen, soll heißen meiner erste Programmiersprache und dabei ist meine Wahl auf Java gefallen

So und, da ich bei AutoIT gut mit diesem System vorangekommen binn wollt ich nun auch hier mal nach euren Java scripts fragen, ich denke so lernt man am besten die neuen Befehle und Eigenschaften einer Sprache

(und das vor allem schön praxisbezigen

)

Also ich freu mich über eure Beiträge

(und da mein Stand bei "Hello World!" liegt, freu ich mich auch über Anfänger Programme

)

Greetz nAno

^darkwing · 12/02/2009, 21:57

PHP Code:


			
class Rechner
{
    public static void main(String args[])
    {
        try
        {
            System.out.println(args[0]+args[1]+args[2]);
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            System.out.println("Drei Parameter angeben!");
            System.exit(1);
        }

        float wert1,wert2;
        char oper;
        /*wert1 = Integer.parseInt(args[0]);
        wert2 = Integer.parseInt(args[2]);*/
        wert1 = Float.valueOf(args[0]).floatValue();  //String zu Float
        wert2 = Float.valueOf(args[2]).floatValue();    
        oper = args[1].charAt(0);
        //System.out.println(oper);
        switch(oper)
        {
        case '+': System.out.println(wert1+ "+" +wert2+ " = " + (wert1+wert2));break;
        case '-': System.out.println(wert1+ "-" +wert2+ " = " + (wert1-wert2));break;
        case 'X': System.out.println(wert1+ "*" +wert2+ " = " + (wert1*wert2));break;
        case ':': System.out.println(wert1+ ":" +wert2+ " = " + (wert1/wert2));break;
        }
    }
}

Ein kleiner Rechner, war mein Anfang in Java.

.nAno · 12/02/2009, 22:01

Thx^^, schnellste Hilfe ever xD

Adroxxx · 12/02/2009, 22:03

Java ist nicht Java script.

Und die teile die du mit java erstellst sind auch keine scripts sondern meistens Klassen oder Applikationen.

Hier mal einige leicht verständliche Klassen:

Spoiler

PHP Code:


			
/**
 * Klasse Stromrechnung für die Berechnung des Betrages,
 * eines Jahresverbrauchs (in kWh).
 */

public class Stromrechnung {

    /**
     * Main Methode für die Berechnung und Ausgabe des Jahresbetrages.
     * @param args wird nicht verwendet
     */
    public static void main(String[] args) {

        /**
         * Variablendeklaration
         * Jahresverbrauch in kWh.
         * Grundpreis in Euro.
         * Verbrauchsreis in Cent.
         * Jahreskosten für Tarif 1 und 2.
         */
        int      jahresverbrauch;
        double   grundpreis, verbrauchspreis, betrag1, betrag2;

        /*
         * Variableninitialisierung für Tarif 1.
         */
        jahresverbrauch = 2965;
        grundpreis = 5.75;
        verbrauchspreis = 17.89;

        /**
         * Berechnung der Kosten für 1 Jahr und Runden des Ergbnisses.
         */

        /* Verbrauchspreis in Cent * den Jahresverbrauch / 100 um auf Euro
         * zu kommen.
         * Das Ergebnis von Verbrauchspreis * 100 + 0.005 wird nach int
         * gecastet. Durch die * 100 verschiebt sich das Komma um 2 stellen.
         * Durch die + 0.005 wird der Kommawerd aufgerundet. Und durch das
         * casten auf int werden die restlichen kommastellen abgeschnitten.
         * Das wird dann durch 100 gerechnet und nach double gecastet.
         * Dies bewirkt, dass die Zahl wieder zu einer Kommazahl wird und das
         * Komma verschiebt sich um 2 Stellen zurück und wir erhalten eine
         * Kommazahl mit 2 Nachkommastellen.
         */
        verbrauchspreis = (verbrauchspreis * jahresverbrauch) / 100;
        verbrauchspreis = (double) (int) ((verbrauchspreis + 0.005) * 100)
                          / 100;

        /* Grundpreis pro Monat wird mit 12 Multipliziert ( 12 Monate = 1 Jahr)
         * Restliche Berechnung und Rundung wie oben beschrieben.
         */
        grundpreis = grundpreis * 12;
        grundpreis = (double) (int) ((grundpreis + 0.005) * 100) / 100;

        /*
         * Verbrauchspreis und Grundpreis für 1 Jahr werden Addiert und in
         * die Variable betrag1 geschrieben der für den Tarif 1 gilt.
         */
        betrag1 = verbrauchspreis + grundpreis;


        /*
         * Variableninitialisierung für Tarif 2.
         */
        jahresverbrauch = 2965;
        grundpreis = 9.85;
        verbrauchspreis = 16.24;

        /*
         * Berechnung der Kosten und runden. Wie oben beschrieben.
         */
        verbrauchspreis = (verbrauchspreis * jahresverbrauch) / 100;
        verbrauchspreis = (double) (int) ((verbrauchspreis + 0.005) * 100)
                           / 100;

        grundpreis = grundpreis * 12;
        grundpreis = (double) (int) ((grundpreis + 0.005) * 100) / 100;

         /*
         * Verbrauchspreis und Grundpreis für 1 Jahr werden Addiert und in
         * die Variable betrag2 geschrieben der für den Tarif 2 gilt.
         */
        betrag2 = verbrauchspreis + grundpreis;

        /*
         * Ausgabe des kleinsten Betrags. Durch Bediengte Ausdrücke.
         * Wenn der Betrag des Tarifs 1 kleiner ist wie der des Betrags vom
         * Tarif 2, wird der betrag1 ausgegeben. Ansonsten betrag2.
         */
        System.out.println((betrag1 < betrag2)
                            ? betrag1
                            : betrag2);
    }
}

Spoiler

PHP Code:


			
/**
 * Die Klasse Zahlendarstellung soll zwei Zahlen in einem Zahlensystem
 * zu einer definierbaren Basis, addieren und das Ergebnis im gleichen
 * Zahlensystem auszugeben.
 * Es gibt insgesamt 5 Methoden.
 * Die Zahlen werden zuerst in das dezimalsystem umgewandelt und dann
 * addiert. Das Ergebnis wird dann wieder in das Zahlensystem mit der
 * Basis "basis" umgewandelt.
 */
public class Zahlendarstellung {

    /**
     * Die Methode wandleUm, wandelt die uebergebene zZahl von der
     * uebergebenen basis in das dezimalsystem.
     * @param ergebnis die umgewandelte Zahl im dezimalsystem
     * @param zahl die uebergebene zahl die umgewandelt werden soll
     * @param basis die basis des zahl die umgewandelt werden soll
     * @return zurueckgegeben wird die zahl im dezimalsystem
     */
    public static long wandleUm(long ergebnis, long zahl, int basis) {

       /* Hier wird die uebergebene Zahl in das dezimalsystem umgewandelt.
        * Die Bedingung ist, dass die Zahl groeßer 0 ist. Damit ist
        * sichergestellt, dass alle Ziffern durchlaufen werden.
        * Dann ruft sich die Methode rekusiv auf mit der Zahl geteilt durch 10.
        * Das ergebnis wird mit der Basis multipliziert und die Zahl Modulo 10
        * dazuaddiert.
        *
        * Durch das zahl modulo 10 wird immer die letzte Ziffer genommen und
        * zum Ergebnis das mit der Basis Multipliziert wurde, addiert.
        * Durch dadruch, dass die Rekusion mit zahl / 10 aufgerufen wird,
        * wird immer die letzte Ziffer abgeschnitten. Durch das abschneiden
        * durch das teilen und durch die restrechnung mit dem modulo, werden
        * alle ziffern durchgenangen addiert und mit zwei multiplziert.
        *
        * Wenn alle Ziffern durchgegangen wurden, wird das ergebnis zurueck
        * gegeben.
        */
        return (zahl > 0) 
                ? wandleUm(ergebnis, zahl / 10, basis) * basis + zahl % 10
                : ergebnis;  
    }

    /**
     * Diese Methode wandelt die Zahl wieder in vom dezimalsystem in das
     * urspruengliche Zahlensytem zurueck.
     * @param zahl die Zahl die ungewandelt werden soll
     * @param basis die basis
     * @return zurueckgegeben wird die Zahl im urspruenglichen Zahlensystem
     */
    public static long wandleZurueck(long zahl, int basis) {
        /*
         * Diese Methode wandelt eine Dezimalzahl in ein Zahlensystem
         * zu einer bestimmten Basis.
         *
         * Die Bedingung ist, dass die Zahl groeßer 0 ist, somit werden
         * alle Ziffern durchgegangen.
         *
         * Die Zahl wird Modulo die basis gerechnet. Der Rest ist dann die neue
         * Zahl.
         * Dann durch die Basis geteilt und nochmal modulo basis genommen,
         * dadurch kommt man an die naechste Zahl.
         * Die Multiplikation mit 10 ist da damit die stellen richtig sind.
         * Beispiel 2er System:
         * 12       % 2 = 0
         *  6(12/2) % 2 = 0 * 10
         *  3( 6/2) % 2 = 1 * 10 * 10
         *  1( 3/2) % 2 = 1 * 10 * 10 * 10
         *
         * Ergebnis 1100.
         */

         return (zahl > 0)
                 ? ((wandleZurueck(zahl / basis, basis) * 10) + zahl % basis)
                 : zahl;
    }

    /**
     * Diese Methode prueft die Gueltigkeit aller Ziffern. Die Ziffern muessen
     * echt kleiner sein als die Basis. Oder besser gesagt die Zahl muss
     * kleiner oder gleich b-1 sein.
     * @param zahl die gesamte zahl die zu pruefen ist
     * @param basis die basis des zahlensystems
     * @return zurueckgegeben wird entweder ja oder nein (true oder false)
     */
    public static boolean istGueltig(long zahl, int basis) {

        /* Diese Methode prueft ob die einzelnen Ziffern gueltig sind.
         * Als gueltig gelten sie, wenn sie echt kleiner sind als die basis.
         * Man koennte auch sagen wenn sie maximal gleich basis - 1 sind.
         *
         * Erst wird geprueft ob die Zahl modulo 10 kleiner ist wie die Basis.
         * Damit wird die hinterste Ziffer geprueft.
         * Wenn dieser Fall zutrifft, wird die Rekusion aufgerufen
         * mit der zahl / 10. Damit wird die letzte Stelle abgeschnitten und
         * dann wieder Modulo 10 genommen, somit wird die naechste Ziffern-
         * stelle ueberprueft.
         *
         * Wenn das stimmt wird der wahrheitswert true zurueckgegeben,
         * ansonsten false.
         */
         return ((zahl % 10) < basis)
                ? (zahl > 10)
                  ? istGueltig((zahl / 10), basis)
                  : true
                : false;

    }

    /**
     * Die Methode addiere, addiert zwei zahlen miteinander, die eine bestimmte
     * Basis haben. Falls eine der Ziffern ungueltig sein sollte, wird eine
     * -1 ausgegeben.
     * @param ersteZahl erste Zahlt die addiert werden soll
     * @param zweiteZahl zweite Zahl die addiert werden soll
     * @param basis basis des zahlensystems
     * @return zurueckgegeben wird die addierte zahl
     */
    public static long addiere(long ersteZahl, long zweiteZahl, int basis) {
        

        

        return (istGueltig(ersteZahl, basis) && istGueltig(zweiteZahl, basis))
                ? wandleZurueck(wandleUm(0, ersteZahl, basis)
                  + wandleUm(0, zweiteZahl, basis), basis)
                : -1;
    }

    /**
     * Die main Methode beinhaltet 11 Ausgabeanweisungen die testwerte
     * ausrechnen sollen um die Korrektheit der Klasse zu pruefen.
     * @param args wird nicht verwendet
     */
    public static void main(String[] args) {

        /*
         * Hier sind einige Testfaelle fuer Werte um die Addition
         * zu testen.
         */
        System.out.println(addiere(1001, 11, 2));
        System.out.println(addiere(11011, 1110, 2));
        System.out.println(addiere(210, 11, 2));
        System.out.println(addiere(773, 0, 8));
        System.out.println(addiere(0, 107, 8));
        System.out.println(addiere(773, 107, 8));
        System.out.println(addiere(773, 1239, 8));
        System.out.println(addiere(950, 192, 8));
        System.out.println(addiere(9145, 882, 10));
        System.out.println(addiere(11111111111L, 1, 2));
        System.out.println(addiere(323, 133, 4));
        
     }
}

.nAno · 12/02/2009, 22:06

Schon klar

Ich kenn den Unterschied und was man jetzt Programmiert, woher soll ich's wissen :P

Das Buch ist aufjedenfall was Wert

Adroxxx · 12/02/2009, 22:11

Ist auch noch for free.

.nAno · 12/02/2009, 22:34

noch besser

Ich freu mich trotzallem über weitere Scripts