Einführung in die GUI-Entwicklung. Die XmSelectionBox-Klasse enthält. Die Bibliothek verfügt über eine Reihe von Verfahren, die die Erstellung des beschriebenen Designs erleichtern

yadobr 14. Januar 2014 um 09:10

Design GUI Benutzer

  • Schnittstellen

Einführung

IN moderne Welt Milliarden von Computergeräten. Noch mehr Programme für sie. Und jede hat ihre eigene Schnittstelle, die die „Hebel“ der Interaktion zwischen dem Benutzer und dem Maschinencode darstellt. Es überrascht nicht, dass die Interaktion umso effektiver ist, je besser die Benutzeroberfläche ist.

Allerdings denken nicht alle Entwickler und sogar Designer darüber nach, eine praktische und verständliche grafische Benutzeroberfläche zu erstellen.

Für mich selbst begann ich damit, Fragen zu stellen: Allgemeine Grundsätze, was Schnittstellenelemente (EI) Erstellen Sie, welches Design sie haben sollen, wo sie richtig platziert werden sollen und wie sie sich verhalten sollen.
Im Folgenden werde ich versuchen, diese Fragen zu beantworten.

Allgemeine Grundsätze


Welche EI soll ich erstellen?


Wie sollte das EI-Design aussehen?

Tatsächlich ist EI-Design das Thema eines separaten Artikels. Hier müssen Sie alles berücksichtigen: von Farbe, Form, Proportionen bis hin zur kognitiven Psychologie. Einige Grundsätze sind jedoch dennoch erwähnenswert:

Wie positioniere ich die EI richtig auf dem Bildschirm?


Wie sollten sich EIs verhalten?


Abschließend

Dieser Artikel erhebt nicht den Anspruch, der umfassendste Leitfaden zu den Prinzipien des Interface-Designs zu sein. Grafische Benutzeroberflächen sind ein umfangreiches Thema, das eng mit der Psychologie verknüpft ist und Wissenschaftler beschäftigt sowie Hunderte von Seiten in Büchern und Studien beschäftigt. In einem so kleinen Format ist es nicht möglich, die Gesamtheit des angesprochenen Themas auszudrücken. Die Befolgung der Grundprinzipien wird es jedoch ermöglichen, benutzerfreundlichere Schnittstellen zu erstellen und den Designprozess selbst zu vereinfachen.
Vielen Dank für Ihre Aufmerksamkeit.

Literatur

Jeff Raskin, „Schnittstelle: neue Wege im Design von Computersystemen“
Alan Cooper, „Über die Schnittstelle. Grundlagen des Interaktionsdesigns“
Alan Cooper, „Psychiatrie in den Händen der Patienten“

GUI-Entwicklung

Das wichtigste Mittel zur Benutzerinteraktion mit dem Programm ist die grafische Benutzeroberfläche (GUI). Die Benutzeroberfläche eines Softwareprodukts ist einer der Schlüsselfaktoren für seine Beliebtheit.

Die Erstellung einer kompetenten Benutzeroberfläche ist ein arbeitsintensiver Prozess und erfordert maximale Liebe zum Detail. Schnittstelle erstellt sollte die Möglichkeiten des Programms maximieren, den Benutzer aber gleichzeitig nicht mit einer Fülle von Menüs, Schaltflächen, Bildern und Texten überlasten.

In der Praxis erfordert die Programmierung von Windows-Anwendungen den umfangreichen Einsatz verschiedener Tools und Assistenten. Unter Berücksichtigung der Standards des ausgewählten Betriebssystems verfügt die Software daher über eine Fensteroberfläche. Dies liegt vor allem daran, dass Windows die Hauptelemente der grafischen Oberfläche in Betriebssystemen (OS) der Windows-Familie sind. Es handelt sich um rechteckige Bereiche mit eigenen Einstellungen, Eigenschaften und Typen.

Der grafische Teil des Trainingsblocks umfasst Fenster von vier Typen:

Das Hauptfenster enthält alle Navigationselemente innerhalb des Programms sowie zusätzliche Informationen, die für die bequeme Arbeit mit der Software erforderlich sind.

Informationsdatenbank-Verwaltungsfenster – umfassen alle Steuerelemente für Informationskomponenten Software-Tool. Sie ermöglichen das Hinzufügen von Tests, Informationen, neuen Benutzern und Administratoren und ermöglichen die Manipulation neu erstellter oder vorhandener Daten;

Windows zum Arbeiten mit Softwarefunktionen – Ermöglichen Sie die Arbeit mit den Hauptfunktionen des Schulungsblocks, z. B. das Bestehen von Tests und das Studieren von Vorlesungen;

Informations- und Statistikanzeigefenster – werden zur Anzeige von Informationen verwendet verschiedene Arten sowie Statistiken und Grafiken.

Das Hauptprogrammfenster enthält die folgenden Elemente Steuerung und Ausgabe von Informationen:

Fenstertitel, der den Namen des Programms und den Zweck des Fensters enthält;

Knöpfe Systemmenü, die für die Größenänderung, Minimierung und Schließung des Programms verantwortlich sind;

Der Fenstertitelbereich, der eine rein dekorative Funktion hat und zur Einhaltung der gesamten Designlösung erforderlich ist;

Willkommensbereich;

Bereich zur Anzeige von Wochentag, aktuellem Datum und Uhrzeit;

Benutzerdefinierte Symbolleiste mit Schaltflächen für den Zugriff auf die Hauptfunktionen des Programms;

Das Verwaltungsfenster enthält eine Schaltfläche für den Zugriff auf die Verwaltungskontrollen des PS;

Statusleiste mit Informationen zu allen Betriebsarten des Programms.

Schema des Hauptfensters der grafischen Oberfläche (Fensteransicht für die Verwaltung). Konto) ist in Abbildung 3.2 dargestellt

Abbildung 3.2 – Diagramm des Hauptfensters der grafischen Oberfläche: 1 – Fenstertitel; 2 – Systemmenütasten; 3 – Fenstertitelbereich; 4 – Statusleiste; 5 – Willkommensbereich; 6 – Bereich zur Anzeige von Wochentag, Datum und Uhrzeit; 7 – Verwaltungsgremium; 8 – Benutzerpanel; 9 – Schaltfläche zum Zugriff auf die Lernphase; 10 – Schaltfläche zum Zugriff auf die Testphase; 11 – Schaltfläche zum Anzeigen von Statistiken und Grafiken; 12 – Ausgang; 13 – Schaltfläche zum Zugriff auf den administrativen Teil der Anwendung

