Programmiersprachen vergleichen durch einfache Programme

[Ynnus]

Hallöchen,

ich dachte mir, man könnte doch mal die verschiedensten Sprachen zusammenrufen und sie alle das selbe Programm erstellen lassen. Soll heißen, wir wählen ein Thema, etwas simples was man schnell machen kann, und jeder schreibt das ganze mal in seiner am liebsten benutzten Sprache. Das soll dem Zweck dienen, am Ende einen Vergleich aufstellen zu können, welche Sprache dafür am besten geeignet war, welcher Syntax am besten aussieht oder am besten angeordnet ist und sowas eben. Oder wie groß die EXE Datei zum Schluss dann ist.

Vorschlag meinerseits:

Wie wäre es zum Auftackt mit einer einfachen Übung - ein springender Ball im Bildschirm? (Nicht als Fensteranwendung sonder als Screen)
Das ist extra so einfach und ohne viel Spielraum gehalten (für den Anfang), damit man später besser vergleichen kann, wie viele Zeilen welche Programmiersprache benötigt hat, wie groß die EXE und ist und sowas eben.

Von daher, es sollten dann folgendes hier reingestellt werden:

- Die compilierte .exe Datei

- den dazugehörigen Sourcecode (Falls es sich dabei um eine Datei handelt, die nur mit bestimmten programmen geöffnet werden kann, dann bitte per Textdokument abspeichern, dass man den Syntax betrachten kann)

- Angaben zur benutzten Sprache, welche man verwendet hat

- Effektive Zeilen (ohne Kommentare oder Absätze)

- Gesamte Anzahl Zeilen (Alle Zeilen incl. Absätzen und Kommentaren)

...

So, das wäre mein Vorschlag. Hätte denn jemand Interesse, mitzumachen?
Oder gibt es noch Vorschläge zum Ablauf hier, oder neue Themen?

[Jesus_666]

1.) Das am weitesten verbreitet Beispielprogramm ist Hallo Welt. Es gibt bereits eine Seite, auf der diverse Sprachen anhand von HW miteinander verglichen werden (ich empfehle Brainfuck).

2.) Die Größe der kompilierten Datei ist abhängig vom Compiler (und seinen Einstellungen), dem System und der Implementierung. Wenig aussagekräftig.

3.) Das Verteilen von fertig kompilierten Programmen sollte nach Möglichkeit vermieden werden. Da kann man sich leicht was wegholen.

[Ineluki]

hm klingt soweit gut, jedoch waere ich nicht unbedingt fuer eine vollbildanwendung, da sowas mit manchen sprachen aeusserst unguenstig ist ... imho z.B bei Java ..

zudem sollte man noch sagen, ob und wenn ja, welche API genutzt werden soll ...

zudem sind graphikanwendingen sowieso ungeeignet, da fuer graphik vornehmlich API genutzt werden muss und API ist sowieso in jeder sprache groesstenteils gleich ...

ich waere ehr fuer ein Programm, das sich auf die grundlagen beschraenkt, z.B. einen Text ausgeben, zwei Zahlen von der Tastatur einlesen und dann das Produkt ausgeben

sozusagen ein etwas erweitertes Hallo Welt Programm

Gruss Ineluki

[Ynnus]

Jup, Hallo Welt kenn ich auch^^ Das war das erste was ich gemacht habe. Aber, ich dachte ja sowieso an mehrere Beispiele, nicht nur eines. Deshalb schlag ich vor, den Ball im Screen springen lassen, und als nächste Möglichkeit dann das Hallo Welt Programmchen...

3.) Das Verteilen von fertig kompilierten Programmen sollte nach Möglichkeit vermieden werden. Da kann man sich leicht was wegholen.

...

Wie genau ist das jetzt gemeint? Etwas abschauen oder so? Gut, aber man muss ja schlussendlich auch das Resultat begutachten, ob der Code denn überhaupt funktioniert. Somit muss zwangsweise eine exe Dabei sein. Außerdem, aus einem fertigen Programm kann man noch immer nicht den Syntax erkennen, wie etwas geschrieben wurde, und da sich die Sprachen ja auch schonmal unterscheiden, wird es noch schwerer dort etwas abzuschauen.

Programmgröße, nun ja, es macht schon einen Unterschied ob es nun 5 KB oder 200 KB sind oder? Und dann wählt man eben einen möglichst passenden compiler der es mit der besten Performance und Größe compiliert. Na ja, und man könnte noch die Größe des Sourcecodes nehmen, da ist ja ASCII Text, und könnte in einer einfachen TXT Datei verglichen werden.

