[an error occurred while processing this directive]
Rheinland-Pfalz;
Informatik
Letzte Aktualisierung: 17.7.2009; Claus Schmitt
|
Startseite Informatik-Rheinland-Pfalz |
Mathematik-Applets
Thales
Pythagoras
Primzahlsieb
Physik-Applets
Fadenpendel
Fadenpendel
(durchgehend schwingend)
Newtons Wiege
Quellen
zurück
zur Java Startseite
Dies
Angebot ist noch in der Entwicklung:
|
I Den
Satz des Thales erfahren // Java-Applet Pythagoras // (Kathetensatz und Satz des Pythagoras) // Kompilierung mit J2SDK 1.6.0 // Walter Fendt // 25.10.1997 - 30.03.2009 // Reduzierung auf den Satz des Thales: // Experimentelles Entdecken (Grünfärben des Dreiecks bei rechtem Winkel) // Gründonnerstag - 20.04.2009 // C.Schmitt import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Thales extends JApplet implements MouseMotionListener { //-----------------------------------------------------------------------------
// Konstanten
//-----------------------------------------------------------------------------
final Color FZF = Color.yellow; // Hintergrundfarbe Zeichenfläche final Font SANSSERIF // Logischer Font = new Font("SansSerif",Font.BOLD,12); //-----------------------------------------------------------------------------
// Attribute
//-----------------------------------------------------------------------------
Zeichenfläche zf; // Zeichenfläche int breite, höhe; // Abmessungen (Pixel) int xm, ym; // Mittelpunkt des Thaleskreises int r; // Radius int r2; // Durchmesser int xa, xb ; // x-Koordinaten der Hypotenusen-Endpunkte Polygon dreieck; // Dreieck Color dreiecksFarbe; // jeweilige Dreiecksfarbe // (später rot / grün ) //-----------------------------------------------------------------------------
// Methoden
//-----------------------------------------------------------------------------
// Start-Methode:
public void start () {
Container cp = getContentPane(); // Container für Komponenten
cp.setLayout(null); // Hartes Layout (Pixelangaben)
Dimension dim = getSize(); // Abmessungen (aus HTML-Datei)
breite = dim.width; // Breite (Pixel)
höhe = dim.height; // Gesamthöhe (Pixel)
xm = breite / 2; // Koordinaten für
ym = höhe * 8 / 10; // Thaleskreis-Mittelpunkt
r = breite / 2 - 10; // Radius
r2 = 2*r; // Durchmesser
xa = xm - r; xb = xm + r; // End-x-Koordinaten der Hypotenuse
zf = new Zeichenfläche(); // Zeichenfläche
zf.setBackground(FZF); // Hintergrundfarbe Zeichenfläche
zf.setBounds(0,0,breite,höhe); // Position/Abmessungen Zeichenfläche
cp.add(zf); // Zeichenfläche hinzufügen
dreieck = neuesDreieck(); // Dreieck
dreiecksFarbe = Color.green; // Grüne Farbe für das rechtwinklige Start-Dreieck
setzenPunkt(0,xa,ym); // Endpunkte der Hypotenuse setzen (konstant)
setzenPunkt(1,xb,ym);
setzenPunkt(2,xm,ym-r); // Startscheitelpunkt setzen
// (geichschenkliges Thalesdreieck)
zf.repaint(); // Zeichenfläche neu zeichnen
zf.addMouseMotionListener(this); // Aufpasser für Mausbewegungen
}
// Erzeugung eines Dreiecks:
Polygon neuesDreieck () {
Polygon p = new Polygon(); // Neues Polygon (mit 0 Ecken)
for (int i=0; i<3; i++) // 3 Ecken hinzufügen
p.addPoint(0,0);
return p; // Rückgabewert (Referenz auf Polygon)
}
// Setzen eines Punktes (Dreiecksecke): // i ...... Index der Ecke // x, y ... Koordinaten void setzenPunkt (int i, int x, int y) {
dreieck.xpoints[i] = x;
dreieck.ypoints[i] = y;
}
// Reaktion auf Ziehen der Maus:
public void mouseMoved (MouseEvent me) {
int x = me.getX(), y = me.getY(); // Position des Mauszeigers
if (y > ym) y = ym; // Mauszeiger unterhalb der Hypotenuse
double dx = xm-x, dy = ym-y; // Koordinaten-Differenzen
// Maß für die Abweichung vom rechtwinkligen Dreieck
double diff = Math.abs(Math.sqrt(dx*dx+dy*dy)-r);
// Dreiecksfarbe festlegen
if (diff < 0.5)
dreiecksFarbe = Color.green;
else
dreiecksFarbe = Color.red;
setzenPunkt(2,x,y); // Scheitelpunkt setzen für Dreieck
zf.repaint(); // Neu zeichnen
}
// Nicht benötigte Methoden von MouseMotionListener:
public void mouseDragged (MouseEvent me){}
public void mouseEntered (MouseEvent me){}
public void mouseExited (MouseEvent me) {}
// ----------------------------------------------------------------
// Innere Klasse Zeichenfläche:
class Zeichenfläche extends JPanel {
public void paint (Graphics g) {
super.paint(g); // Hintergrund zeichnen
g.setColor(dreiecksFarbe); // Dreieck ausfüllen g.fillPolygon(dreieck); g.setColor(Color.black); // Ränder zeichnen g.drawArc(xm-r,ym-r,r2,r2,0,180); // Thaleskreis zeichnen // Halbkreise für zwei weitere Radien zeichnen, // um Thaleskreis besser zu betonen int rr, d; // Hilfsgrößen dafür rr = r - 1; d = 2*rr; g.drawArc(xm-rr,ym-rr,d,d,0,180); rr = r + 1; d = 2*rr; g.drawArc(xm-rr,ym-rr,d,d,0,180); // Dreieckseiten zeichnen g.drawPolygon(dreieck); g.setFont(SANSSERIF); // Header g.drawString("Dreieck mit der Maus erfahren",breite/3,40); // Copyright-Hinweis g.drawString("© W. Fendt 1997",50,höhe-20); g.drawString("reduziert von C. Schmitt 2009",50,höhe-7); } } // Ende Zeichenfläche
} // Ende Thales
. |
Satz des Pythagoras // Java-Applet Thales
// Kathetensatz und Satz des Thales
// Kompilierung mit J2SDK 1.6.0
// Walter Fendt
// 25.10.1997 - 30.03.2009
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Pythagoras extends JApplet implements MouseMotionListener {
//-----------------------------------------------------------------------------
// Konstanten
//-----------------------------------------------------------------------------
final Color FZF = Color.yellow; // Hintergrundfarbe Zeichenfläche final Color FARBE_DREIECK = Color.green; // Farbe für Dreieck final Color FARBE_RE = Color.blue; // Farbe für rechte Seite final Color FARBE_LI = Color.red; // Farbe für linke Seite final int XM = 200, YM = 150; // Mittelpunkt des Thaleskreises final int R = 50, R2 = 2*R; // Radius und Durchmesser final int XA = XM-R, XB = XM+R; // Endpunkte der Hypotenuse final Font SANSSERIF // Logischer Font = new Font("SansSerif",Font.BOLD,12); //-----------------------------------------------------------------------------
// Attribute
//-----------------------------------------------------------------------------
Zeichenfläche zf; // Zeichenfläche int breite, höhe; // Abmessungen (Pixel) int x0, y0; // Scheitel des rechten Winkels Polygon dreieck; // Dreieck Polygon quadratLinks, quadratRechts; // Quadrate //-----------------------------------------------------------------------------
// Methoden
//-----------------------------------------------------------------------------
// Start-Methode:
public void start () {
Container cp = getContentPane(); // Container für Komponenten
cp.setLayout(null); // Hartes Layout (Pixelangaben)
Dimension dim = getSize(); // Abmessungen (aus HTML-Datei)
breite = dim.width; // Breite (Pixel)
höhe = dim.height; // Gesamthöhe (Pixel)
zf = new Zeichenfläche(); // Zeichenfläche
zf.setBackground(FZF); // Hintergrundfarbe Zeichenfläche
zf.setBounds(0,0,breite,höhe); // Position/Abmessungen Zeichenfläche
cp.add(zf); zf.repaint(); // Zeichenfläche hinzufügen und neu zeichnen
dreieck = neuesPolygon(3); // Dreieck
quadratLinks = neuesPolygon(4); // Kathetenquadrat links
quadratRechts = neuesPolygon(4); // Kathetenquadrat rechts
x0 = (int)(XM-0.6*R); // Scheitel des rechten Winkels,
// x-Koordinate
y0 = (int)(YM-0.8*R); // Scheitel des rechten Winkels,
// y-Koordinate
zf.addMouseMotionListener(this); // Aufpasser für Mausbewegungen
}
// Erzeugung eines Polygons: // n ... Zahl der Ecken Polygon neuesPolygon (int n) {
Polygon p = new Polygon(); // Neues Polygon (mit 0 Ecken)
for (int i=0; i<n; i++) // n Ecken hinzufügen
p.addPoint(0,0);
return p; // Rückgabewert (Referenz auf Polygon)
}
// Setzen eines Punktes (Polygonecke): // p ...... Polygon // i ...... Index der Ecke // x, y ... Koordinaten void setzenPunkt (Polygon p, int i, int x, int y) {
p.xpoints[i] = x; p.ypoints[i] = y;
}
// Aktualisierung der Polygone: // Die Ecken des rechtwinkligen Dreiecks und der beiden Kathetenquadrate // werden an die neuen Werte von x0 und y0 (Scheitel des rechten Winkels) // angepasst. void setzenPolygone () {
setzenPunkt(dreieck,0,XA,YM); // Dreieck
setzenPunkt(dreieck,1,XB,YM);
setzenPunkt(dreieck,2,x0,y0);
int dx = x0-XA, dy = YM-y0; // Hilfsgrößen
setzenPunkt(quadratLinks,0,XA,YM); // Linkes Kathetenquadrat
setzenPunkt(quadratLinks,1,x0,y0);
setzenPunkt(quadratLinks,2,x0-dy,y0-dx);
setzenPunkt(quadratLinks,3,x0-dy-dx,YM-dx);
dx = XB-x0; dy = YM-y0; // Hilfsgrößen ändern
setzenPunkt(quadratRechts,0,x0,y0); // Rechtes Kathetenquadrat
setzenPunkt(quadratRechts,1,XB,YM);
setzenPunkt(quadratRechts,2,XB+dy,YM-dx);
setzenPunkt(quadratRechts,3,x0+dy,y0-dx);
}
// Reaktion auf Ziehen der Maus:
public void mouseDragged (MouseEvent me) {
int x = me.getX(), y = me.getY(); // Position des Mauszeigers
if (y > YM) y = YM; // Mauszeiger unterhalb der
// Hypotenuse
double my = Math.atan2(YM-y,x-XM); // Mittelpunktswinkel
x0 = (int)Math.round(XM+R*Math.cos(my)); // Neuer Scheitel
y0 = (int)Math.round(YM-R*Math.sin(my));
zf.repaint(); // Neu zeichnen
}
// Nicht benötigte Methoden von MouseMotionListener:
public void mouseMoved (MouseEvent me) {}
public void mouseEntered (MouseEvent me) {}
public void mouseExited (MouseEvent me) {}
// ---------------------------------------------------------------- // Innere Klasse Zeichenfläche: class Zeichenfläche extends JPanel {
public void paint (Graphics g) {
super.paint(g); // Hintergrund zeichnen
setzenPolygone(); // Polygone aktualisieren
g.setColor(FARBE_DREIECK); // Dreieck ausfüllen
g.fillPolygon(dreieck);
g.setColor(FARBE_LI); // Kathetenquadrat links ausfüllen
g.fillPolygon(quadratLinks);
g.fillRect(XA,YM,x0-XA,R2); // Rechteck links ausfüllen
g.setColor(FARBE_RE); // Kathetenquadrat rechts ausfüllen
g.fillPolygon(quadratRechts);
g.fillRect(x0,YM,XB-x0,R2); // Rechteck rechts ausfüllen
g.setColor(Color.black); // Ränder zeichnen
g.drawPolygon(quadratLinks);
g.drawPolygon(quadratRechts);
g.drawRect(XA,YM,x0-XA,R2);
g.drawRect(x0,YM,XB-x0,R2);
g.drawArc(XA,YM-R,R2,R2,0,180); // Thaleskreis zeichnen
g.setFont(SANSSERIF); // Copyright-Hinweis
g.drawString("© W. Fendt 1997",breite-120,höhe-20);
}
} // Ende Zeichenfläche
} // Ende Pythagoras
.
|
|
Primzahlsieb (vereinfachte Fassung)
// Java-Applet Primzahlen
// Primzahlentabelle
// Kompilierung mit J2SDK 1.6.0
// Walter Fendt
// 12.10.2003 - 01.04.2009
// Vorschläge zur didaktischen Reduzierung C.Schmitt; 16.7.09
// Das Applet zeigt eine Primzahlentabelle, die 1000 Zahlen umfasst. In jeder
// Tabellenzeile stehen 10 Zahlen.
// Da die Tabelle viel Platz einnimmt, wird sie in ein Rollbalkensystem
// (ScrollPane) eingebaut. Mithilfe der Rollbalken lässt sich der sichtbare
// Teilbereich der Tabelle auswählen. Bewegt man den Mauszeiger zu einer Zahl
// der Tabelle, so erscheint kurzzeitig die Aussage, dass es sich um eine
// Primzahl handelt, oder die Primfaktorenzerlegung der Zahl.
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Primzahlen extends JApplet
implements MouseMotionListener {
//-----------------------------------------------------------------------------
// Konstanten
//-----------------------------------------------------------------------------
final Color FZF = Color.yellow; // Hintergrundfarbe Zeichenfläche final Color FARBE_PRIM = Color.orange; // Farbe für Primzahlen final Color FSF = Color.green; // Hintergrundfarbe Schaltfläche final Font SANSSERIF // Logischer Font = new Font("SansSerif",Font.BOLD,12); final int HÖHE_TITEL = 40; // Höhe der Tabellenüberschrift (Pixel) final int BREITE_ZF = 1100; // Breite der Zeichenfläche (Pixel) final int HÖHE_ZF = 2001; // Höhe der Zeichenfläche (Pixel) final int HÖHE_RB = 320; // Höhe des Rollbalken-Systems (Pixel) final int HöHE_ZELLE = HöHE_ZF/100; // Höhe einer Tabellenzelle (Pixel) //----------------------------------------------------------------------------- // Attribute //----------------------------------------------------------------------------- boolean[][] prim; // Array mit Wahrheitswerten für Primzahl int breite, höhe; // Abmessungen des Applets (Pixel) JLabel lbTitel; // Tabellenüberschrift Zeichenfläche zf; // Zeichenfläche (Tabelle) JScrollBar scrH, scrV; // Rollbalken horizontal/vertikal int breiteZelle; // Breite einer Tabellenzelle (Pixel) //----------------------------------------------------------------------------- // Methoden //----------------------------------------------------------------------------- // Start-Methode:
public void start () {
Container cp = getContentPane(); // Container für Komponenten
cp.setLayout(null); // Hartes Layout (Pixelangaben)
prim = new boolean[100][10]; // Array mit Wahrheitswerten für Primzahl
updateFlags(); // Wahrheitswerte ermitteln
Dimension dim = getSize(); // Abmessungen (aus HTML-Datei)
breite = dim.width; // Breite (Pixel)
höhe = dim.height; // Gesamthöhe (Pixel)
lbTitel = new JLabel(titel()); // Tabellenüberschrift
lbTitel.setBackground(FSF); // Hintergrundfarbe
lbTitel.setOpaque(true); // Undurchsichtig
lbTitel.setBounds(0,0,breite,HÖHE_TITEL); // Position und Abmessungen (Pixel)
cp.add(lbTitel); // Tabellenüberschrift hinzufügen
breiteZelle = 42; // Breite einer Tabellenzelle (Pixel)
zf = new Zeichenfläche(); // Zeichenfläche für Tabelle
zf.addMouseMotionListener(this); // Aufpasser für Mausbewegungen
JScrollPane sp = new JScrollPane(zf); // Rollbalkensystem für Tabelle sp.setBounds(0,HÖHE_TITEL,breite,HÖHE_RB); // Position und Abmessungen (Pixel) sp.setHorizontalScrollBarPolicy( // Horizontaler Rollbalken immer sichtbar JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS); sp.setVerticalScrollBarPolicy( // Vertikaler Rollbalken immer sichtbar JScrollPane.VERTICAL_SCROLLBAR_ALWAYS); scrH = sp.getHorizontalScrollBar(); // Horizontaler Rollbalken scrV = sp.getVerticalScrollBar(); // Vertikaler Rollbalken updateRollbalken(); // Rollbalken anpassen cp.add(sp); // Rollbalkensystem (mit Inhalt) hinzufügen }
// Überschrift:
String titel () {
String s = " Primzahlentabelle ("; // Anfang der Überschrift (Zeichenkette)
s += "1 bis 1000"; // Überschrift ergänzen
return s; // Rückgabewert
}
//********************************************************************************** // Umsetzung der eigentlichen Mathematik // Kleinster Primfaktor:
// z ... Gegebene natürliche Zahl (größer als 1)
// Falls z nicht größer als 1 ist (Fehler), ist der Rückgabewert 0.
long kleinsterPrimfaktor (long z) {
if (z <= 1) return 0; // Fehler, da z > 1 nicht erfüllt
long t = 2; // Möglicher Teiler von z
while (t*t <= z) { // Teiler bis zur Wurzel aus z testen
if (z%t == 0) return t; // Bei Erfolg Teiler ausgeben
t++; // Andernfalls weitermachen
}
return z; // z ausgeben, da Primzahl
}
// Überprüfung der Primzahleigenschaft:
// z ... Gegebene natürliche Zahl
boolean istPrimzahl (long z) {
if (z <= 1) return false; // z <= 1, daher keine Primzahl
return (kleinsterPrimfaktor(z) == z); // Bedingung für Primzahl
}
// Aktualisierung der Wahrheitswerte für die Primzahleigenschaft:
void updateFlags () {
for (int i=0; i<100; i++) // Für alle 100 Tabellenzeilen
for (int j=0; j<10; j++) { // Für alle 10 Tabellenspalten
long z = 10*i+j+1; // Zahl in Tabellenzelle
prim[i][j] = istPrimzahl(z); // Wahrheitswert für Primzahleigenschaft
}
}
//*********************************************************************************
// Rollbalken aktualisieren:
void updateRollbalken () {
scrH.setUnitIncrement(breiteZelle); // Klick auf Pfeil (horizontal)
scrH.setBlockIncrement(2*breiteZelle); // Klick auf Rollbalken (horizontal)
scrV.setUnitIncrement(HÖHE_ZF/100); // Klick auf Pfeil (vertikal)
scrV.setBlockIncrement(HÖHE_ZF/10); // Klick auf Rollbalken (vertikal)
}
// ..........................................................................
// Reaktion auf Mausbewegungen:
// Falls sich der Mauszeiger innerhalb der Primzahltabelle befindet,
// wird an dieser Stelle für kurze Zeit ein Hinweis (ToolTip) eingeblendet.
// Dieser Hinweis enthält entweder die Aussage, dass eine Primzahl vorliegt,
// oder die Primfaktorenzerlegung.
public void mouseMoved (MouseEvent me) {
int x = me.getX(), y = me.getY(); // Position des Mauszeigers
boolean innerhalb = (x < 10*breiteZelle); // Position innerhalb der Tabelle?
long z = 10*(y/HÖHE_ZELLE)+x/breiteZelle+1; // Zahl in der Tabellenzelle
if (!innerhalb || z <= 1) { // Kein Hinweis nötig
zf.setToolTipText(null); return;
}
String s = ""+z; // Zahl in Zeichenkette umwandeln
long p = kleinsterPrimfaktor(z); z /= p; // Durch kleinsten Primfaktor teilen
if (z == 1) s += " ist eine Primzahl."; // Hinweistext für Primzahl
else s += " = "+p; // Hinweistext für Zerlegung (Beginn)
while (z > 1) { // Solange Zerlegung noch nicht beendet ...
p = kleinsterPrimfaktor(z); z /= p; // ... durch kleinsten Faktor teilen
s += " \u00b7 "+p; // ... Malpunkt und Faktor ergänzen
zf.setToolTipText(s); // Hinweistext festlegen
}
// Nicht benötigte Methode von MouseMotionListener:
public void mouseDragged (MouseEvent me) {}
// --------------------------------------------------------------------------
// Innere Klasse Zeichenfläche (Tabelle):
class Zeichenfläche extends JPanel {
// Konstruktor:
Zeichenfläche () {
setBounds(0,0,BREITE_ZF,HÖHE_ZF); // Position und Abmessungen (Pixel)
setBackground(FZF); // Hintergrundfarbe
}
// Grafik-Ausgabe: // g ... Grafik-Kontext public void paint (Graphics g) {
super.paint(g); // Hintergrund zeichnen
g.setFont(SANSSERIF); // Zeichensatz
FontMetrics fmH // Abmessungen Zeichensatz
= getFontMetrics(SANSSERIF);
g.setColor(Color.black); // Schriftfarbe schwarz
for (int i=0; i<100; i++) // Für alle 100 Zeilen
for (int j=0; j<10; j++) { // Für alle 10 Spalten
long z = 10*i+j+1; // Zahl in Tabellenzelle
if (prim[i][j]) { // Falls Primzahl ...
g.setColor(FARBE_PRIM); // ... Farbe für Primzahl
g.fillRect(j*breiteZelle,i*HÖHE_ZELLE,breiteZelle,HÖHE_ZELLE);
// ... Zelle einfärben
g.setColor(Color.black); // ... Farbe zurücksetzen
}
String s = ""+z; // Zahl in Zeichenkette umwandeln
int w = fmH.stringWidth(s); // Breite (Pixel)
g.drawString(s,(j+1)*breiteZelle-w-8,i*HÖHE_ZELLE+15);
// Zahl eintragen
}
int xRechts = 10*breiteZelle; // Rechter Rand der Tabelle (Pixel)
for (int i=0; i<=100; i++) { // Waagrechte Begrenzungslinien
int y = i*HÖHE_ZELLE; // y-Koordinate der Linie
g.drawLine(0,y,xRechts,y); // Linie zeichnen
}
int yUnten = 100*HÖHE_ZELLE; // Unterer Rand der Tabelle (Pixel)
for (int j=0; j<=10; j++) { // Senkrechte Begrenzungslinien
int x = j*breiteZelle; // x-Koordinate der Linie
g.drawLine(x,0,x,yUnten); // Linie zeichnen
}
}
// Bevorzugte Abmessungen der Zeichenfläche:
// Diese Methode wird vom Rollbalkensystem (ScrollPane) benötigt.
public Dimension getPreferredSize () {
return new Dimension(BREITE_ZF,HÖHE_ZF);
}
} // Ende Zeichenfläche
} // Ende Primzahlen
. |
| Physik-Applets vgl. |
|
Herrn
Walter
Fendt /
Paul-Klee-Gymnasium
Gersthofen / Fachlehrer für Mathematik / Physik / Informatik bin ich für hilfreichen Anregungen und die Überarbeitung der Applet-Quelltexte sehr dankbar. Außerdem danke ich für den kommentierten Quelltext der beiden Applets, welche er extra für diese ZUM-Seite neu überarbeitet hat! . |
|
Startseite Informatik-Rheinland-Pfalz |