Angesichts des Schwerpunkts der zu entwickelnden Software wurden mehrere nicht standardmäßige Grafiklösungen entwickelt, um Aufmerksamkeit und größeres Interesse an der Anwendung zu wecken. Darüber hinaus können Sie dadurch eine gewisse Individualität gegenüber dem Rest der Reihe von Programmen mit ähnlichen Themen und Schwerpunkten erreichen.

Eine dieser Lösungen sind farbenfrohe Schnittstellenelemente, die ein einzigartiges Design schaffen und in diesem Bereich keine Entsprechung haben. Es geht darumüber animierte Einfügungen basierend auf Flash-Animationen. Mit ihrer Hilfe wurde die Gestaltung der Namen aller Hauptfunktionsfenster, Navigationselemente und der Oberfläche des Registrierungs- und Autorisierungsformulars umgesetzt. Die Hauptvorteile dieser Entwicklung sind: Implementierung einer angenehmen und benutzerfreundlichen Oberfläche; erhebliche Vereinfachung der Nutzung des Programms, sowohl auf Benutzer- als auch auf Verwaltungsebene.

Ein weiterer Hauptvorteil analoger Programme, sowohl in der Software als auch in der grafischen Umsetzung, ist die Organisation von bestandenen Tests auf Anfrage. Um den Test zu machen dieser Art Der Benutzer muss SQL-Abfragen aus separaten, unabhängigen Elementen zusammenstellen. Abhängig von der Art der Anfrage, die aufgrund der Bedingungen der vorgeschlagenen Aufgabe gestellt werden muss, wird ein bestimmtes Polygon für die Montage gebildet. Das Polygon enthält Felder zum Ersetzen von Operatoren, die mit der Maus aus einem separaten Block hineingezogen werden, sowie Felder zum Eingeben der Namen von Tabellen, Feldern und Bedingungen.

Benutzerstatistiken werden in Form von Grafiken implementiert, die abhängig von den von ihm erzielten Ergebnissen erstellt werden. Jeder Test hat seine eigene Dynamik. Diagramme enthalten alle erforderlichen Signaturen, werden mithilfe der TChart-Komponente implementiert und verfügen daher über zahlreiche Steuerelemente, die standardmäßig in die Komponente integriert und daher in der Anwendung implementiert sind.

Für eine benutzerfreundlichere Visualisierung wurden außerdem die Tabellenkopfstile durch diejenigen ersetzt, die in der Standardentwicklungsumgebung implementiert sind.

Die implementierten grafischen Lösungen ermöglichten es somit, das Ergebnis zu erreichen, das die eigentliche Idee des GUI-Designs vorsah. Die erstellte Schnittstelle maximiert die Möglichkeiten des Programms, überlastet den Benutzer aber gleichzeitig nicht mit einer Fülle von Menüs, Schaltflächen, Bildern und Texten.

Beigetragen von Saleem Gul und Tomas Pavek

Dabei Schulungskurs Wir beschäftigen uns mit der Erstellung einer einfachen grafischen Benutzeroberfläche und dem Hinzufügen einfacher Serverfunktionen. Insbesondere werden wir uns den Code ansehen, der das Verhalten von Schaltflächen und Feldern in einem Swing-Formular definiert.

Wir schauen uns das Layout und die Struktur der GUI an und fügen dann einige Schaltflächen und Textfelder hinzu. Textfelder dienen dazu, vom Benutzer eingegebene Informationen zu empfangen und das Ergebnis des Programms anzuzeigen. Die Schaltfläche initiiert die Ausführung von Funktionen, die im Client-Teil des Programms integriert sind. Die Anwendung, die erstellt wird ist ein einfacher, aber voll ausgestatteter Taschenrechner.

Eine ausführlichere Anleitung zu den GUI Designer-Entwicklungsfunktionen, einschließlich Videodemonstrationen verschiedener Entwicklungsfunktionen, finden Sie unter .

Geschätzte Dauer: 20 Minuten

Übung 1: Erstellen eines Projekts

Der erste Schritt besteht darin, ein IDE-Projekt für die Anwendung zu erstellen, die Sie entwickeln. Nennen wir das Projekt NumberAddition.

  1. Wählen Sie „Datei“ > „Neues Projekt“. Sie können auch auf das Symbol „Neues Projekt“ in der IDE-Symbolleiste klicken.
  2. Wählen Sie im Bereich Kategorien den Java-Knoten aus. Wählen Sie im Bereich „Projekte“ „Java-Anwendung“ aus. Klicken Sie auf die Schaltfläche „Weiter“.
  3. Geben Sie NumberAddition in das Feld Projektname ein und geben Sie einen Pfad, z. B. Ihr Home-Verzeichnis, als Projektspeicherort an.
  4. Aktivieren Sie das Kontrollkästchen „Separaten Ordner zum Speichern von Bibliotheken verwenden“ und geben Sie den Speicherort des Bibliotheksordners an (optional). Weitere Informationen Weitere Informationen finden Sie im Artikel „Teilen einer Bibliothek mit anderen Benutzern in einem Dokument“. Entwickeln von Anwendungen mit NetBeans IDE.
  5. Entfernen Sie das Kontrollkästchen „Hauptklasse erstellen“, falls es aktiviert ist.
  6. Klicken Sie auf die Schaltfläche „Fertig“.

Übung 2: Erstellen des Frontends

Um den Schnittstellenerstellungsprozess fortzusetzen, müssen Sie einen Java-Container erstellen, in dem die anderen erforderlichen GUI-Elemente platziert werden. In dieser Aktivität wird ein Container mithilfe eines JFrame-Elements erstellt. Der Container wird in ein neues Paket eingefügt, das im Knoten „Quellpakete“ angezeigt wird.

Erstellen eines JFrame-Containers

  1. Klicken Sie im Fenster „Projekte“ auf Rechtsklick Bewegen Sie den Mauszeiger über den NumberAddition-Knoten und wählen Sie „Neu“ > „Andere“.
  2. Wählen Sie im Dateierstellungsdialog eine Kategorie aus Swing-GUI Formulare und der JFrame-Formulardateityp. Klicken Sie auf die Schaltfläche „Weiter“.
  3. Geben Sie NumberAdditionUI als Klassennamen ein.
  4. Wählen Sie das my.numberaddition-Paket aus.
  5. Klicken Sie auf die Schaltfläche „Fertig“.