Möchte denn jemand mitmachen?


EDIT: Ok, Luki, kein Problem. Eine Fensteranwendung könnt man auch machen. Wie wäre es dann (nach deiner Idee) mit einem Taschenrechner der die 4 Grundrechenarten beherscht? ( + | - | * | /)

Bei der API würde ich die WinAPI mit einschließen. Sonst könnte man noch Direct X oder open GL nehmen, aber die benötigt man ja eher bei Vollbildanwendungen... Ich denke mal, es steht erst einmal frei, welche API oder?

[Jesus_666]

Original geschrieben von Sunny
Wie genau ist das jetzt gemeint? Etwas abschauen oder so?

...

Ich bezog mich eher darauf, daß man sich einen Virus einfangen könnte. Es braucht dazu nur zwei Rechner mit nicht ganz aktueller Antivirensoftware...
Es bleibt das Problem, daß fertige Binaries (abgesehen von der Frage, ob das Programm überhaupt funktioniert) kaum aussagekräftig sind. Die Größe einer Binary hängt von unzähligen Faktoren ab (zu der oben genannten Liste will ich an dieser Stelle noch das Betriebssystem hinzufügen).

APIs sollte man nach Möglichkeit vermeiden... Es gibt einfach zu viele Möglichkeiten. Ein Programm, das versucht, direkt mit X zu interfacen wird unglaublich kompliziert aussehen, obwohl der meiste Code nur für X draufgeht.

Den einfachen, konsolenbasierten Rechner halte ich für eine gute Idee. Vielleicht könnte man ihn noch um ein paar Funktionen erweitern (Potenzen und Quadratwurzeln gehören zum Standardrepertoire der meisten (höheren) Sprachen).

[Ynnus]

hm, na ja, wenn ich aber das Fenster genau mittig des Desktops platzieren will, kann ich doch über die WinAPI die Auflösung abfragen und das dadurch machen... Es sieht vielleicht komplexer aus, aber das ist es ja dann auch^^
Also die WinAPI halte ich in machen fällen schonmal für nützlich, bei einem so simplen Programm ansich noch nicht so sehr, aber auch Kleinigkeiten kann man dort ja nutzen. (Fenstertext oder Icon ändern, wobei das ja nur kleine Spielerei ist)... Ach ja, ich meinte mit Rechner eigentlich nich den Konsolenbasierenden, sonder eine Fensteranwendung... Für was wären denn die Anderen?

Hm, aber irgendwie muss man die Programme ja dann doch testen, also mit EXE... Dann schlage ich vor, die exen hochzuladen, und ich teste sie auf Viren durch und stelle mich als Tester bereit. Ich sag euch aber schonmal gleich, wer mir hier die Platte löscht, dem bin ich ehrlich böse!^^

So, ja dann machen wir doch zu Beginn mal einen Taschenrechner. Mit den 4 Rechenarten (wahlweise + quadrat und Quadratwurzel.)

[Ineluki]

So hier das Erste Beispiel in der Consolenvariante von Delphi .. sozusagen Turbo Pascal aequivalent

Eine GUI Variante wird noch nachgeliefert ... das sieht dann GANZ anders aus

Code:

program Rechner;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var z1,z2:real;
    op:string;

begin
 Writeln('Hallo Welt.');
 Write('Bitte erste Zahl eingeben: '); readln(z1);
 Write('Bitte zweite Zahl eingeben: '); readln(z2);
 repeat
   Write('Bitte Operation waehlen + - * / ');readln(op);
 until (op='+') or (op='-') or (op='*') or (op='/');
 if op='+' then Writeln(z1,' + ',z2,' = ',z1+z2);
 if op='-' then Writeln(z1,' - ',z2,' = ',z1-z2);
 if op='*' then Writeln(z1,' * ',z2,' = ',z1*z2);
 if op='/' then Writeln(z1,' / ',z2,' = ',z1/z2);
 Writeln('Danke fuer die Benutzung. Zum Beenden Enter druecken.');
 readln;
end.

und hier die Exe dazu -> ftp://ftp.uni-freiburg.de/incoming/delphi/rechner.exe 42Kb

Natuerlich hab ich jetzt auf Fehlerbehandlung und Eingabeueberpruefung verzichtet .. sollte das gewuenscht sein, liefere ich das natuerlich gerne nach ^^

So ich liefer nun die GUI version nach ...

Code:

