Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
bin im moment etwas übervordert.
Ich soll den eingegebenen Text überprüfen oder er folgenes Format hat?
Die beiden TextFelder sind mJrfDateFrom und mJtfDateTo!
"tt.mm.jjjj"
So jetzt stell ich ich so blöd an, dass ich überhaupt nicht weis was ich machen solL?
Bitte könnt ihr mir weiterhelfen?
DANKE
MFG
MIKE
Code:
public ExportGuiSheets() {
// Designen und Erstellen der GUI
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setTitle("Excel-Exporter");
setSize(200, 140);
setLocation(500, 400);
// Panel in dem alle anderen Panels gehängt werden
JPanel mainPanel = new JPanel(new BorderLayout());
// Panel mit den Datumsfeldern
JPanel datumpanel = new JPanel(new GridLayout(1, 2));
JLabel label1 = new JLabel();
label1.setText("Von:");
JPanel vonPanel = new JPanel();
vonPanel.add(label1);
vonPanel.add(mJtfDateFrom);
datumpanel.add(vonPanel);
JLabel label2 = new JLabel();
label2.setText("Bis:");
JPanel bisPanel = new JPanel();
bisPanel.add(label2);
bisPanel.add(mJtfDateTo);
datumpanel.add(bisPanel);
// Panel mit den Button Exit und Speichern
JPanel exitclosepanel = new JPanel(new BorderLayout());
JButton bt01 = new JButton("Export");
bt01.setActionCommand("Export");
bt01.addActionListener(new PushButtonActionListener(this));
exitclosepanel.add(bt01, BorderLayout.WEST);
JButton bt02 = new JButton("Exit");
bt02.setActionCommand("Close");
bt02.addActionListener(new PushButtonActionListener(this));
exitclosepanel.add(bt02, BorderLayout.EAST);
mainPanel.add(datumpanel, BorderLayout.CENTER);
mainPanel.add(exitclosepanel, BorderLayout.SOUTH);
getContentPane().add(mainPanel);
setResizable(false);
setVisible(true);
}
Hi,
du weißt wie man einen InputVerifier verwendet? Du musst einfach nur eine neue Klasse von eben diesem ableiten und dort die Methode verify überschreiben:
Code:
class DateVerifier extends javax.swing.InputVerifier {
public boolean verify(JComponent input) {
// dein Code
}
}
Deine Textfelder haben eine Methode setInputVerifier, mit der du dann einfach eine Instanz dieser Klasse hinzufügen kannst.
Was du eigentlich in dieser Methode verify machen musst ist nur ein paar Kleinigkeit zu prüfen.
Schritt1 sollte sein, ob du ein TextField (oder was du verwendest) hast (sonst klappt das casten nicht).
Dann castest du in die entsprechende Klasse und liest den String aus, der dort eingetragen wurde.
Nun musst du nur noch schauen ob dieser ein gültiges Format hat. Als erstes kannst du ihn dazu mittels java.util.StringTokenizer zerlegen. Das Trennzeichen ist hier natürlich der Punkt.
Hast du jetzt ungleich 3 Token, so kann der String nicht das richtige Format haben.
Ja und der Rest ist dann testen der Token. Du kannst z.B. schauen ob die die richtige Länge haben (2, 2, 4) und dann ob die Werte zulässig sind.
Hi,
also ich hab mal ein wenig schönes BSP fertig gemacht. Ist nicht gerade das woran du dir ein Beispiel nehmen solltest, aber das ist ein anderes Thema (hab gerade keine IDE zur Hand).
Jedenfalls zeige ich dir hier kurz wie man einen InputVerifier verwendet. Du hast hier ein Frame mit zwei Eingabefeldern. Auf das obere wird der InputVerifier angewendet (analog für weitere Felder mit gleicher Beschränkung).
Wenn du jetzt etwas in das obere Feld eintippen möchtest, muss es die Form ??.??.???? haben (? ist dabei ein beliebiges Zeichen!). Ist dies nicht der Fall, kannst du nicht das andere Input-Feld verwenden. Der Fokus bleibt im oberen Feld.
Was hier natürlich für ein Datum fehlt ist die überprüfung, ob es gültige Zeichen sind, x1.aa.3847 ist sicherlich kein Datum, würde hier aber noch akzeptiert werden.
So nun der Code:
Code:
import javax.swing.JFrame;
import javax.swing.JTextField;
import javax.swing.InputVerifier;
import java.awt.BorderLayout;
import javax.swing.JComponent;
import java.util.StringTokenizer;
class MyInputVerifier extends InputVerifier {
private static final String DELIMITER = ".";
public boolean verify(JComponent component) {
if (component instanceof JTextField) {
String text = ((JTextField)component).getText();
StringTokenizer tokenizer = new StringTokenizer(text, MyInputVerifier.DELIMITER);
if (tokenizer.countTokens() != 3) {
return false;
}
// Tage ermitteln:
String buffer = tokenizer.nextToken();
if (buffer.length() != 2) {
return false;
}
// prüfen
// ...
// Monat ermitteln:
buffer = tokenizer.nextToken();
if (buffer.length() != 2) {
return false;
}
// prüfen
// ...
// Jahr ermitteln:
buffer = tokenizer.nextToken();
if (buffer.length() != 4) {
return false;
}
// prüfen
// ...
}
return true;
}
}
public class TestGUI extends JFrame {
public TestGUI() {
this.init();
}
public void init() {
this.jTextField1 = new JTextField();
this.jTextField1.setInputVerifier(new MyInputVerifier());
this.getContentPane().add(jTextField1, BorderLayout.NORTH);
this.jTextField2 = new JTextField();
this.getContentPane().add(jTextField2, BorderLayout.SOUTH);
this.setSize(200, 200);
//this.pack();
this.setVisible(true);
}
public static void main(String[] args) {
TestGUI gui = new TestGUI();
gui.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
private JTextField jTextField1;
private JTextField jTextField2;
}
@notizblock: Das ist gerade der Sinn des InputVerifier. Wenn ein Wechsel des Fokus stattfinden soll, prüft Java einfach ob ein InputVerifier (mit setInputVerifier) gesetzt wurde. Ist dies der Fall, wird die Methode verify aufgerufen (das Argument ist gerade der Aufrufer selbst). Verify gibt einen boolschen Wert zurück, ist dir nicht wahr, so wird der Wechsel verboten.
@morpheus schön dass es dir geholfen hat. Das ist eigentlich schon in einer eigenen Klasse ausgelagert (nur gebe ich dir recht, eine eigene Datei mit einer öffentlichen Klasse ist um einiges sauberer!).
Was bei deiner Klasse fehlt ist das extendx InputVerifier. Dieser liegt im package javax.swing (also entweder per Import einbinden oder halt extende javax.swing.InputVerifier), nur dadurch kannst du den verwenden. InputVerifier ist eine abstrakte Klasse. Die Methode verify ist abstrakt, muss also von deiner Klasse überschrieben werden. Dass dies geschieht sicherst du dadurch zu, dass du von der Klasse erbst. Dass du eine Methode mit gleicher Signatur hast, dass ist Java hingegen egal (solange du eben nicht erbst).
Dann klapp auch die Zeile die du zum einfügen stehen hast.
InputVerifier ist eine abstrakte Klasse. Die Methode verify ist abstrakt, muss also von deiner Klasse überschrieben werden. Dass dies geschieht sicherst du dadurch zu, dass du von der Klasse erbst. Dass du eine Methode mit gleicher Signatur hast, dass ist Java hingegen egal (solange du eben nicht erbst).
Äh, versuch es mal mit "Java ist auch nur eine Insel"
Das gibt es als OpenBook kostenlos im Netz zu lesen. Ist meiner Meinung nach eines der vollständigsten Bücher in der Art. Ich denke der Autor geht echt gut auf alles Wichtige (und vieles mehr) ein. Du hast da ein sehr anfängerfreundliches Werk. Die Adresse würde ich auch nur ergooglen, findest du aber auch in dem Forum.
Die Idee von (abstrakten) Klassen und Interfaces ist an sich sehr wichtig für gute (Java)Programme. Das Java ist hier aussen vor zu lassen, es ist eher ein Prinzip der Objekt Orientierung (OO).
Wirklich gut wird es wohl eher ein Buch (wie das oben genannte) erklären, aber mal eine kurze Einführung:
In der Objekt Orientierung wird alles durch Klassen modelliert. Eine Klasse klassifiziert (toll oder?). Das entspricht einfach dem was du auch in der Biologie machst. Da Informatiker keine Biologen sind nehmen die es einfach nicht so genau, es gibt keine Gattung, Art, Familie (wer kann sich da schon merken was wo kommt), es gibt nur Klassen.
Eine Klasse fässt immer die Eigenschaften aller Mitglieder zusammen. Für uns heißt das z.B., dass du die Klasse der Säugetiere nehmen könntest. Allen gemeinsam ist, dass sie Sauerstoff atmen und ihre Kinder säugen (usw.).
Eine Unterart wären die Primaten. Primaten sind wiederum eine Klasse, aber sie sind halt auch Säugetiere (also sind Primaten eine Spezialisierung der Klasse Säugetiere). Primaten haben immer 2 Arme und 2 Beine und können Werkzeuge benutzen.
Ja, eine spezielle Primaten Art ist dann noch der Mensch. Auch hier hast eigenschaften, die hat jeder Mensch aber eben nicht jeder Primat (schon mal einen blonden Affen gesehen?).
Genau das versuchst du in OOP / Java mit Klassen abzubilden. Du erstellst einfach Klassen, die alle Gemeinsamkeiten aufführen. Dabei gibt es Eigenschaften (in Form von Variablen) und Verhalten (in Form von Methoden).
In der OO können Klassen von anderen Klassen erben. In Java wird dazu das Schlüsselwort extends verwendet, na was fällt dir da auf?
Richtig, eine Klasse die erbt ist also eine Spezialisierung der anderen Klasse. Sagen wir die Klasse Primat erbt von der Klasse Säugetier, dann hat jeder Primat schon die Eigenschaften eines Säugetiers (ist ja auch korrekt). Und ein Mensch erbt von den Primaten (ist eine Spezialisierung). Hier gilt, dass der aber auch alle Eigenschaften der Säugetiere hat. Egal an welcher Stelle man in dieser Vererbungskette steht, es ist immer so, dass man alle Vorgängereigenschaften beibehält.
Dein Java Programm ist letztlich eine leere Welt. Die Klassen enthalten den Bauplan (z.B. für Primaten), aber noch lebt keiner dieser Primaten auf der Welt. In deinem Programm kannst du Objekte erzeugen. Das ist das was der Befehl new macht. Er erzeugt ein neues Exemplar einer Klasse. Dieses Exemplar hat dann alle Eigenschaften der Klasse, aber man hat wirklich ein Individuum.
Sagen wir mal du erzeugst zwei Menschen, Adam und Eva, dann sind das zwei Instanzen der Klasse Mensch. Die haben also gemeinsame Eigenschaften (z.B. ein Geschlecht, eine Haarfarbe, ...). Aber die Eigenschaften können individuell sein (dürfte klar sein).
In einem Programm ist es so, dass die Individualität wenig ausgeprägt ist. Programme handeln unter gleichen Vorraussetzungen auch immer gleich. Bei Menschen mag das anders aussehen, aber wer hat schon die exakt gleichen Vorraussetzungen?
Wenn ein Objekt sich in einem bestimmten Zustand befindet und man ruft eine Methode auf, wird sich verhalten wie jedes Objekt (selber Klasse) im gleichen Zustand. In deiner Java-Welt gibt es zwar erzeugte Objekte, aber die wissen nichts von der Welt. Na ja, wie man Methoden aufruft weißt du sicher.
Eine Besonderheit ist jetzt, dass du auch abstrakte Klassen haben kannst. Das Beispiel mit den Menschen verlassen wir kurz und gehen in die Geometrie. Hier gibt es verschiedene Formen, Dreiecke, Kreise, Rechtecke, ....
Allen gemeinsam ist, dass sie eine Fläche haben. Diese berechnet sich aber komplett unterschiedlich. Auch haben sie alle eine Form, die man zeichnen kann. Doch wie man die Zeichnet hängt natürlich von der Klasse ab.
Hier hast du jetzt das Problem, dass alle Formen eine Spezialisierung der Klasse Form sind, du aber nicht allgemein weißt wie eine Form gezeichnet wird (hängt von der konkreten Form ab) oder wie man die Fläche berechnet.
Du kannst hier also eine leere Methode hinschreiben und darauf hoffen, dass jede Spezialisierung diese überschreibt, du kannst aber auch ein Verhalten ankündigen. Dieses Verhalten ist abstrakt. Du sagst es gibt eine Methode, die heißt so und so und bekommt folgende Parameter. Wie genau die arbeitet weißt du aber noch gar nicht.
Ist eine Methode abstrakt, so muss diese Methode von jeder Spezialisierung implementiert werden. Eine Klasse die abstrakte Methoden enthält ist selbst abstrakt. Von abstrakten Klassen kannst du keine Instanzen erzeugen.
In Java hätte das die Form:
Code:
abstract class Form {
publlic abstract int getFlaeche();
publlic abstract void zeichneForm(Graphics g);
}
Wie du siehst sind die Klasse und die Methoden mit dem Schlüsselwort abstract versehen. Die Methoden enden ohne Implementierung, du kannst sie also gar nicht aufrufen.
Hast du nicht abstrakte Nachfahren, müssen diese die Methoden implementieren. Das heißt sie haben Methoden mit gleicher Signatur (ohne abstract) in denen dann auch wirklich Code steht.
Code:
class Rechteck extends Form {
public int getFlaeche() {
return this.laenge * this.breite;
}
...
}
Ein Rechteck ist jetzt eine spezielle Form. In dieser steht drin, wie man seien Fläche berechnet. Da es eine spezielle Form ist, weiß ich auch, dass da drin stehen muss, wie man es zeichnet.
Stellt sich jetzt die Frage nach dem Vorteil davon.
Der ist eigentlich recht einfach zu sehen. Er liegt in der Abstraktion (sorry, klingt immer ein wenig dumm, aber die Worte kommen halt nicht von ungefähr).
Abstraktion heißt, dass du gar nicht wissen willst, was du nicht wissen musst. Wenn du z.B. ein Programm schreibst, dass einfach Formen zeichnen soll, dann ist es dir eigentlich egal welche Form genau du zeichnest. Das ein Dreieck anders gezeichnet wird als ein Kreis ist dir klar, aber es ist egal. Was du weißt ist, dass jede Form eine Methode hat, der du einfach ein Graphics Objekt übergibst und die spezielle Form wird darauf gezeichnet.
Code:
public zeichneForm(Form irgendeineForm) {
Graphics g = getGraphics(); // holt irgendwas zum Raufzeichnen, egal.
irgendeineForm.zeichneForm(g); // klappt für alle Formen!
}
public void test() {
this.zeichneForm(new Dreieck());
this.zeichneForm(new Rechteck());
this.zeichneForm(new Kreis());
}
So könnte ein Aufruf grob aussehen. Dreieck, Rechteck und Kreis müssten halt von Form erben/es erweitern. Natürlich sollte der Konstruktor auch Daten zur Form enthalten, aber das ist eine andere Sache. Wichtig ist, dass abstrakte Klassen auch nicht abstrakte Methoden und Variablen enthalten können. So könnte z.B. jede Form eine Farbe haben, die über setColor gesetzt und über getColor gelesen wird. Dies kannst du (wie in einer normalen Klasse auch) einfach fertig implementieren. Auch diese Funktionen hätte dann jeder Nachfahre. Diese könnten dann die Methoden setColor und getColor überschreiben, müssen es aber nicht.
So, für alles weitere lege ich dir ein Buch nahe (hoffe dass es dir trotzdem für's erste hilft).
Ok soweit hab ich jetzt alles,
wenn ich allerding noch überprüfen möchte, dass nur zahlen rein dürfen?
Code:
if(!StringUtils.isEmpty(dateText))
{
if (dateText.matches("\\d\\d\\.\\d\\d\\.\\d\\d\\d\\d"))
{
if (dateText.matches("[b]was soll ich hier reinschreiben?[/b]")){
dateField.setText(dateText);
}
else
{
// Fehler!
}
}
else
{
JOptionPane.showMessageDialog(null, "Bitte geben Sie das Datum im Format tt.mm.jjjj ein", "Hinweis", JOptionPane.ERROR_MESSAGE);
dateField.grabFocus();
dateField.selectAll();
flag=false;
}
}
Was meinst du denn mit prüfen das nur Zahlen rein dürfen? Im Moment sagt doch dein regulärer Ausdruck, dass nur 2 Zahlen, ein Punkt, 2 Zahlen ein Punkt und 4 Zahlen rein darf.
Genau genommen machst du hier einen Fehler (der Punkt muss durch \\x2E ersetzt werden). Ein . Bedeutet in einem regulären Ausdruck, dass du ein beliebiges Zeichen zulässt.
Wenn du also nur prüfen möchtest ob ein Datum in der Richtigen Art und Weise eigengeben wurde, so bist du damit fertig. Vielleicht solltest du dir reguläre Ausdrücke mal anschauen.
Was du da eigentlich stehen hast ist
\d \d \x2E \d \d \x2E \d \d \d \d
Das \\ kommt nur daher, dass ein \ ein Escape Character in Java Strings ist. Ein \\ in einem Java String entspricht einfach nur einem \ (den kann der String nicht direkt verwenden).
\d heißt für den regulären Ausdruck einfach nur, dass hier eine Ziffer (0..9) stehen muss.
\xAA bedeutet, dass das Zeichen mit dem ordinalen Wert 0xAA dort stehen muss, wobei AA ein beliebiger Hexcode ist. 2E = "."
Damit prüft matches in deinem Fall dann schon, ob der String die richtige Form hat.
Falls du wissen willst, wie man generell die Eingabe auf beliebig viele Zahlen beschränkt, dass wäre der Ausdruck
"\\d*" (für >= 0 Ziffern)
"\\d+" (für > 0 Ziffern)
Das heißt hier, dass du beim + mindestens eine Ziffer stehen haben musst, nicht dass die Ziffer größer 0 sein muss.