Die IDE erstellt das NumberAdditionUI-Formular und die NumberAdditionUI-Klasse in der NumberAddition-Anwendung und öffnet das NumberAdditionUI-Formular im GUI Builder. Das my.NumberAddition-Paket ersetzt das Standardpaket.

Elemente hinzufügen: Ein Frontend erstellen

Als nächstes verwenden Sie das Fenster „Palette“. Frontend Die Anwendung wird mit dem JPanel gefüllt. Danach werden drei JLabel-Elemente (Textbeschriftungen), drei JTextField-Elemente (Textfelder) und drei JButton-Elemente (Schaltflächen) hinzugefügt. Wenn Sie noch nie mit dem GUI-Designer gearbeitet haben, finden Sie unter Entwerfen einer Swing-GUI in der NetBeans-IDE Informationen zur Komponentenplatzierung.

Nach dem Ziehen und Platzieren der oben genannten Elemente sollte das JFrame-Element wie im Bild unten aussehen.

Wenn in der oberen rechten Ecke der IDE kein Palettenfenster vorhanden ist, wählen Sie „Fenster“ > „Palette“.

  1. Wählen Sie zunächst ein Panel aus der Kategorie „Swing-Container“ in der Palette aus und ziehen Sie es auf den JFrame.
  2. Das JPanel wird hervorgehoben. Gehen Sie zum Fenster „Eigenschaften“ und klicken Sie auf die Schaltfläche mit den Auslassungspunkten (...) neben dem Feld „Rahmen“, um einen Rahmenstil auszuwählen.
  3. Wählen Sie im Dialogfeld „Rahmen“ die Option „TiltedBorder“ aus der Liste aus und geben Sie „Number Addition“ in das Feld „Titel“ ein. Klicken Sie auf „OK“, um Ihre Änderungen zu speichern und das Dialogfeld zu schließen.
  4. Auf dem Bildschirm sollte nun ein leeres „JFrame“-Element mit dem Titel „Number Addition“ angezeigt werden, wie im Bild gezeigt. Fügen Sie wie im Bild drei JLabels, drei JTextFields und drei JButtons hinzu.

Elemente umbenennen

In diesem Schritt werden die Elemente umbenannt, die dem JFrame-Element hinzugefügt wurden.

  1. Doppelklicken Sie auf jLabel1 und ändern Sie ntrcn („Text“-Eigenschaft) in „Erste Zahl“.
  2. Doppelklicken Sie auf jLabel2 und ändern Sie den Text in „Second Number“.
  3. Doppelklicken Sie auf jLabel3 und ändern Sie den Text in „Ergebnis“.
  4. Entfernen Sie den Standardtext aus jTextField1. Der angezeigte Text kann in bearbeitbaren Text umgewandelt werden. Klicken Sie dazu mit der rechten Maustaste auf das Textfeld und wählen Sie im Popup-Menü „Text bearbeiten“. Dies erfordert möglicherweise, dass Sie jTextField1 auf seine ursprüngliche Größe zurücksetzen. Wiederholen Sie diesen Schritt für die Felder jTextField2 und jTextField3.
  5. Ändern Sie den Anzeigetext von jButton1 in Clear . (Um den Text einer Schaltfläche zu ändern, klicken Sie mit der rechten Maustaste auf die Schaltfläche und wählen Sie Text bearbeiten. Alternativ können Sie auf die Schaltfläche klicken, anhalten und erneut klicken.)
  6. Ändern Sie den Anzeigetext von jButton2 in Add .
  7. Ändern Sie den Anzeigetext von jButton3 in Exit .

Nun sollte die fertige GUI wie im Bild unten aussehen:

Übung 3: Funktionalität hinzufügen

In dieser Übung werden die erforderlichen Funktionen zu den Schaltflächen „Hinzufügen“, „Löschen“ und „Beenden“ hinzugefügt. Die Felder jTextField1 und jTextField2 werden für Benutzereingaben verwendet und jTextField3 wird verwendet, um das Ergebnis des Programms anzuzeigen. Das erstellte Programm ist ein einfacher Taschenrechner. Also fangen wir an!

Hinzufügen von Funktionen zur Schaltfläche „Beenden“.