unit RechnerGUI;

interface

uses
 SysUtils, Forms, Classes, Controls, StdCtrls;

type
  TForm1 = class(TForm)
    EdZ1: TEdit;
    EdZ2: TEdit;
    EdErg: TEdit;
    Btnplus: TButton;
    BtnMal: TButton;
    BtnMinus: TButton;
    BtnDurch: TButton;
    procedure BtnClick(Sender: TObject);
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.BtnClick(Sender: TObject);
var z1,z2,erg:real;
    error:integer;
    noerror: Boolean;
begin
 if Sender is TButton then
  begin
   val(EdZ1.Text,z1,error); // Text in Zahl umwandeln
   noerror:=(error=0);      // Trat Fehler auf ?
   if (error<>0) then application.MessageBox('Zahl1 ist keine Zahl','Fehler');

   val(EdZ2.Text,z2,error);
   noerror:=noerror and (error=0); // War Fehler oder ist Fehler
   if (error<>0) then application.MessageBox('Zahl2 ist keine Zahl','Fehler');

   if noerror then begin
                    if TButton(Sender).Caption='+' then erg:=z1+z2;
                    if TButton(Sender).Caption='-' then erg:=z1-z2;
                    if TButton(Sender).Caption='*' then erg:=z1*z2;
                    if TButton(Sender).Caption='/' then erg:=z1/z2;
                    EdErg.Text:=format('%1.5f',[erg]);
                   end;
  end;
end;

end.

Natuerlich muss man nicht den ganzen code schreiben .. das meisste uebernimmt die Visuelle Umgebung ^^ ... und hier ist natuerlich eine Ueberpruefung dabei, ob das Eingegebene auch wirklich Zahlen sind.

und zum austesten auch hier die Exe -> ftp://ftp.uni-freiburg.de/incoming/d...rechnergui.exe 365 Kb -> Auch wegen den beinhalteten Cursor und Icongraphiken ... ist ja GUI

[Ynnus]

So, also Lukis exen sind Virenfrei^^

Aber nun meine:

Den Sourcecode gibts hier: (*.txt)
http://derfeind2k.de/daten/rechner.txt

Die Exe dazu gibts hier:
http://derfeind2k.de/daten/rechner.exe

-----
[edit] Neue Version hochgeladen. Mit dem kleinen Kasten unter der Anzeige kann man den Rechner wieder auf 0 setzen.
[/edit]
-----

Code:

Sprache:  Purebasic

*Effektive Zeilen:  155

**Gesamte Zeilenanzahl:  193

Größe des Source in KB:  4,39 KB

Größe der Exe in KB:  16,00 KB (extra incl. selfmade-Icon)

API:  WinAPI
---------
* Zeilen ohne Kommentare und Absätzen
** Alle Zeilen incl. Absätzen und Kommentaren

Ach ja, ich hab Quadrat und Wurzel vorerst nicht mit eingebaut, weil Luki das ja auch nicht getan hat.^^
Und Konsolenprogrammierung hab ich noch nie gemacht, daher nur eine Fensteranwendung.

So, ich hoffe es beteiligen sich noch ein paar Leutchen hier. Der Rechner kann auch noch einfacher aufgebaut sein, hauptsache die 4 Rechenarten sind dabei.
Erlaubt ist jede Sprache...

Ach, und bitte den Sourcecode nicht so wie Luki posten, dass macht alles so unübersichtlich. Besser wäre es, per *.txt Datei hochzuladen.

[Jesus_666]

So, ich habe das Ding mal mit C++/FLTK umgesetzt.

Weil es alles einfach einzubauen war, beherrscht das Teil die Fuktionen +, -, *, /, Potenzierung, Quadratwurzel und Modulo. Es hat sogar Tooltips.
Eingabeüberprüfung und Fehlerbehandlung sind schon eingebaut (entweder direkt bei C++ oder bei FLTK).

Das Programm basiert auf OpenGL und läßt sich auf jedem System kompilieren, auf dem OpenGL verfügbar ist.

Ich habe den Code in der FLTK-IDE (fluid version 1.0104) gemacht und nicht nachträglich verändert, deshalb ist er etwas unübersichtlich.

Der Sourcecode:
www.rpgmaker.info/temp/code/calc.cxx (Programm; 3,98 KiB)
www.rpgmaker.info/temp/code/calc.h (Header, 543 B)

Das Programm:
www.rpgmaker.info/temp/code/calc.exe (262 KiB)

