Java - Allgemeine Fragen

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • Java - Allgemeine Fragen

      hab ein kleines java problem. ich hab einen JButton mit actionlistener gemacht. wird der button gedrückt passiert. etwas. jetzt soll aber nach dem ausführen, wenn der button nochmal gedrückt wird, etwas anderes passieren. wie kann ich das machen?

      ich meine aber keinen doppelklick. klick auf den button = etwas passiert. zweiter klick auf den button = etwas anderes soll passieren.

      Spoiler anzeigen

      Java-Quellcode

      1. new ActionListener() {
      2. public void actionPerformed(ActionEvent a) {
      3. String s;
      4. s = tfEingabe.getText();
      5. lbZielEingabe.setText(s);
      6. tfEingabe.requestFocus();
      7. tfEingabe.setText("");
      8. }
      9. }


      so ist der stand jetzt. es wird nur text von A nach B kopiert. jetzt soll eben noch etwas anderes kopiert werden wenn der button nochmal geklickt wird.

      Edit by ramius: Da es sich um Java handelt, hab ich es aus dem C++ Thread in einen eigenen Java Thread verschoben.
    • Mach dir eine global Variable/Attribut, ka wie das bei java richtig heisst.
      Ein Boolean, setz den default auf false, beim ersten ausführen auf true. schreib in den actionlistener beide funktionen die ausgeführt werden sollen. führ die erste nur für false, die zweite nur für true aus.

      Müsste doch klappen. So ähnlich?

      Edit: Ninjas everywhere. Aber jeder gleichen Ansatz, andere Umsetzung. :D
    • henpara schrieb:

      Integer einführen, auf Null setzen, wenn Button gedrückt wird im Actionlistener Integer um eins erhöhen, dann via IF unterscheiden, was im passieren soll.

      ich darf aber den int aus dem actionlistener nicht anfassen. darf auch nicht den wert übernehmen, kommt immer ein fehler.
      irgendwo muss er den wert für den klick herhaben, aber das geht iwie nicht.

      edit: was genau ist dieses "ActionEvent a". wofür steht das a?
      edit2: danke ramius für den thread. :love:

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Bläh ()

    • a ist der name des ActionEvents mit dem du auf es zugreifen kannst ;)

      also du hast 2 Alternativen:

      Die erste wurde bereits mehrfach genannt:
      Im ActionListener hast du ein sogenanntes Flag, welches nach dem ersten Klick umspringt und dann beim zweiten Klick mittels if-Abfrage eine andere Logik ablaufen lässt

      also quasi so:

      Quellcode

      1. //Außerhalb ActionListener
      2. bool clickedOnce=false;
      3. ....
      4. //Innerhalb ActionListener
      5. if(!clickedOnce){
      6. //Erster Klick
      7. clickedOnce=true;
      8. }else{
      9. //Zweiter Klick
      10. }


      Zweite Alternative:
      du benutzt 2 ActionListeners, welche jeweils entsprechende Logik implementieren

      Quellcode

      1. //Innerhalb Action Listener 1
      2. Klick 1 bearbeiten
      3. for( JButton currentButton: button ) { //Dies entfernt alle ActionListener vom Button
      4. for( ActionListener al : currentButton.getActionListeners() ) {
      5. currentButton.removeActionListener( al );
      6. }
      7. }
      8. Button.setActionListener(ActionListener2)
      9. //ActionListener2


      Option 1 ist die bessere ;)
      If the king doesn't lead, how can he expect his subordinates to follow
      And forgive us our trespasses.
      As we forgive those who trespass against us.

      tree^ schrieb:

      was seid ihr alles für hässliche megaspasten. k3 ist der boss!
    • Wie woher bekommst du den Wert? Du setzt den zu Beginn deines Programms. Das clickedOnce sollte damit global auch sein.
      Und im listener rufst du ihn einfach auf.
      Und setzt ihn auf true.

      Wo willst du noch welchen Wert haben?

      Edit: ach du denkst über das clickevent kommt ein wert mit. verstehe.
      du brauchst keinen wert davon. wenn das clickedonce global deklariert ist, kennt das tool auch innerhalb des actrionlisteners das clickedOnce, du kannst ihn einfach aufrufen.
    • Bläh schrieb:

      option 2 ist leider keine lösung.
      die erste hab ich schon verstanden aber wo krieg ich den wert für clickedOnce her? das klicken selber hat keinen wert den ich sehen kann, heir ist das problem.


      Ok:

      1. Option
      Die Klasse mit dem button implementiert und ist der ActionListener.
      2. Option
      Die Variable ist static.
      3. Option
      Der ActionListener ist innere Klasse in der Klasse die den Button hat. Somit kann er auf die Variablen der äußeren Klasse zugreifen.
      4. Option bei der Instanziierung übergibst du dem Listener die Klasse mit den boolean (Nur aufgezählt zur vollständigkeit)
      1.

      Quellcode

      1. public class YourClass implements ActionListener{
      2. private bool onceClicked=false;
      3. ...
      4. button.addActionListener(this);
      5. ...
      6. @Override public void actionPerformed(ActionEvent e){
      7. if(onceClicked)....
      8. }
      9. }


      2.

      Quellcode

      1. public class YourClass{
      2. public static boolean onceClicked=false;
      3. }
      4. aufrufen dann per YourClass.onceClicked


      3.

      Quellcode

      1. public class YourClass{
      2. private bool onceClicked=false;
      3. ...
      4. button.addActionListener(new listener());
      5. ...
      6. class listener implements ActionListener{
      7. @Override public void actionPerformed(ActionEvent e){
      8. if(onceClicked)....
      9. }
      10. }
      11. }
      Alles anzeigen
      If the king doesn't lead, how can he expect his subordinates to follow
      And forgive us our trespasses.
      As we forgive those who trespass against us.

      tree^ schrieb:

      was seid ihr alles für hässliche megaspasten. k3 ist der boss!
    • lol jetzt versteh ichs. also ich mach einfach den zähler ++. wollte die ganze zeit einen wert fürs klicken haben, also 1x klick = a und 2x klick = b;
      :ugly: :fresse:

      hab jetzt einen int zähler++;
      bei 0 wird halt das erste ausgeführt, bei 1 der rest. das ist mir grade voll peinlich. :whistling:

      danke euch.
    • Ich benutz einfach mal diesen Thread hier



      Dank TI4 hab ich die letzten paar Vorlesungen verpasst und bin mir nicht so ganz sicher was ich bei meiner Hausaufgabe genau machen soll.
      Ich hab zurzeit 42 pkt und brauch noch 8 (weil 50 für die Zulassung zur Klausur benötigt wird). Sind noch 2 Hausaufgaben (inklusive dieser) die jeweils 12 und 10 punkte geben.
      Ich würde aber gern mit dieser Hausaufgabe schonmal die 50pkt erreichen.

      Ich weiß nicht so recht wo ich bei der 6.1 anfangen soll. Einfach die Klassen (BlueRay, DVD, ..) erstellen mit dem Interface DatabaseItem implementiert?
      Sollte ich ne Klasse DatabaseItem erstellen die als superclass fungiert? Wäre das iwie sinnvoll?

      Was meinen die genau mit "Überlegen Sie sich dabei eine vernünftige Modellierung, die Redundanzen möglichst vermeidet, ohne die Elemente in einen ”Einheitsbrei“ zu verwandeln."

      Bräuchte "Anweisungen" wo ich anfangen sollte und was ich machen sollte. Mir fehlt zurzeit der Überblick dafür wegen einigen Lücken bei Java (die ich wohl erst nach Ti4 :whistling: auffüllen werden kann).
    • Könntest du mal noch die schon vorgegeben Klassen posten? also vorallem das Interface?


      Du sollst in 6.1. halt das package erweitern, sodass die Datenbank später mit BlueRay, Book, CD und DVD funktioniert. Generell soll es aber mit allen möglichen Sachen funktionieren.

      Und in 6.2. musst du dann die Datenbank realisieren.


      Mehr versteh ich da jetzt aber auch nicht ohne die Klassen gesehen zu haben.
    • DatabaseItem.java

      package gdi1database.items;

      /**
      * describes the interface for an arbitrary database item
      * that can be described by its name, data, key, and "additional data".
      *
      * @author Guido Rößling (roessling@acm.org)
      */
      public interface DatabaseItem {

      /**
      * returns the name of the database item
      *
      * @return the name of the database item
      */
      public String getName();

      /**
      * returns the main data of the database item
      *
      * @return the data of the database item
      */
      public String getData();

      /**
      * returns additional data for the database item
      *
      * @return the additional data for the database item
      */
      public String getAdditionalData();

      /**
      * returns the key of the database item
      *
      * @return the key of the database item
      */
      public String getKey();
      }


      DatabaseInterface.java

      package gdi1database;

      import gdi1database.items.DatabaseItem;

      import java.util.Set;

      /**
      * Describes the interface for a (simplified) database implementation.
      *
      * @author Guido Rößling (roessling@acm.org)
      */
      public interface DatabaseInterface<T extends DatabaseItem> {

      /**
      * adds a DatabaseItem to the database. Note: entries that already
      * exist will not be added again.
      *
      * @param e
      * the DatabaseItem that should be inserted to the database.
      * @return true if DatabaseItem has been successfully inserted to the
      * database, else false (usually because the value is null or already
      * existed).
      */
      public boolean addEntry(T e);

      /**
      * deletes the DatabaseItem e if it exists and updates the database
      *
      * @param e
      * the DatabaseItem which should be deleted.
      * @return true if the DatabaseItem has been deleted successfully, else
      * false.
      */
      public boolean deleteEntry(T e);

      /**
      * Drops the database and replaces it with one of size 0
      *
      * @return true if database has been deleted correctly, else false.
      */
      public boolean dropDatabase();

      /**
      * returns true if an DatabaseItem matching the parameter exists in
      * the database
      *
      * @param e
      * the DatabaseItem that should exist.
      * @return true if the DatabaseItem exists inside the database, else
      * false.
      */
      public boolean entryExists(T e);

      /**
      * returns the element at the chosen position of null if the position is
      * invalid
      *
      * @param key
      * the key of the DatabaseItem to be returned.
      * @return the DatabaseItem object at the given position, if any, else
      * null.
      */
      public T getEntry(String key);

      /**
      * returns the keys for all elements in this database
      *
      * @return the set of (String) keys for all elements in this database
      */
      public Set<String> getKeys();

      /**
      * returns the size of this database
      *
      * @return the size of this database.
      */
      public int getSize();
      }


      DatabaseColumn.java

      package gdi1database;

      /**
      * describes a column in a (simplified) database
      *
      * @author Guido R&ouml;&szlig;ling (roessling@acm.org)
      */
      public enum DatabaseColumn {
      DATA, NAME, ADDITIONAL_DATA, KEY, DATA_NAME, KEY_DATA, KEY_DATA_NAME, ALL
      }



      @6.1 also einfach die jeweiligen Klassen (BlueRay, DVD, ...) schreiben die das interface DatabaseInterface implementiert haben?

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von khoi-chan gf ()

    • JA würde ich sagen.

      "Was meinen die genau mit "Überlegen Sie sich dabei eine vernünftige Modellierung, die Redundanzen möglichst vermeidet, ohne die Elemente in einen ”Einheitsbrei“ zu verwandeln."

      Das verstehe ich auch nicht so ganz, Eventuell sollst du die Klassen gruppieren. Also DVD und BlueRay sind ja fast identisch, Also könntest du ne Klasse "Filme" machen und dadrunter dann erst DVD und BlueRay.

      Also:

      DataBaseItem -> Filme -> DVD
      DataBaseItem -> Filme -> BlueRay
      DataBaseItem -> CD
      DataBaseItem -> Book

      Dadurch könntest du gemeinsame Methoden in der Klasse "Filme" deklarieren und in DVD und BlueRay dann nur die Unterschiede. Evtl. kannst du Sie auch anders gruppieren um CD und/oder Buch auch noch mit einzubeziehen

      Java ist bisschen her, daher hoffe ich, ich erzähle nicht mist :D Aber müsste mit Vererbung doch so funktionieren?
    • Sweeper schrieb:

      JA würde ich sagen.

      "Was meinen die genau mit "Überlegen Sie sich dabei eine vernünftige Modellierung, die Redundanzen möglichst vermeidet, ohne die Elemente in einen ”Einheitsbrei“ zu verwandeln."

      Das verstehe ich auch nicht so ganz, Eventuell sollst du die Klassen gruppieren. Also DVD und BlueRay sind ja fast identisch, Also könntest du ne Klasse "Filme" machen und dadrunter dann erst DVD und BlueRay.

      Also:

      DataBaseItem -> Filme -> DVD
      DataBaseItem -> Filme -> BlueRay
      DataBaseItem -> CD
      DataBaseItem -> Book

      Dadurch könntest du gemeinsame Methoden in der Klasse "Filme" deklarieren und in DVD und BlueRay dann nur die Unterschiede. Evtl. kannst du Sie auch anders gruppieren um CD und/oder Buch auch noch mit einzubeziehen

      Java ist bisschen her, daher hoffe ich, ich erzähle nicht mist :D Aber müsste mit Vererbung doch so funktionieren?


      Doch, sollte so stimmen. Man könnte natürlich noch einen Schritt weitergehen, und alle Objekte von einem AusleihhbarenObject (sehe grade, dass du das oben schon überlegt hast, du hast es halt DataBaseItem genannt) oder ähnlich benannten erben lassen, um zum Beispiel einen key zurückzugeben.

      Die Rückgabe der Werte kannst du über states implementieren, du erzeugst Fälle für die verschiedenen Elemente, zB Buch, BluRay und die Rückgäbe unterscheidet sich dann je nach dem Element, um das es dir grade geht. So kannst du die Methoden in der obersten Klasse definieren.

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Dumbaz ()

    • Java wie gesagt länger her und die Programmiersprache mit der ich Arbeite hat keine Vererbung.

      Aber muss die Klasse Movies (sollte Movie heißen btw) nicht auch nen Konstruktor haben und den springst du dann in BlueRay und DVD mit super() an?

      In BlueRay und DVD deshalb glaub ich auch nicht die Attribute deklarieren die du schon in Movie hast.


      *edit: Jo, siehe: programmersbase.net/Content/Ja…utorial/Java/Heredity.htm
    • Hey ich hoffe das ist hier im richtigem Thema!

      Ich möchte Java lernen um mich beruflich weiterzubilden. Bin Dipl.-Ing. Verfahrenstechniker. Kann bisher nicht wirklich programmieren, habe aber Erfahrung mit sowas wie matlab funktionen schreiben.

      Zu Weihnachten wollte ich mir 1-2 Bücher gönnen um mir das autodidaktisch beizubringen.

      Bloß welche Bücher sollte ich mir holen? Vllt habt Ihr hier ja nen Tipp für mich?

      Als startprojekte würde ich sowas schreiben wollen wie nen intelligenten nicht linearen solver für open office. Oder einen Destillationskollonnensimulator. (Nur damit Ihr eine Vorstellung habt, was ich mit JAVA umsetzen möchte)

      Wäre für gute Tipps sehr dankbar. :)
      Gruß Kalle
      Weil ich immer wieder gefragt werde: Ich bin nicht der dotalan (veno)Kalle.