Damit die Schaltflächen funktionsfähig sind, muss jeder Schaltfläche ein Ereignishandler zugewiesen werden, der für die Reaktion auf Ereignisse verantwortlich ist. In unserem Fall müssen wir das Schaltflächenklickereignis identifizieren – entweder durch Klicken mit der Maus oder mithilfe der Tastatur. Daher wird die Schnittstelle „ActionListener“ zur Verarbeitung von „ActionEvent“-Ereignissen verwendet.

  1. Klicken Sie mit der rechten Maustaste auf die Schaltfläche „Beenden“. Wählen Sie im Popup-Menü Ereignisse > Aktion > actionPerformed aus. Bitte beachten Sie, dass das Menü viele weitere Ereignisse enthält, auf die das Programm reagieren kann! Wenn Sie das actionPerformed-Ereignis auswählen, fügt die IDE automatisch einen ActionListener zur Exit-Schaltfläche hinzu und erstellt eine Handler-Methode zur Verarbeitung der actionPerformed-Listener-Methode.
  2. Die IDE öffnet automatisch das Quellcodefenster und zeigt Ihnen, wo Sie die Aktion einfügen können, die die Schaltfläche ausführen soll, wenn Sie darauf klicken (mit der Maus oder der Tastatur). Das Fenster „Quellcode“ sollte die folgenden Zeilen enthalten: private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( //TODO fügen Sie hier Ihren Bearbeitungscode hinzu: )
  3. Fügen wir nun den Code für die Aktion hinzu, die die Schaltfläche „Beenden“ ausführen soll. Ersetzen Sie die TODO-Zeile durch System.exit(0); . Der fertige Code für die Schaltfläche „Beenden“ sollte wie folgt aussehen: private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( System.exit(0); )

Funktionalität zur Schaltfläche „Löschen“ hinzufügen

  1. Klicken Sie mit der rechten Maustaste auf die Schaltfläche „Löschen“ (jButton1). Wählen Sie im angezeigten Menü „Ereignisse > Aktion > actionPerformed“ aus.
  2. Wenn Sie auf die Schaltfläche „Löschen“ klicken, sollte der gesamte Text aus allen „jTextField“-Textfeldern entfernt werden. Fügen Sie dazu Code hinzu, der dem oben genannten ähnelt. Der fertige Quellcode sollte wie folgt aussehen: private void jButton1ActionPerformed(java.awt.event.ActionEvent evt)( jTextField1.setText(""); jTextField2.setText(""); jTextField3.setText(""); )

Dieser Code entfernt Text aus allen drei JTextFields und lässt sie leer.

Hinzufügen von Funktionen zur Schaltfläche „Hinzufügen“.

Die Schaltfläche „Hinzufügen“ sollte drei Dinge bewirken.

  1. Es nimmt zunächst die Eingaben des Benutzers in die Felder jTextField1 und jTextField2 und konvertiert sie von einem „String“-Typ in einen „Float“-Typ.
  2. Anschließend wird die Addition der beiden Zahlen durchgeführt.
  3. Schließlich wird die Summe in einen String umgewandelt und in jTextField3 platziert.
Fangen wir an!
  1. Klicken Sie oben im Arbeitsbereich auf die Registerkarte „Entwurf“, um zum Bildschirm „Formularentwurf“ zurückzukehren.
  2. Klicken Sie mit der rechten Maustaste auf die Schaltfläche „Hinzufügen“ (jButton2). Wählen Sie im Popup-Menü Ereignisse > Aktion > actionPerformed aus.
  3. Fügen Sie Code für die Aktionen hinzu, die die Schaltfläche „Hinzufügen“ ausführen soll. Der fertige Quellcode sollte so aussehen: private void jButton2ActionPerformed(java.awt.event.ActionEvent evt)( // Zuerst definieren wir Float-Variablen. float num1, num2, result; // Wir müssen den Text in einen Typ float analysieren . num1 = Float.parseFloat(jTextField1.getText()); num2 = Float.parseFloat(jTextField2.getText()); // Jetzt können wir das Ergebnis = num1+num2; ausführen , wir werden // den Wert von result von einem Float in einen String ändern.

Jetzt ist das Programm vollständig fertig und Sie können mit der Zusammenstellung und Ausführung beginnen.

Übung 4: Ausführen des Programms

Um das Programm in der IDE auszuführen, gehen Sie folgendermaßen vor:

  1. Wählen Sie „Ausführen“ > „Hauptprojekt ausführen“ (alternativ drücken Sie F6).

    Notiz. Wenn Sie ein Fenster öffnen, das anzeigt, dass für Project NumberAddition keine Hauptklasse angegeben ist, sollten Sie im selben Fenster my.NumberAddition.NumberAdditionUI als Hauptklasse auswählen und auf OK klicken.

Um das Programm außerhalb der IDE auszuführen, gehen Sie folgendermaßen vor:

Nach einigen Sekunden wird die Anwendung gestartet.

Notiz. Wenn ein Doppelklick auf eine JAR-Datei die Anwendung nicht startet, finden Sie weitere Informationen unter JAR-Dateizuordnungen auf Ihrem Betriebssystem.

Sie können die Anwendung auch über die Befehlszeile ausführen.

Um die Anwendung über die Befehlszeile auszuführen, führen Sie die folgenden Schritte aus:

  1. Öffnen Sie eine Eingabeaufforderung oder ein Terminalfenster.
  2. IN BefehlszeileÄndern Sie das aktuelle Verzeichnis in das Verzeichnis NumberAddition/dist.
  3. Geben Sie an der Eingabeaufforderung die folgende Anweisung ein: java -jar NumberAddition.jar

    Notiz. Stellen Sie sicher, dass my.NumberAddition.NumberAdditionUI als Hauptklasse festgelegt ist, bevor Sie die Anwendung ausführen. Um dies zu überprüfen, klicken Sie im Bedienfeld „Projekte“ mit der rechten Maustaste auf den Projektknoten „NumberAddition“, wählen Sie „Eigenschaften“ aus dem Popup-Menü und wählen Sie im Dialogfeld „Projekteigenschaften“ die Kategorie „Ausführen“. Im Feld „Hauptklasse“ sollte my.numberaddition.NumberAdditionUI angezeigt werden.

Ereignisverarbeitungs-Engine

In diesem Tutorial wurde die Reaktion auf ein einfaches Schaltflächenklickereignis untersucht. Es gibt viele Ereignisse, auf die eine Anwendung reagieren kann. In der IDE können Sie die Liste der verfügbaren Ereignisse, die von GUI-Elementen verarbeitet werden können, wie folgt anzeigen:

  1. Kehren Sie im Editor zur Datei NumberAdditionUI.java zurück. Klicken Sie auf die Registerkarte „Design“, um die GUI-Struktur im GUI Builder anzuzeigen.
  2. Klicken Sie mit der rechten Maustaste auf ein beliebiges GUI-Element und wählen Sie „Ereignisse“ aus dem angezeigten Menü. Jetzt können Sie einfach den Inhalt des Menüs erkunden, ohne irgendwelche Elemente auszuwählen.
  3. Alternativ können Sie im Menü „Fenster“ den Eintrag „Eigenschaften“ auswählen. Klicken Sie im Eigenschaftenfenster auf die Registerkarte Ereignisse. Auf der Registerkarte „Ereignisse“ können Sie Ereignishandler anzeigen und ändern, die mit dem aktuell aktiven GUI-Element verknüpft sind.
  4. Die Anwendung kann auch auf Tastendrücke, Einzel-, Doppel- oder Dreifachklicks, Mauszeigerbewegungen, Fenstergrößenänderungen und Eingabefokusbewegungen reagieren. Über das Menü „Ereignisse“ können Sie automatisch Ereignishandler für alle diese Ereignisse erstellen. Das häufigste davon ist das „Action“-Ereignis. (Weitere Informationen finden Sie im Sun Java Events Tutorial unter Umgang mit Ereignissen.)

Wie werden Ereignisse verarbeitet? Immer wenn Sie ein Ereignis aus dem Ereignismenü auswählen, erstellt die IDE automatisch einen sogenannten Ereignis-Listener und ordnet ihn der Entwicklerkomponente zu. Um mehr über die Ereignisverarbeitung zu erfahren, führen Sie die folgenden Schritte aus:

  1. Kehren Sie im Editor zur Datei NumberAdditionUI.java zurück. Klicken Sie zum Anzeigen auf die Registerkarte „Quelle“. Quellcode grafische Oberfläche.
  2. Scrollen Sie nach unten, um die implementierten Methoden jButton1ActionPerformed() , jButton2ActionPerformed() und jButton3ActionPerformed() anzuzeigen. Diese Methoden werden Event-Handler genannt.
  3. Gehen Sie nun zur initComponents()-Methode. Wenn diese Methode fehlt, suchen Sie die Zeile „Generierter Code“ und klicken Sie auf das Pluszeichen „+“ neben dieser Zeile, um die ausgeblendete initComponents()-Methode anzuzeigen.
  4. Beachten Sie den blauen Block, der die initComponents()-Methode umgibt. Dieser Code wurde automatisch von der IDE generiert und kann vom Benutzer nicht geändert werden.
  5. Schauen Sie sich nun die initComponents()-Methode selbst an. Es enthält unter anderem Code, der GUI-Elemente initialisiert und auf dem Formular platziert. Dieser Code wird automatisch generiert und aktualisiert, wenn Sie Elemente im Designmodus platzieren und ändern.
  6. Suchen Sie in der initComponents()-Methode das folgende Snippet: jButton3.setText("Exit"); jButton3.addActionListener(new java.awt.event.ActionListener() ( public void actionPerformed(java.awt.event.ActionEvent evt) ( jButton3ActionPerformed(evt); ) ));

    Zu diesem Zeitpunkt wird dem GUI-Element, in diesem Fall jButton3, ein Ereignis-Listener-Objekt „ActionListener“ hinzugefügt. Die „ActionListener“-Schnittstelle verfügt über eine „actionPerformed“-Methode auf dem „ActionEvent“-Objekt, die durch einfachen Aufruf des jButton3ActionPerformed-Ereignishandlers implementiert wird. Diese Schaltfläche reagiert jetzt auf Aktionsereignisse. Jedes Mal, wenn auf die Schaltfläche geklickt wird, wird ein „ActionEvent“ generiert und an die Methode „actionPerformed“ der Ereignis-Listener-Schnittstelle übergeben, die den Code ausführt, den der Entwickler für dieses Ereignis im Ereignishandler bereitgestellt hat.

  7. Lernkarte für Java-GUI-Anwendungen

9. Juli 2003

Mit dem Aufkommen verschiedener Tools zur visuellen Anwendungsentwicklung ist das Schreiben grafischer Schnittstellen für Programme zu einer Art Kinderspiel geworden. Ich tippte mit der Maus darauf und ein Formular erschien; ich tippte ein zweites Mal darauf und eine Schaltfläche erschien. Es scheint mir, dass viele Leute heutzutage nicht mehr über eine andere Art der Programmierung in einer grafischen Umgebung nachdenken. Gegen den Fortschritt kann man natürlich nicht argumentieren; beim Schreiben großer Projekte sind all diese Annehmlichkeiten sehr praktisch. Aber darum geht es in diesem Gespräch nicht. Manchmal kommt es zur Absurdität: Eine primitive Anwendung wird mit MFC, VCL usw. geschrieben. Solche Programme verschlingen den Speicher wie Termiten und beanspruchen mit ihren dicken Körpern zusätzlichen Speicherplatz. In der Regel „wiegen“ MFC/VCL-Analoga zehn- bis zwanzigmal mehr als Programme, die auf einer reinen API geschrieben sind. Und Visual Basic (möge Gott mir diesen Satz verzeihen) mit seiner msvbvmXX.dll? Ja und Systemressourcen es wird deutlich mehr verbraucht (mehrmals). Arme Benutzer, die sich das Bier verweigern, sparen Geld, um neue Hardware zu kaufen. Ist es nicht schade um die armen Dinger? Nicht nur Programmierer trinken Bier? Es gibt noch einen weiteren positiven Aspekt der API-Codierung: Der Programmierer rückt näher an das Betriebssystem heran. Dementsprechend versteht und kontrolliert er es besser. Und es ist ganz einfach: Es ist eine sehr aufregende Aktivität. Ich wiederhole, das alles gilt speziell für kleine, einfache Programme; bei großen Projekten ist alles völlig anders.

Ich hoffe, ich habe Sie überzeugt. Lass uns gehen.

Wir werden uns mit der Erstellung einer einfachen Fensteroberfläche mit minimaler Funktionalität befassen. Dies wird ein einfaches Fenster mit zwei Eingabefeldern und zwei Schaltflächen sein. Wenn Sie auf die Schaltfläche „Kopieren“ klicken, wird der Text aus dem ersten Eingabefeld in das zweite kopiert. Wenn Sie auf die Schaltfläche „Schließen“ klicken, beendet das Programm seine Arbeit. Zukünftig kann es als Vorlage für das Schreiben anderer, komplexerer Anwendungen dienen. Wir werden in C/C++ kommunizieren, obwohl wir Delphi auch nicht vor den Kopf stoßen werden. Das allgemeine Prinzip ist dasselbe, nur die Syntax ist unterschiedlich. Um mit Systemmeldungen und API-Funktionen arbeiten zu können, müssen Sie Header-Dateien in Ihr Projekt einbinden. In C/C++ ist dies „windows.h“, in Delphi ist dies Windows-Module und Nachrichten.

Jedes Programm im Windows-Betriebssystem besteht aus drei Hauptteilen: der Hauptfunktion, der Nachrichtenschleife und der Fensterfunktion, die alle an das Fenster gesendeten Nachrichten verarbeitet.

Die Ausführung unseres Programms beginnt mit der Funktion WinMain(). Dies ist die Hauptfunktion. Die Funktion WinMain() führt normalerweise die folgenden Aufgaben aus:

  • Definiert die Fensterklasse. Nicht zu verwechseln mit einer OOP-Klasse.
  • Registriert diese Klasse im System.
  • Erstellt das Hauptanwendungsfenster und andere Steuerelemente.
  • Zeigt ein Fenster auf dem Bildschirm an.
  • Startet die Nachrichtenverarbeitungsschleife.
  • Es wird folgendermaßen deklariert: int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) Schauen wir uns die Parameter an:
    • hInstance ist ein Handle für die aktuelle Anwendungsinstanz.
    • hPrevInstance ist ein Handle für die vorherige Instanz der Anwendung, sofern diese ausgeführt wird.
    • lpCmdLine – Zeiger auf eine Zeile mit Parametern, die beim Start an das Programm übergeben werden.
    • nCmdShow – eine Konstante, die bestimmt, wie das Fenster angezeigt wird. (Siehe SW_-Konstanten).

In Delphi werden wir ein solches Bild nicht sehen; in dieser Entwicklungsumgebung wird die Hauptfunktion durch den Compiler vor dem Programmierer verborgen. Obwohl es natürlich im endgültigen Code vorhanden ist. Um eine Fensterklasse zu registrieren, müssen Sie die Felder der Struktur vom Typ WNDCLASS (in Delphi TWNDCLASS) ausfüllen. Zu diesem Zweck haben wir die Variable wcl deklariert.

wcl.hInstance = hInstance; Die hInstance-Variable ist ein Handle für die aktuelle Anwendungsinstanz und wird von der Funktion WinMain() initialisiert. In Delphi wird es implizit initialisiert.

wcl.lpszClassName = szWinName; Klassenname. Wir haben vorab die String-Variable szWinName erstellt und initialisiert.

wcl.lpfnWndProc = WindowFunc; Ein Zeiger auf eine Fensterfunktion. wcl.style = 0; Eine Konstante, die den Fensterstil angibt. Dafür werden die CS_-Flags verwendet, ich habe sie einfach auf Null gelöscht. Sie können eine Kombination von Flags mithilfe der bitweisen „Oder“-Operation angeben. wcl.hIcon = LoadIcon(NULL, IDI_ASTERISK); Ein Handle für das Anwendungssymbol, das von der LoadIcon()-Funktion zurückgegeben wird. Ich habe ein Standardsymbol hochgeladen. Siehe IDI_-Konstanten.
  • wcl.hCursor = LoadCursor(NULL,IDC_ARROW); Ein Handle für den Anwendungscursor, wie von LoadCursor() zurückgegeben. Ich habe den Standardpfeil geladen. Siehe IDC_-Konstanten.
  • wcl.lpszMenuName = NULL; Zeiger auf eine Zeichenfolge, die den Namen der Menüressource für diese Fensterklasse angibt. Keine Speisekarte, kein Schild.
  • wcl.cbClsExtra = 0; Reserviertes Feld. Lassen Sie uns zurücksetzen.
  • wcl.cbWndExtra = 0; Reserviertes Feld. Lassen Sie uns zurücksetzen.
  • wcl.hbrBackground = (HBRUSH)COLOR_WINDOW; Fensterfarbe. Die COLOR_WINDOW-Konstante wird in den Typ HBRUSH umgewandelt (in Delphi ist keine Umwandlung erforderlich). Mit der Funktion GetStockObject() können Sie außerdem die Farbe des Fensterpinsels oder das Hintergrundbild festlegen. Melden Sie sich jetzt gerne für die Fensterklasse an.
  • Der achte Parameter ist das Eigentümerfenster. Im Hauptfenster ist der Besitzer der Desktop (0). Die Steuerelemente verfügen über ein Hauptfenster.
  • Der neunte ist ein Zeiger auf das Menühandle. Keine Speisekarte, kein Schild.
  • Der zehnte Parameter ist ein Handle für die aktuelle Anwendungsinstanz.
  • Elftens – Wird beim Erstellen von Anwendungen mit einer MDI-Schnittstelle verwendet. Wir brauchen es nicht.
Die Funktion gibt ein Handle für das erstellte Fenster zurück, das in der Variablen hMainWnd gespeichert ist.
Ein Fensterhandle ist eine eindeutige Nummer im System, die ein Fenster oder Steuerelement identifiziert.

Als nächstes erstellen wir die notwendigen Steuerelemente. Alle Steuerelemente sind die gleichen Fenster, sie haben nur einen anderen Klassennamen. Es ist nicht erforderlich, Kontrollklassen zu registrieren; sie sind bereits im System vordefiniert. Button – Button-Klasse. Eingabefeld – Klassenbearbeitung. Bildunterschrift – Klassenstil. Es gibt viele Klassen, die Standardsteuerelementen entsprechen. Wir erstellen Steuerelemente mit der bekannten Funktion „CreateWindow()“ und der unbekannten Funktion „CreateWindowEx()“. Mit CreateWindowEx() können Sie ein Fenster mit einem erweiterten Stil erstellen. Wir verwenden es, um Eingabefelder zu erstellen. Diese Funktion hat den ersten Parameter hinzugefügt, der diesen fortschrittlichsten Stil festlegt, die übrigen Parameter sind die gleichen wie bei CreateWindow(). Steuerelemente sind untergeordnete Fenster, ihr Besitzer ist das Hauptfenster.

Beim Erstellen von Steuerelementen müssen Sie in den Funktionsparametern den Deskriptor des Hauptfensters sowie den Fensterstil WS_CHILD angeben. Aussehen und die Funktionalität der Steuerelemente kann mithilfe der Flags WS_, ES_, BS_, SS_ manipuliert werden, indem sie mit der bitweisen „Oder“-Operation kombiniert werden. Beim Erstellen von Steuerelementen initialisieren wir die entsprechenden Variablen mit ihren Deskriptoren, die von den Funktionen CreateWindow() und CreateWindowEx() zurückgegeben werden. Wir werden diese Deskriptoren für die weitere Arbeit mit Kontrollen benötigen. Wir zeigen das von uns erstellte Fenster auf dem Bildschirm an und zeichnen es neu.

Die GetMessage-Funktion wählt die nächste Nachricht aus der Nachrichtenwarteschlange der Anwendung aus und sendet sie an das Fenster.
  • Der erste Parameter ist eine Struktur vom Typ MSG (in Delphi vom Typ TMSG)
  • Der zweite Parameter ist ein Handle für das Fenster, für das die Nachricht bestimmt ist. Wenn NULL oder 0, dann alle Anwendungsfenster.
  • Mit der dritten und vierten Option können Sie den Bereich der empfangenen Nachrichten festlegen. Wenn 0, dann alle an das Fenster adressierten Nachrichten.
GetMessage – gibt FALSE zurück, wenn eine WM_QUIT-Meldung erscheint. In diesem Fall wird die Schleife verlassen und die Anwendung beendet.

TranslateMessage – übersetzt virtuelle Tastencodes in Tastaturnachrichten. DispatchMessage – sendet eine Nachricht zur Verarbeitung an die Fensterfunktion. Die Fensterfunktion stellt Programmfunktionalität bereit, indem sie Systemmeldungen verarbeitet. Die Fensterfunktion ist eine CALLBACK-Funktion, d.h. angerufen

Betriebssystem

  • als Antwort auf eine neu empfangene Nachricht. Die Fensterfunktion wird wie folgt deklariert:
  • LRESULT CALLBACK WindowFunc(HWND hMainWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
  • HMainWnd – Handle für das Hauptfenster.

iMsg – Nachrichtennummer. Siehe WM_-Konstanten.

lParam und wParam sind Nachrichtenparameter.

Wenn eine Meldung erscheint, können wir den iMsg-Parameter mit einer der WM_-Konstanten vergleichen und das Programm so programmieren, dass es entsprechend reagiert.

Beispiel: Wenn die linke Maustaste gedrückt wird, während sich der Mauszeiger über dem Clientbereich des Fensters befindet, wird das Ereignis WM_LBUTTONDOWN ausgelöst. Die Fensterfunktion wird aufgerufen, der Wert der Konstante WM_LBUTTONDOWN wird in den iMsg-Parameter eingegeben, wir können die Bedingung prüfen und die gewünschte Programmreaktion programmieren.

Innerhalb der Fensterfunktion befindet sich eine Auswahlanweisung, die die oben beschriebene Aufgabe ausführt. Der Auswahloperator muss über einen Standardhandler verfügen, der durch die Funktion DefWindowProc(hMainWnd, iMsg, wParam, lParam) implementiert wird.

Wenn dies nicht geschieht, wird unser Programm ohne Wiederbelebung sterben. Viele Meldungen werden vom System selbst verarbeitet, wie zum Beispiel: Fenstergröße ändern, Fenster minimieren/maximieren, Systemmenü aufrufen usw. Dafür ist DefWindowProc() gedacht. Beim Arbeiten mit Fenstersteuerelementen wird eine WM_COMMAND-Nachricht an den Fenstereigentümer gesendet, wobei lParam das Handle für das Steuerelement enthält und das High-Byte des wParam-Parameters die Kennung des im Steuerelement ausgelösten Ereignisses ist. Beispiel: Wenn Sie auf eine Schaltfläche klicken – BN_CLICKED. Siehe Konstanten BN_, WM_. Wir können das Programm mit der Funktion PostQuitMessage(0) schließen. Diese Funktion sendet eine WM_QUIT-Nachricht an das Fenster., starten Sie den Projektmanager und löschen Sie Unit1 zusammen mit dem Formular. Drücken Sie Strg + F12 und öffnen Sie die Projektdatei. Wir entfernen das Formularmodul aus den Verwendungen, fügen dort Fenster und Nachrichten hinzu. Wir löschen alles zwischen Anfang und Ende. Das Werkstück ist fertig. Sie können codieren. Ohne Hilfe, die immer zur Hand sein sollte, ist es unmöglich, Programme mit einer reinen API zu schreiben. Wenn Sie Gates selbst wären, würden Sie sich nicht an alles erinnern. Ich empfehle:

  • zunächst einmal - MSDN;
  • Hilfesystem Delphi (MSTOOLS.HLP-Datei);
  • Auf der Website http://www.soobcha.ru/rushelp gibt es russische Hilfe zur Win32-API.
Das ist alles.
Viel Glück.

Bobachenko Maxim Herunterladen: CreateWnd.zip(2,6K)
Das Archiv enthält die Dateien windows.cpp und windows.dpr

GUI-Standard.

Eine der wichtigsten Veränderungen in der Computerindustrie ist die Einführung der grafischen Benutzeroberfläche. Besteht also die Notwendigkeit, GUI-Standards einzuführen, die festlegen, wie Windows-Anwendungen aussehen sollen? Macintosh usw. Es gibt sogar Zertifizierungsprogramme, auf die Anbieter ihre Anwendungen zuschneiden. Windows-Symbol. Dies geschieht aus mehreren Gründen.

Einer der Vorteile von Windows oder Mac ist ihr einheitliches Erscheinungsbild. Wenn Sie gelernt haben, in einem von ihnen zu arbeiten, denken Sie, dass Sie den Rest beherrschen. Die meisten Windows-Anwendungen verwenden dieselben Konventionen, sodass Sie wissen, wie Sie in jeder dieser Anwendungen eine Datei öffnen, speichern, drucken, schließen und kopieren. Die Standardoberfläche ist sehr benutzerfreundlich. Sie müssen versuchen, Ihre Anwendungen anderen Windows-Anwendungen ähnlich zu machen, mit denen Benutzer bereits vertraut sind. Es sind sieben Allgemeine Grundsätze GUI-Entwicklung. Wenn Sie sie lernen und befolgen, wird Ihr App-Design gut sein.

Sieben Prinzipien des GUI-Designs.

Die sieben allgemeinen Prinzipien des GUI-Designs stammen aus dem Microsoft Windows Interface Guide. Sie bilden eine Blaupause, aus der Sie Ihre eigenen Standards erstellen können. Dieses Design bietet Entwicklern und Benutzern zwei wesentliche Vorteile. Erstens sehen die Apps professionell aus. Zweitens sind sie funktional, konsistent mit anderen Anwendungen und für Benutzer leicht zu erlernen.

Damit eine Bewerbung erfolgreich ist, muss sie natürlich gut geschrieben und nützlich sein – das sind die Hauptvoraussetzungen. Die Prinzipien, über die wir sprechen, geben dem Entwickler lediglich Denkanstöße.

1. Erlauben Sie dem Benutzer, die Anwendung zu steuern.

2. Folgen Sie dem Objekt/Aktion-Paradigma.

3. Seien Sie konsequent.

4. Machen Sie die Verwendung von Anwendungen einfach und offensichtlich.

5. Streben Sie nach Harmonie.

6. Geben Sie Benutzer-Feedback.

7. Seien Sie nachsichtig

Prinzip eins: Geben Sie dem Benutzer die Kontrolle über die Anwendung.

Der Benutzer muss die Anwendung steuern, d. h. von jedem anderen Modul aus Zugriff auf jedes Anwendungsmodul haben. Bisher wurde für diesen Zugriff ein hierarchisches Menü verwendet.


Nehmen wir an, der Benutzer möchte einen neuen Kunden hinzufügen. Im Beispiel muss der Benutzer zum ACCOUNTS RECCIEVAable-Modul gehen und von dort aus einen neuen Kunden hinzufügen. Woher weiß er, was zu tun ist? Wahrscheinlich aus meiner Erfahrung mit dieser Anwendung. Und in der GUI-Welt wählt der Benutzer einfach den Befehl „Neu“ aus dem Menü und dann „Kunde“, wie in Abb. Dabei modernes System Sie können über das Menü „Datei“ einen neuen Kunden, Lieferanten oder Bestandsartikel hinzufügen. Dadurch können Sie einen Kundendatensatz ändern, während Sie sich auf dem Händlerbildschirm befinden, und umgekehrt. Der Benutzer muss nicht mehr durch komplexe und verwirrende hierarchische Menüs navigieren.

Prinzip zwei: Befolgen Sie das Objekt/Aktion-Paradigma.

Das Objekt/Aktion-Paradigma besagt, dass bestimmte Operationen an allen Objekten im System ausgeführt werden können. Das einfachste und offensichtlichste Beispiel ist der Supportbildschirm für die Kundendatenbank (Abb.). Der Bildschirm enthält eine Reihe von Schaltflächen und jede der Schaltflächen unten ermöglicht es Ihnen, eine Aktion mit Informationen über den ausgewählten Kunden durchzuführen. Sie können es löschen, bearbeiten, drucken usw. Aktionen, die auf einem bestimmten Client ausgeführt werden können, müssen zu den entsprechenden Zeiten verfügbar oder nicht verfügbar sein. Wenn sich beispielsweise ein Kundendatensatz im Bearbeitungsmodus befindet, sollten die Schaltflächen „Löschen“ und „Neu“ deaktiviert sein.

Prinzip drei: Seien Sie konsequent.

Konsistenz ist eines der wichtigsten Prinzipien des GUI-Designs. GUI – Ermöglichen Sie Benutzern das Erkunden mehr Apps als ältere Programme. Und das alles dank des Prinzips der Konsistenz. Wenn ein Benutzer auf eine neue Anwendung trifft, ist er bereits mit den grundlegenden Befehlen vertraut: Öffnen, Drucken und Speichern von Dateien. Auf diesen Plattformen entwickelte Anwendungen sind in der Regel miteinander konsistent.

Seien Sie also beim Erstellen neuer Anwendungen konsistent. Wenn ich hinzufügen möchte neuer Eintrag Der Befehl „Neu“ wird verwendet, verwenden Sie ihn überall. Dieses Wort sollte nicht durch andere ersetzt werden – zum Beispiel durch das Wort Add 9add). Dank Ihrer Konsistenz wissen Benutzer, dass sie überall dort, wo sie auf den Befehl „Neu“ stoßen, zum Hinzufügen eines neuen Eintrags verwendet werden können.

Prinzip vier: Machen Sie die Verwendung der Anwendung einfach und offensichtlich.

Eine andere Möglichkeit, diese Idee auszudrücken, ist: Verwenden Sie keinen Fachjargon. Es gibt einen Bildschirm mit zwei Tasten. Einer von ihnen sagt „Packen Sie die Datenbank“ und der andere sagt „Zum Löschen markierte Datensätze entfernen“. Der zweite Eintrag wird für den Benutzer wahrscheinlich verständlicher sein.

Bei der Entwicklung von Anwendungen besteht oft die Versuchung, in der Benutzeroberfläche Programmierer-Slang zu verwenden. Versuchen Sie dies nach Möglichkeit zu vermeiden.

Fünftes Prinzip: Streben Sie nach Harmonie

Selbst in Schwarzweiß hat dieser Bildschirm einen erheblichen ästhetischen Nachteil: einen weißen Hintergrund mit kontrastierenden Objekten darauf. In Abb. Der gleiche Bildschirm sieht farblich ausgewogen aus.

Es gibt Millionen von Farbkombinationen, die Sie auf Windows übertragen können. Bedeutet das, dass sie alle genutzt werden müssen? Natürlich nicht. Sie sollten einfache, ruhige Farben wählen und deren chaotisches Mischen vermeiden, was manche Programmierer aus irgendeinem Grund mögen.

Prinzip sechs. Geben Sie dem Benutzer Feedback.

Stellen Sie sich vor, Ihre Anwendung verfügt über einen Prozess, dessen Ausführung lange dauert. Während dieser Zeit können Sie auf dem Bildschirm eine Meldung mit folgendem Inhalt anzeigen: „Das Programm läuft, bitte warten.“ Bequeme Lösung; Aber woher weiß der Benutzer, dass es nicht eingefroren ist? Daher ist es sehr wahrscheinlich, dass er der Anwendung einen „Drei-Finger-Gruß“ (Strg+Alt+Entf) gibt, obwohl mit dem Programm alles in Ordnung sein wird.

Es ist besser, dem Benutzer zu zeigen, welcher Teil des Prozesses abgeschlossen ist. Dann wird er das Programm nicht unnötig unterbrechen, sondern kann beurteilen, wie weit die Arbeit fortgeschritten ist, und andere Dinge tun, bis der Prozess abgeschlossen ist. Dadurch erhöht sich die Produktivität des Anwenders um rund 25 Prozent. Dieses Ergebnis kann durch einfache Anzeige des Messgeräts auf dem Bildschirm erreicht werden. Typischerweise werden Meldungen wie „10 von 100 Datensätzen verarbeitet“ oder „40 % abgeschlossen“ angezeigt. Noch besser ist es, sowohl die Anzahl der verarbeiteten Datensätze als auch deren Prozentsatz anzuzeigen.“

Siebter Grundsatz: Sei verzeihend

Jeder von uns hat schon einmal einen Beitrag gelöscht, weil er versehentlich den falschen Knopf gedrückt hat. Geben Sie dem Benutzer daher die Möglichkeit, seine Meinung zu ändern oder die gerade durchgeführten Aktionen abzubrechen. Wenn der Vorgang lange dauert, eine große Datenmenge ändert oder eine Erstellung durch den Benutzer erforderlich ist Sicherungskopie Bevor Sie eine Aktion ausführen, müssen Sie eine entsprechende Warnung ausgeben. Ich habe Anwendungen gesehen, die eine doppelte Bestätigung erfordern und dann auch nach einem Passwort fragen. Benötigen Ihre Programme dieses Maß an Schutz? Vielleicht. Die Aufgabe des Entwicklers besteht darin, dem Benutzer zu helfen, wenn ihm in irgendeiner Phase der Arbeit ein Fehler unterlaufen ist.

Die Bedeutung von GUI-Standardkonventionen.

Wie Sie sehen, sind die Prinzipien des GUI-Designs sehr einfach und sollten beim Erstellen von Bildschirmen verwendet werden. Bevor Sie jedoch den Bildschirm entwerfen, müssen Sie festlegen, wie er aussehen soll. Wählen Sie Größen, Schriftarten, Farben, Nachrichtenstile usw. Indem Sie diese Probleme im Voraus lösen, beschleunigen Sie Ihre Arbeit erheblich. Wenn es später um die Schriftart oder den Stil von Nachrichten geht, schaut man einfach auf den Standard.



VERWANDTE ARTIKEL