Code:

                Sprache: ISO-konformes C++

       Effektive Zeilen: 108 (.cxx) + 18 (.h) = 126
   Gesamte Zeilenanzahl: 135 (.cxx) + 21 (.h) = 156

Größe des Source in KiB: 4,51 KiB
Größe der Binary in KiB: 262  KiB
         Art der Binary: Win32 Executable

                    API: OpenGL via FLTK

               Benötigt: FLTK, C++-Standardheader

               Compiler: gcc version 3.3.1 (cygming special)
         Kompiliert als: gcc -I/code/fltk-1.1.4/bin/include -mwindows -DWIN32 -mno-cygwin
                         -o calc calc.cxx /code/fltk-1.1.4/bin/lib/libfltk.a
                         -lole32 -luuid -lcomctl32  -lwsock32 -lsupc++ -O4

Anmerkung:
"Benötigt" beschreibt, was man alles installiert haben muß, um das Programm kompilieren zu können (oder ausführen, bei Interpretersprachen).
"Kompiliert als" gibt an, wie der Compiler aufgerufen wurde (wenn diese Angabe möglich ist).
"Art der Binary" ist hier nebensächlich und nur aus Gründen der unnötigen Vollständigkeit angegeben.
Alle "KB"-Angaben wurden durch das korrektere "KiB" ersetzt.

[Ineluki]

hm ... also wenn ich mir den codeunfang etc so ansehe ... da wuerd ich sagen, mit Delphi hat sich das am besten gemacht ^^

Was sagt ihr dazu ?

[Jesus_666]

Original geschrieben von Ineluki
hm ... also wenn ich mir den codeunfang etc so ansehe ... da wuerd ich sagen, mit Delphi hat sich das am besten gemacht ^^

Was sagt ihr dazu ?

...

Kommt drauf an.
Mit einer anderen API, bzw. einem anderen Toolkit oder als Konsolenapp wäre die C++-Version vielleicht Delphi gefährlich geworden; allerdings hatte ich da mit der Eingabe ein paar Probleme. Vielleicht mache ich noch eine Konsolenversion, mal sehen.

[Ineluki]

bei einem so einfachen problem kannst du den quellcode auch fast 1:1 uebernehmen und mit suchen und ersetzen die syntaxunterschiede ausgleichen und es wird laufen ....

die wichtigen unterschiede der sprachen zeigen sich meist erst, bei etwas komplexeren sachen

[Ynnus]

Gut, jetzt hat jeder mal einen Einblick in die Welt der anderen Sprache bekommen^^ Womit könnte man weiter machen? Das "hallo Welt" ist wohl etwas zuuuu einfach, als dass dort große Unterschiede wären. Jemand einen Vorschlag? Sonst könnte man nochmal auf den Springenden Punk im Screen zurückgreifen.

[Jesus_666]

Hier nun die Konsolenversion mit C++.
Operatoren sind + - * /, die Eingaben werden überprüft.

Das Programm läßt sich auf jedem System kompilieren, auf dem ein ISO-konformer C++-Compiler verfügbar ist.

Ich habe noch eine alternative Version geschrieben, die das mit dem Operator recht elegant mit einem switch erledigt.

Der Sourcecode:
www.rpgmaker.info/temp/code/ccalc.cxx (871 Byte)
www.rpgmaker.info/temp/code/ccalc.cxx (alternative Version; 817 Byte)

Das Programm:
www.rpgmaker.info/temp/code/ccalc.exe (415 KiB)

Code:

                Sprache: ISO-konformes C++

       Effektive Zeilen: 37 (alternativ: 48)
   Gesamte Zeilenanzahl: 44 (alternativ: 55)

Größe des Source in KiB: 871 Byte (alternativ: 817 Byte)
Größe der Binary in KiB: 415  KiB
         Art der Binary: Win32 Executable

                    API: keine

               Benötigt: C++-Standardheader

               Compiler: gcc version 3.3.1 (cygming special)
         Kompiliert als: gcc -mno-cygwin -o ccalc ccalc.cxx -O4

BTW, die Optimierung (-O4) hätte ich mir auch sparen können, hat eh nichts gebracht.

[Ineluki]

@Jeez ... also soo gefaellt mir dein Code schon viel besser ^^ .. aber haettest dui nicht while statt for(; verwenden koennen ? ^^

so und aus spass an der freude hab ich auch noch gleich das ganze mit dem springenden Ball im Fenster gemacht ... natuerlich alles ohne schnoerkel oder so ^^

ftp://ftp.uni-freiburg.de/incoming/delphi/ball.exe

Code:

unit Ball;

interface

uses
  SysUtils, Forms, Classes, Controls, StdCtrls, Graphics;

type
  TForm1 = class(TForm)
    Timer1: TTimer;
    procedure Timer1Timer(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
    x,y,dx,dy:integer;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Timer1Timer(Sender: TObject);
var nx,ny:integer;
begin
nx:=x+dx; ny:=y+dy;
if nx<=50 then begin nx:=50; dx:=-dx; end;
if nx>=form1.ClientWidth-50 then begin nx:=form1.ClientWidth-50; dx:=-dx; end;
if ny<=50 then begin ny:=50; dy:=-dy; end;
if ny>=form1.ClientHeight -50 then begin ny:=form1.ClientHeight-50; dy:=-dy; end;
form1.Canvas.Pen.Color:=form1.Color;
form1.Canvas.Ellipse(x-50,y-50,x+50,y+50);
x:=nx; y:=ny;
form1.Canvas.Pen.Color:=clblack;
form1.Canvas.Ellipse(x-50,y-50,x+50,y+50);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
randomize;
x:=51; y:=51;
repeat
dx:=(1-random(3))*random(3);
dy:=(1-random(3))*random(3);
until (dx<>0) and (dy<>0);
end;

end.

[Jesus_666]

Original geschrieben von Ineluki
@Jeez ... also soo gefaellt mir dein Code schon viel besser ^^ .. aber haettest dui nicht while statt for(;;) verwenden koennen

...

Ein unkonditionales while tut genau das Gleiche wie ein unkonditionales for. Es ist an sich relativ egal, was man nimmt.

[Reaperman]

Hier das Hallo Welt mal in perl

Code:

Sprache: perl
Effektive Zeilen: 21
Gesamte Zeilen: 23
Größe des QT: 624byte
Exe leider nicht verfügbar (Skriptsprache und keine Ahnung vom B-Modul)

Code:

#!perl

print "Hallo Welt.\n";
print "Bitte erste Zahl eingeben: ";
chomp($a = <STDIN>);
print "Bitte zweite Zahl eingeben: ";
chomp($b = <STDIN>);
do {
  print "Bitte Operation waehlen + - * / ";
  chomp($operator = <STDIN>)
} until $operator =~ /\+/ || $operator =~ /-/ || $operator =~ /\*/ || $operator =~ /\//;
if ($operator =~ /\+/) {
  $result = $a + $b
} elsif ($operator =~ /\*/) {
  $result = $a * $b
} elsif ($operator =~ /\//) {
  $result = $a / $b
} elsif ($operator =~ /\-/) {
  $result = $a - $b
}

print "$a $& $b = $result\nDanke fuer die Benutzung. Zum Beenden Enter druecken";
<STDIN>

[edit]Als kleines Goodie noch ein Programm, das eine Reihe von Dateien als Parameter nimmt und deren inhalt ausgibt:

Code:

#!perl

while (<>) {
  print
}

[/edit]

[Ineluki]

@Jeez .. ich weiss .. aber solche forausdruecke koennten unsere anfaenger abschrecken, weil es ueberhaupt nicht dem entspricht, wozu eigentlich eine forschleife urspruenglich da war .. naemlich etwas hochzaehlen

So und hier noch ein beispiel, wo die OOP sehr schoen zur Anwendung kommt ... das Ballbeispiel als Multiball mit 5 baellen .. viel spass dabei ... ich weiss, das konzept ist nicht ganz bugfrei .. aber was solls ^^ ... die physik dahinter: beim zusammenstoss zweier kugeln tauschen sie ihre impulse, sowohl in Betrag als auch Richtung

Source: ftp://ftp.uni-freiburg.de/incoming/delphi/multiball.txt
Executable: ftp://ftp.uni-freiburg.de/incoming/delphi/multiball.exe

Gruss Ineluki

[Master of Disaster]

Das Ganze in Java :

Code:

                 Sprache: Java

        Effektive Zeilen: 47 
Größe des Source in Byte: 1328
Größe der Binary in Byte: 2038
          Art der Binary: Java Bytecode

                     API: keine

                Benötigt: java.io.IOException, java.io.InputStreamReader

                Compiler: Blackdown JDK-1.4.1
          Kompiliert als: javac Main.java

Code:

import java.io.InputStreamReader;
import java.io.IOException;

public class Main {

  public static String readLine() {
    InputStreamReader isr=new InputStreamReader(System.in);
    char c;
    String line="";

    try {
      do {
        c=(char) isr.read();
        if (c!='\n') line = line+c;
      } while (c!='\n');
    } catch (IOException ex) {
    }
    return line;
  }

  public static void main(String[] args) {
    float z1,z2;
    String op="";
    char c;

    System.out.println("Hallo Welt.");
    System.out.print("Erste Zahl eingeben: ");
    z1=Float.parseFloat(readLine());
    System.out.print("Zweite Zahl eingeben: ");
    z2=Float.parseFloat(readLine());
    System.out.println(op);
    do {
      System.out.print("Bitte Operation waehlen + - * / ");
      op=readLine();
    } while ( !(op.equals("+") || op.equals("-") || op.equals("*") || op.equals("/")) );

    switch (op.charAt(0)) {
      case '+': System.out.println(z1+" + "+z2+" = "+(z1+z2)); break;
      case '-': System.out.println(z1+" - "+z2+" = "+(z1-z2)); break;
      case '*': System.out.println(z1+" * "+z2+" = "+(z1*z2)); break;
      case '/': System.out.println(z1+" / "+z2+" = "+(z1/z2)); break;
      default: break;
    }
    System.out.println("Danke fuer die Benutzung. Zum Beenden Enter druecken.");
    readLine();
  }
}

Testlauf:

Code:

fuero@bmfh classes $ java Main
Hallo Welt.
Erste Zahl eingeben: 23
Zweite Zahl eingeben: 56

Bitte Operation waehlen + - * / +
23.0 + 56.0 = 79.0
Danke fuer die Benutzung. Zum Beenden Enter druecken.

[MuadDib]

und das ganze als Java Swing-GUI

Code:

                 Sprache: Java

                  Zeilen: 83
Größe des Source in Byte: 2215
Größe der Binary in Byte: 2382 

                     API: keine

                Benötigt: ein paar Imports aus der javax.swing. und java.awt.

                Compiler: Sun J2SDK 1.4.2
          Kompiliert als: javac SwingCalc.java

Das Listing dazu:

Code:

/** import */
import javax.swing.JFrame;
import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.JLabel;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.*;

public class SwingCalc extends JFrame implements ActionListener
{
  JTextField first, second;
  JLabel result;

  public SwingCalc(String s)
  {
    super(s);
		
    /** inits */
		
    this.getContentPane().setLayout(new GridLayout(1,2));
		
    /** buttons */
    JPanel buttons = new JPanel();
    buttons.setLayout(new GridLayout(2,2));
		
    JButton add = new JButton("+");
    add.addActionListener(this);
    JButton sub = new JButton("-");
    sub.addActionListener(this);
    JButton mult = new JButton("*");
    mult.addActionListener(this);
    JButton div = new JButton("/");
    div .addActionListener(this);
		
    buttons.add(add);
    buttons.add(sub);
    buttons.add(mult);
    buttons.add(div);
		
    /** input panel */
    JPanel input = new JPanel();
    input.setLayout(new GridLayout(5,1));
    input.add(new JLabel("First number:"));
    first = new JTextField();
    input.add(first);
    input.add(new JLabel("Second number:"));
    second = new JTextField();
    input.add(second);
    result = new JLabel("Result");
    input.add(result);
		
    this.getContentPane().add(input);
    this.getContentPane().add(buttons);
  }
	
  public static void main(String args[])
  {
    SwingCalc s = new SwingCalc("SwingCalc 1.0");
    s.setSize(300,150);
    s.setVisible(true);
  }
	
  public void actionPerformed(ActionEvent e)
  {
    Object o = e.getActionCommand();
    float res = 0;
    try
    {
      if(o.equals("+"))
        res = Float.parseFloat(first.getText()) + Float.parseFloat(second.getText());
      else if(o.equals("-"))
	res = Float.parseFloat(first.getText()) - Float.parseFloat(second.getText());
      else if(o.equals("*"))
	res = Float.parseFloat(first.getText()) * Float.parseFloat(second.getText());
      else if(o.equals("/"))
	res = Float.parseFloat(first.getText()) / Float.parseFloat(second.getText());
      result.setText("Result: " + res);
    }
    catch(Exception ex) { result.setText("Error calculating..."); }
  }
}

Ein paar Anmerkungen:
Das ganze hat auch Exception Handling und fügt die benötigten Klassen einzeln hinzu, anstatt das gesamte Package... kostet aber auch nur ein paar Zeilen mehr.