Η διαδικασία ανάπτυξης ενός απλού προγράμματος GUI σε Java. Επιλογή βιβλιοθήκης για τη δημιουργία Java GUI

Πρόγραμμα Kerish Doctor. 23.06.2019
Επισκόπηση προγράμματος Η έκδοση υπολογιστή του Microsoft Excel Viewer θα επιτρέψει...

Chercher Οικιακές συσκευέςείναι ότι δεν είναι μόνο μια γλώσσα, αλλά και ένας τυποποιημένος αντικειμενοστραφής χρόνος εκτέλεσης. Είναι ενδιαφέρον να δούμε πώς επιλύονται τα παραδοσιακά προβλήματα προγραμματισμού εντός της Java. Θα επικεντρωθούμε στη γραφική διεπαφή με παράθυρο.

Μαζί με διάφορες ευχάριστες (κυρίως για τον χρήστη) ιδιότητες, η διεπαφή παραθύρου εισάγει επίσης μάλλον δυσάρεστα (για τον προγραμματιστή) προβλήματα. Ένα από αυτά είναι η φορητότητα των εφαρμογών μεταξύ διαφορετικών πλατφορμών. Η φορητότητα είναι ένα πρόβλημα χωρίς GUI, αλλά η ύπαρξη ενός το καθιστά πολύ πιο δύσκολο.

Το γεγονός είναι ότι κάθε περιβάλλον παραθύρου είναι ένας πολύπλοκος κόσμος, με τους δικούς του νόμους, ένα σύνολο δομικών στοιχείων και τεχνικές προγραμματισμού. Το μοτίβο δεν μοιάζει με τα MS-Windows ή το σύστημα παραθύρων Macintosh. Τα πρωτόγονα στοιχεία διεπαφής αναπαρίστανται διαφορετικά, τα εξωτερικά συμβάντα υφίστανται διαφορετική επεξεργασία, η σχεδίαση στην οθόνη εμφανίζεται διαφορετικά, κ.λπ.

Ταυτόχρονα, στον πυρήνα του, το περιβάλλον παραθύρου είναι απλώς ένα ιδανικό πεδίο δραστηριότητας για προγραμματισμό αντικειμένων. Είναι σαφές ακόμη και σε ένα άτομο άπειρο σε αντικειμενοστρεφείς μεθόδους σχεδίασης ότι πράγματα όπως κουμπιά, πεδία κειμένου και μενού αξίζουν πλήρως να ονομάζονται αντικείμενα, ανεξάρτητα από το πώς γίνεται κατανοητή αυτή η λέξη. Με άλλα λόγια, είναι ξεκάθαρο τι είναι «κουμπί γενικά», «λίστα γενικά» κ.λπ.

Όλα αυτά δίνουν λόγους να ελπίζουμε ότι χρησιμοποιώντας μια αντικειμενοστρεφή προσέγγιση είναι δυνατό να επιτευχθεί ένα πραγματικά υψηλού επιπέδου και φορητό περιβάλλον παραθύρων που βασίζεται σε αφηρημένους τύπους δεδομένων.

Αυτό το χαρακτηριστικό των περιβαλλόντων παραθύρων εκδηλώθηκε, ειδικότερα, με την εμφάνιση ενός αρκετά μεγάλου αριθμού διαφορετικών βιβλιοθηκών κλάσεων που «τύλιξαν» τα αρχικά συστήματα παραθύρων. Παραδείγματα περιλαμβάνουν τα MFC, OWL, Zink και πολλά άλλα.

Έτσι, μεταξύ των τυπικών βιβλιοθηκών Java υπάρχει το AWT ή το Abstract Windowing Toolkit - μια αφηρημένη εργαλειοθήκη παραθύρων.

Το AWT είναι ένα σύστημα κλάσης για την υποστήριξη προγραμματισμού σε περιβάλλον παραθύρου. Η «αφηρότητά» του εκδηλώνεται στο γεγονός ότι όλα όσα εξαρτώνται από μια συγκεκριμένη πλατφόρμα είναι καλά εντοπισμένα και κρυμμένα. Το AWT υλοποιεί τόσο απλά και κατανοητά πράγματα όπως κουμπιά, μενού, πεδία εισαγωγής. απλά και ξεκάθαρα μέσα οργάνωσης της διεπαφής - δοχεία, πίνακες, διαχειριστές γεωμετρίας.

Βασικά στοιχεία γραφικής διεπαφής χρήστη και κοντέινερ

Αν κοιτάξετε οποιαδήποτε εφαρμογή με παράθυρο, είναι εύκολο να δείτε ότι το τμήμα διεπαφής αποτελείται από αντικείμενα ομαδοποιημένα σε ομάδες. Στο AWT, τα αντικείμενα ονομάζονται συστατικά (στην πραγματικότητα, είναι όλα απόγονοι της κλάσης Component) και οι ομάδες αντικειμένων υλοποιούνται χρησιμοποιώντας τα λεγόμενα containers. Σημειώστε ότι οποιοδήποτε δοχείο είναι επίσης ένα συστατικό, επομένως ομάδες αντικειμένων μπορούν να τοποθετηθούν μεταξύ τους. Ως συνήθως, τα μενού ξεχωρίζουν.

Τα πρωτόγονα συστατικά περιλαμβάνουν:

Κύρια δοχεία:

Η αλληλεπίδραση των στοιχείων διεπαφής με τον χρήστη υλοποιείται χρησιμοποιώντας τη συσκευή συμβάντων, η οποία θα συζητηθεί παρακάτω.

Αυτό το άρθρο εξηγεί πώς να δημιουργήσετε την απλή εφαρμογή που φαίνεται στο σχήμα στα δεξιά και παρέχει τον πηγαίο κώδικα της.


Για να τοποθετήσετε κουμπιά, ετικέτες κειμένουκαι άλλα στοιχεία στο παράθυρο του προγράμματος, θα πρέπει να κατανοήσετε πώς λειτουργεί το JPanel. Αυτό είναι κάτι σαν δοχείο για εξαρτήματα που καταλαμβάνει ορθογώνιος χώροςοθόνη και εμφανίζει στοιχεία ευθυγραμμισμένα με ορισμένα απλή αρχή. Ο τρόπος με τον οποίο ακριβώς ευθυγραμμίζονται τα στοιχεία εξαρτάται από τον τύπο διάταξης που έχετε εγκαταστήσει για τον πίνακα. Για απλές εργασίες προγραμματισμού, θα πρέπει να γνωρίζετε τουλάχιστον το BorderLayout, το οποίο τοποθετεί στοιχεία στις άκρες και ένα μεγάλο στοιχείο στη μέση, μετά το FlowLayout, το οποίο συνήθως ευθυγραμμίζει τα στοιχεία οριζόντια και τέλος το GridLayout, το οποίο τακτοποιεί τα στοιχεία σε έναν προσαρμοσμένο πίνακα n* m. Υπάρχουν και άλλα είδη, αλλά είναι πολύ δύσκολα για αρχάριους. Η βασική ιδέα είναι ότι ένα "συστατικό" μπορεί να είναι κάτι διαφορετικό από ένα κουμπί ή ένα πλαίσιο ελέγχου. JPanel.Μπορείτε να αποκτήσετε μια αρκετά περίπλοκη διεπαφή χρήστη απλά στοιβάζοντας πάνελ το ένα πάνω στο άλλο και επιλέγοντας μια διάταξη για αυτά.


Εάν έχετε ένα παράδειγμα αντικειμένου JPanelκαλέστε τη μέθοδο .setLayoutγια να ορίσετε τον τύπο διάταξης και στη συνέχεια τη μέθοδο.add για να προσθέσετε στοιχεία στον πίνακα. Σε περίπτωση BorderLayoutθα χρειαστεί να περάσετε τη θέση ως δεύτερη παράμετρο. Για παράδειγμα, για να τοποθετήσετε το κουμπί στο επάνω μέρος, καλέστε myPanel.add(myButton, BorderLayout.North).


Το ίδιο το δοχείο υψηλό επίπεδοπου εμφανίζεται στην οθόνη που αντιπροσωπεύει μια εφαρμογή Java είναι ένα παράδειγμα JFrame, όχι JPanel. Για να προσθέσετε τον κύριο πίνακα σας σε μια παρουσία JFrameαπλά καλέστε myJFrame.getContentPane().add(myJPanel, BorderLayout.Center).


Για να κάνετε την εφαρμογή σας να κάνει περισσότερα από την απλή εμφάνιση, θα πρέπει να κατανοήσετε τη διεπαφή ActionListener. Οποιαδήποτε μη αφηρημένη ActionListenerυπάρχει μόνο μία μέθοδος Εκτελέστηκε δράσηπου καλείται όταν ο χρήστης εκτελεί μια «ενέργεια» στο στοιχείο στο οποίο είναι εγγεγραμμένος ο ακροατής (για παράδειγμα, η ενέργεια σε ένα κουμπί προφανώς το πατάει). Για να καταχωρίσετε ένα πρόγραμμα ακρόασης ενεργειών για ένα κουμπί ή οποιοδήποτε άλλο στοιχείο, καλέστε τη μέθοδο .addActionListener. .

Βήματα

Δημιουργία κοινόχρηστου πλαισίου

    Δημιουργήστε μια κλάση που επεκτείνει την κλάση JFrame. Αυτή η κλάση θα περιέχει όλα τα στοιχεία της γραφικής διεπαφής (GUI) σας, όπως κουμπιά και πεδία κειμένου.

    Σκεφτείτε τη συνολική εμφάνιση και αίσθηση της πρώτης σας εφαρμογής.Ένα καλό μέρος για να ξεκινήσετε θα ήταν με ένα κεντρικό πάνελ όπως BorderLayoutμε άλλο πάνελ στο κάτω μέρος ( BorderLayout.South). Αυτός ο δεύτερος πίνακας θα είναι του τύπου FlowLayoutκαι περιέχει πολλά κουμπιά, πλαίσια ελέγχου και άλλα στοιχεία ελέγχου. Τέλος, τοποθετήστε το μεγάλο εξάρτημα JTextAreaστη μέση του κεντρικού στοιχείου. Για να αλληλεπιδράσετε με τον χρήστη μέσω κειμένου, θα μπορείτε να χρησιμοποιήσετε μεθόδους getText()Και setText().

    Γράψτε έναν κατασκευαστή για την τάξη σας.Αυτός ο σχεδιαστής θα πρέπει να δημιουργήσει όλα τα πάνελ και τα εξαρτήματα που έχετε σχεδιάσει, να τα τακτοποιήσει σωστά και να προσθέσει το τελικό πλαίσιο που "κολλάει τα πάντα" στο πλαίσιο σας (myFrame.getContentPane().add(myLargePanel, BorderLayout.Center).

    Γράψτε μια κύρια μέθοδο που θα είναι το σημείο εισόδου του προγράμματος.Σε αυτή τη μέθοδο, δημιουργήστε ένα στιγμιότυπο του πλαισίου, ορίστε το αρχικό του μέγεθος και θέση (χρήση. setSize(x,y)Και .setLocation(πλάτος, ύψος)) και κάντε το να εμφανίζεται στην οθόνη καλώντας .setVisible(true).

    Προγραμματισμός απαντήσεων στις ενέργειες του χρήστη

    1. Κάντε το πλαίσιο σας να εφαρμόσει μια διεπαφή ActionListener. Αυτό θα επιτρέψει στην τάξη σας να "ακούει" τις ενέργειες των στοιχείων.

      Για κάθε κουμπί, πλαίσιο ελέγχου ή άλλο στοιχείο ελέγχου που δημιουργείτε, καλέστε μια μέθοδο.addActionListener,περνώντας το πλαίσιο σου ( αυτό) ως παράμετρος.

      Παράκαμψη της αφηρημένης μεθόδου της κλάσης ActionListener που ονομάζεται actionPerformed (Συμβάν ActionEvent). Σε αυτή τη μέθοδο θα πρέπει να προσθέσετε δηλώσεις υπό όρους "if" για να ελέγξετε από πού προήλθε το συμβάν. Αυτή η υπό όρους δήλωση "αν" θα πρέπει να έχει μια συνθήκη όπως αυτή: " if (event.getSource() == button1)". Αυτό ελέγχει από πού προήλθε το συμβάν και αν προήλθε από το κουμπί. Μέσα στη δήλωση "αν", εκτελέστε όποια ενέργεια χρειάζεστε όταν κάνετε κλικ στο κουμπί.

      U JTextAreaυπάρχει μέθοδος .setText("myText"), που είναι ένας καλός τρόπος για να προγραμματίσετε κάποιο είδος ορατής απόκρισης στη δράση σας.

    • Δεν είναι πολύ πιο δύσκολο να υλοποιήσετε μια διεπαφή MouseListenerκαι χρήση .addMouseListenerγια να το καταχωρήσετε για οποιοδήποτε στοιχείο.
    • Εάν πρέπει να ζητήσετε από τον χρήστη να εισαγάγει κάποια συμβολοσειρά, καλέστε στατική μέθοδος J OptionPane.showInputDialog(αυτό, "Το μήνυμά μου").Η πρώτη παράμετρος θα πρέπει να είναι το πλαίσιο της εφαρμογής σας ή κάποιο είδος πίνακα (το πεδίο εισαγωγής θα εμφανιστεί στη μέση του γονικού στοιχείου). Η μέθοδος επιστρέφει την τιμή που εισήγαγε ο χρήστης στο παράθυρο διαλόγου.
    • Είναι πολύ πιθανό να τοποθετήσετε όλα τα εξαρτήματα σε ένα πάνελ χρησιμοποιώντας τον τύπο GridBagLayoutαλλά αυτή η κατηγορία είναι πιο δύσκολο να ελεγχθεί.
    • Εάν θέλετε να σχεδιάσετε τα δικά σας γραφικά (π.χ. σκακιέρα), διαβάστε για το στοιχείο Canvas. Μπορεί να τοποθετηθεί στην εφαρμογή σας όπως κάθε άλλο στοιχείο, αλλά θα χρειαστεί να γράψετε μια μέθοδο .paint που είναι αποκλειστικά υπεύθυνη για τη ζωγραφική του.
    • Σε πολλά πραγματικές εφαρμογέςΤο πιο χρήσιμο εξάρτημα Swing είναι το JTable. Αφού μάθετε τα βασικά, συνεχίστε να εργάζεστε με αυτό.

    Προειδοποιήσεις

    • Ορισμένα εργαλεία ανάπτυξης προσφέρουν τη δυνατότητα σύνθεσης ενός Swing GUI με "φιλικό προς το χρήστη" τρόπο. Ωστόσο, συχνά αποτυγχάνουν να δημιουργήσουν σωστά έναν πίνακα με προηγμένες δυνατότητες. Αυτές οι δυνατότητες περιλαμβάνουν δέντρα, πίνακες, λίστες και σύνθετα πλαίσια που αλλάζουν τα περιεχόμενά τους καθώς εκτελείται το πρόγραμμα, στοιχεία με μοντέλα δεδομένων χρήστη και ούτω καθεξής. Ο κώδικας γραμμένος με αυτόν τον "φιλικό προς τον χρήστη" τρόπο θα γίνει πραγματικός εφιάλτης εάν αργότερα χρειαστεί να τον προσθέσετε χειροκίνητα. Επομένως, μην παρασυρθείτε πολύ με αυτού του είδους τους «φιλικούς προς το χρήστη σχεδιαστές GUI», γιατί θα περιορίσουν τις επιλογές σας λόγω των περιορισμένων δυνατοτήτων τους.
    • Το Swing είναι μια εφαρμογή με ένα σπείρωμα. Εάν η ενέργειά σας διαρκεί πολύ για να επεξεργαστεί, θα σταματήσει μέχρι να τερματιστεί η μέθοδος .δράση Εκτελέστηκε. Μάθετε και χρησιμοποιήστε το java multithreading για να διατηρήσετε το Swing ζωντανό ενώ εκτελείται κάποια χρονοβόρα διαδικασία.
    • Οι περισσότερες μέθοδοι στοιχείων Swing μπορούν να κληθούν με ασφάλεια μόνο από το νήμα αποστολής συμβάντων (μέθοδος .δράση Εκτελέστηκεκαι άλλες παρόμοιες μεθόδους ακροατή). Εάν πρέπει να τους καλέσετε από κάποιο άλλο νήμα (για παράδειγμα, για να ενημερώσετε μια γραμμή προόδου ή να εμφανίσετε τα αποτελέσματα κάποιας μακροχρόνιας διαδικασίας), διαβάστε σχετικά SwingUtils.invokeLater.

    Πηγές

    Πηγαίος κώδικας

    Εισαγωγή java.awt.BorderLayout; εισαγωγή java.awt.FlowLayout;εισαγωγή java.awt.event.ActionEvent ; εισαγωγή java.awt.event.ActionListener ;εισαγωγή javax.swing.JButton ; εισαγωγή javax.swing.JCheckBox ;εισαγωγή javax.swing.JFrame ; εισαγωγή javax.swing.JPanel ;εισαγωγή javax.swing.JTextArea ; /** * Μια πολύ απλή εφαρμογή java swing.*Περιέχει ένα κουμπί και ένα πλαίσιο ελέγχου. Απαντά * σε αλλαγές σε αυτά τα στοιχεία ελέγχου * αλλάζοντας το κείμενο στο κύριο πεδίο κειμένου. * * @συγγραφέας audriusa */δημόσια κλάση WikiHow επεκτείνει το JFrame υλοποιεί το ActionListener ( /** * Κουμπί. */ JButton myButton = νέο JButton ("Button" ) ; /** * Πλαίσιο ελέγχου. */ JCheckBox myCheckBox = νέο JCheckBox ( "Έλεγχος" ) ; /** * Πεδίο κειμένου.*/ JTextArea myText = νέο JTextArea ("Το κείμενό μου" ) ;/** * Το κάτω πλαίσιο που περιέχει το κουμπί. */ JPanel bottomPanel = new JPanel();

/** * Ο γονικός πίνακας που περιέχει τα πάντα.

  • Προβολείς - κλάσεις για την ενθυλάκωση των εργασιών παροχής δεδομένων για εμφάνιση, φιλτράρισμα, ταξινόμηση κ.λπ.
  • Δράσεις και συνεισφορές - εισάγετε τη σημασιολογία περιγραφής ενέργειες χρήστηκαι πώς πρέπει να διατίθενται στον χρήστη.
  • Μητρώα εικόνων και γραμματοσειρών - Παρέχετε κλάσεις για τη διαχείριση πόρων όπως εικόνες και γραμματοσειρές.
  • Διάλογοι και οδηγοί - ένα πλαίσιο για την οικοδόμηση πολύπλοκης αλληλεπίδρασης διαλόγου με τον χρήστη.
  • Υποβοήθηση πεδίου—Παρέχει επιλογές για την εφαρμογή βοηθητικής λειτουργικότητας για πεδία, όπως εμφάνιση κατάστασης πεδίου ή υποδείξεων περιεχομένου.

Το πρώτο μέρος θα εξετάσει τη δημιουργία ενός απλού παραθύρου χρησιμοποιώντας το JFace, την προσθήκη μενού, γραμμής κατάστασης και γραμμής εργαλείων σε αυτό.

Ρύθμιση έργου

Προκειμένου να αναπτυχθεί γραφικές εφαρμογέςχρησιμοποιώντας το JFace στο Eclipse, πρέπει να συμπεριλάβετε τα αρχεία jar SWT και JFace.

  • Εάν το PDE είναι εγκατεστημένο στο Eclipse, αυτό μπορεί να γίνει καθορίζοντας στις ρυθμίσεις του έργου τη χρήση της βιβλιοθήκης SWT και επιλέγοντας το πλαίσιο για υποστήριξη JFace.
  • Εάν το PDE δεν είναι εγκατεστημένο, τότε πρέπει να συνδέσετε τα αρχεία jar στο έργο με μη αυτόματο τρόπο. Μπορείτε να τα βρείτε στον κατάλογο προσθηκών Eclipse, ονομάζονται org.eclipse.swt_*.jar και org.eclipse.jface_*.jar

Δημιουργία παραθύρου

Το παράθυρο εφαρμογής στο JFace κληρονομείται από την κλάση ApplicationWindow, η οποία παρέχει δυνατότητες δημιουργίας μενού, πινάκων ελέγχου και γραμμών κατάστασης.

Ο απλούστερος τρόπος για να δημιουργήσετε ένα παράθυρο δίνεται στο ακόλουθο παράδειγμα:

εισαγωγή org.eclipse.jface.window.ApplicationWindow; εισαγωγή org.eclipse.swt.widgets.Display; δημόσια κλάση MainWindow επεκτείνει ApplicationWindow ( public static void main(String args) ( MainWindow window = new MainWindow(); // Create your window window.setBlockOnOpen(true); // Ορίστε τη σημαία - περιμένετε να κλείσει το παράθυρο window.open ()

Δημιουργία περιεχομένου παραθύρου

Για να δημιουργήσετε κάποιο περιεχόμενο παραθύρου, πρέπει να παρακάμψετε τη μέθοδο Control createContents(Composite parent) της κλάσης ApplicationWindow. Η μέθοδος πρέπει να επιστρέψει ένα στοιχείο που θα είναι το περιεχόμενο του παραθύρου.

Στην ίδια μέθοδο, μπορείτε να ορίσετε τον τίτλο του παραθύρου καλώντας τη μέθοδο setText(String text) του κελύφους, προσβάσιμη καλώντας την getShell()

Σε αυτό το παράδειγμα, ένα τέτοιο στοιχείο θα είναι απλώς ένα λευκό σημάδι σε πραγματικές εφαρμογές, ένα τέτοιο στοιχείο θα είναι κάποιο είδος σύνθετου.

Πράγματι, ένα παράδειγμα:

προστατευμένο Έλεγχος createContents(Composite parent) ( getShell().setText("My window"); // Ορισμός του τίτλου του παραθύρου Label lbl = new Label(parent, SWT.NONE); // Δημιουργία νέο στοιχείο, στην περίπτωσή μας - μόνο μια ετικέτα lbl.setText("Περιεχόμενα παραθύρου"); // Ορίστε το κείμενο για αυτό lbl.setBackground(new Color(Display.getCurrent(), 255, 255, 255)); // Εγκατάσταση λευκόεπιστροφή φόντου lbl? )

Προσθήκη γραμμής κατάστασης

Η προσθήκη μιας γραμμής κατάστασης στο παράθυρο της εφαρμογής δεν είναι εύκολη, αλλά πολύ απλή. Για να το κάνετε αυτό, πρέπει απλώς να καλέσετε την προστατευμένη μέθοδο addStatusBar(). Πιθανώς το καταλληλότερο μέρος για μια τέτοια κλήση είναι ο κατασκευαστής παραθύρου ή κάποια μέθοδος προετοιμασίας του.

Για να εμφανιστεί κείμενο στη γραμμή κατάστασης, πρέπει να καλέσετε τη μέθοδο setStatus(String status), το όρισμα της οποίας είναι η ίδια η συμβολοσειρά που πρέπει να εμφανιστεί.

Δημιουργία μενού

Για να δημιουργήσετε μια γραμμή μενού στο JFace, πρέπει να καλέσετε τη μέθοδο addMenuBar(), όπως ακριβώς και να δημιουργήσετε μια γραμμή κατάστασης.
Στη συνέχεια, όμως, πρέπει να προσθέσετε στοιχεία μενού στον πίνακα. Αυτό γίνεται ως εξής:

  • Η ενότητα μενού περιγράφεται από την κλάση MenuManager. Στον κατασκευαστή, μπορεί να περάσει μια συμβολοσειρά - το όνομα της ενότητας, όπου ο χαρακτήρας "&" σημαίνει ότι ο χαρακτήρας που ακολουθεί θα είναι το κλειδί κατά την πλοήγηση χρησιμοποιώντας το πλήκτρο Alt. Μια ενότητα μενού προστίθεται στον πίνακα χρησιμοποιώντας την κατασκευή getMenuBar().add(menu).
  • Το στοιχείο μενού περιγράφεται από την κλάση Action. Η ίδια η κλάση είναι αφηρημένη, το στοιχείο μενού πρέπει να κληρονομήσει από αυτήν και να παρακάμψει τη μέθοδο void run(), η οποία φιλοξενεί τον κώδικα που εκτελείται όταν ο χρήστης επιλέγει ένα στοιχείο μενού. Στην πραγματικότητα, η μέθοδος δεν χρειάζεται να παρακαμφθεί, αλλά τότε γιατί χρειάζεται αυτό το στοιχείο μενού =) Το όνομα του στοιχείου μπορεί να οριστεί περνώντας το στον κατασκευαστή ή καλώντας τη μέθοδο void setText(String text). Μόλις δημιουργηθεί, ένα στοιχείο μενού προστίθεται στην ενότητα καλώντας τη μέθοδο προσθήκης στο αντικείμενο της ενότητας μενού. Για παράδειγμα: menu.add(menuItem)
  • Τα υπομενού δημιουργούνται πολύ απλά: Πρέπει να προσθέσετε μια άλλη ενότητα σε μια ενότητα του μενού χρησιμοποιώντας τη μέθοδο προσθήκης. Αυτό είναι όλο.

Στο παρακάτω παράδειγμα, δημιουργούμε μια ενότητα μενού Αρχείο και ένα στοιχείο Hello σε αυτό, η επιλογή του οποίου προκαλεί την εμφάνιση κειμένου στη γραμμή κατάστασης του παραθύρου. Μορφοποίησα τον κώδικα δημιουργίας μενού σε μία μέθοδο, η οποία καλείται από τον κατασκευαστή παραθύρου:

private void createMenu() ( addMenuBar(); // Προσθήκη γραμμής μενού MenuManager fileMenu = new MenuManager("&File"); // Δημιουργία νέου μενού getMenuBarManager().add(fileMenu); // Προσθήκη μενού στον πίνακα fileMenu.add( new Separator() // Προσθήκη διαχωριστικού στο μενού fileMenu.add(new Action("&Hello") ( // Δημιουργήστε μια νέα ενέργεια, καθορίστε το κείμενό της @Override public void run() ( // Ο κώδικας εκτελείται όταν η ενέργεια είναι ενεργοποιημένη setStatus( "Hello world!!") Εμφανίζουμε απλώς τη νέα τιμή στη γραμμή κατάστασης ))

Δημιουργία γραμμής εργαλείων

Για να δημιουργήσετε μια γραμμή εργαλείων σε ένα παράθυρο, πρέπει να καλέσετε τη μέθοδο addToolBar(int style) στον κατασκευαστή παραθύρου, στην οποία μεταβιβάζετε το στυλ του στοιχείου του πίνακα.

Για πρόσβαση στη γραμμή που δημιουργήθηκε, χρησιμοποιείται η μέθοδος getToolBarManager(). Για να προσθέσετε μια ενέργεια σε ένα πλαίσιο, χρησιμοποιήστε τη μέθοδο προσθήκης του πίνακα όπου αποστέλλεται η ενέργεια.

Στην απλούστερη περίπτωση, η δημιουργία ενός πίνακα και η προσθήκη ενός κουμπιού σε αυτό θα μοιάζει με αυτό:

private void createToolBar() ( addToolBar(SWT.NONE); getToolBarManager().add(new Action("&Hello") ( // Δημιουργία νέας ενέργειας, προσδιορίστε το κείμενό της @Override public void run() ( // Ο κώδικας εκτελείται κατά ενέργειες ενεργοποίησης setStatus("Hello world!!" // Εμφανίζουμε απλώς τη νέα τιμή στη γραμμή κατάστασης ) );

Δημιουργία πολλαπλών πλωτών γραμμών εργαλείων

Αντί για μία γραμμή εργαλείων, μπορείτε να δημιουργήσετε ένα σύνολο κινητών πλαισίων (CoolBar). Για να το κάνετε αυτό χρειάζεστε:

  1. Αντί για τη μέθοδο addToolBar, καλέστε τη μέθοδο addCoolBar
  2. Για πρόσβαση σε ένα σύνολο πινάκων, χρησιμοποιήστε τη μέθοδο getCoolBarManager().
  3. Δημιουργήστε μια γραμμή εργαλείων στην οποία μπορείτε να προσθέσετε ενέργειες. Για να το κάνετε αυτό, πρέπει να δημιουργήσετε μια νέα παρουσία της κλάσης ToolBarManager που θα αντιπροσωπεύει τον πίνακα και θα καλέσετε τη μέθοδο προσθήκης CoolBarManager, περνώντας τον πίνακα εκεί.
  4. Μπορείτε να προσθέσετε ενέργειες στον πίνακα που δημιουργήθηκε

Παράδειγμα κώδικα που δημιουργεί δύο αιωρούμενους πίνακες:

private void createCoolbar() ( addCoolBar(SWT.NONE); ToolBarManager tm = new ToolBarManager(); getCoolBarManager().add(tm); tm.add(helloAction); ToolBarManager tm2 = new ToolBarManager(); anagerger().dM (tm2);

Σπουδαίος! Ένα παράθυρο εφαρμογής μπορεί να έχει είτε έναν πίνακα ελέγχου είτε ένα σύνολο κινητών, η προσπάθεια δημιουργίας και των δύο θα οδηγήσει σε σφάλμα!

Πιθανά προβλήματα

Ακολουθούν ορισμένα προβλήματα που μπορεί να αντιμετωπίσετε:

  • Κατά την προσθήκη στοιχείων μενού μετά την εκκίνηση της εφαρμογής, δεν εμφανίζονται— για να αντικατοπτρίζονται οι αλλαγές μενού στο παράθυρο μετά τη δημιουργία του παραθύρου, πρέπει να καλέσετε τη μέθοδο getMenuBarManager().update(true)— καθορίστε για ενημέρωση της γραμμής μενού.

Εδαφος διά παιγνίδι γκολφ

Πρόσθετες πληροφορίες για το JFace μπορείτε να βρείτε στους παρακάτω συνδέσμους:

  • Εισαγωγικό άρθρο στη ρωσική γλώσσα στο ibm.com
  • Μια σειρά άρθρων στην αγγλική γλώσσα στο ibm.com
  • Περιγραφή του Eclipse API - μεταξύ άλλων, υπάρχουν πακέτα που σχετίζονται με το SWT και το JFace

Μια φόρμα οθόνης είναι μια περιοχή που είναι ορατή στην οθόνη με τη μορφή παραθύρου με διάφορα στοιχεία - κουμπιά, κείμενο, αναπτυσσόμενες λίστες κ.λπ. Και αυτά τα στοιχεία ονομάζονται συστατικά.

Τα περιβάλλοντα που σας επιτρέπουν να τοποθετείτε διαδραστικά στοιχεία σε φόρμες και να ορίζετε τις παραμέτρους τους κατά την ανάπτυξη εφαρμογών ονομάζονται περιβάλλοντα RAD. Το RAD σημαίνει Rapid Ανάπτυξη Εφαρμογών- γρήγορη ανάπτυξη εφαρμογών.

Στο NetBeans και σε άλλα σύγχρονα περιβάλλοντα ανάπτυξης, αυτή η διαδικασία βασίζεται στο μοντέλο αντικειμένου συστατικού, γι' αυτό και ονομάζεται Αντικειμενοστραφής Σχεδίαση (OOD).

Το NetBeans είναι ένα περιβάλλον RAD που σας επιτρέπει να δημιουργείτε γρήγορα και εύκολα εφαρμογές με πλούσιο γραφικό περιβάλλον χρήστη (GUI). Αν και οι δομές γλώσσας Java που σας επιτρέπουν να το κάνετε αυτό δεν είναι πολύ απλές, αρχικό στάδιοδουλεύοντας με φόρμες οθόνης και τα στοιχεία τους, δεν χρειάζεται να εμβαθύνουμε σε αυτές τις λεπτότητες. Αρκεί να γνωρίζουμε τις βασικές αρχές της εργασίας με τέτοια έργα.

Πρώτον, από την αρχή μαθαίνετε πώς να δημιουργείτε πλήρεις εφαρμογές που μπορούν να χρησιμοποιηθούν για χρήσιμους σκοπούς. Είναι δύσκολο να μελετάς για μήνες αφηρημένες έννοιες, και μόνο με το να γίνεις επαγγελματίας θα μπορέσεις να κάνεις κάτι που μπορεί να φανεί στους άλλους. Είναι πολύ πιο ενδιαφέρον και χρήσιμο να αρχίσουμε αμέσως να εφαρμόζουμε τις γνώσεις που αποκτήθηκαν στην πράξη.

Δεύτερον, μια τέτοια διεπαφή, κατά την επίλυση οποιουδήποτε προβλήματος, σας επιτρέπει να διαμορφώσετε καλύτερα ποιες παραμέτρους πρέπει να εισαχθούν, ποιες ενέργειες πρέπει να εκτελεστούν και με ποια σειρά και τι τελικά λαμβάνεται. Και εμφανίστε όλα αυτά στην οθόνη: τα στοιχεία εισαγωγής κειμένου θα αντιστοιχούν στις εισαγόμενες παραμέτρους, τα κουμπιά και τα στοιχεία μενού θα αντιστοιχούν σε ενέργειες, τα στοιχεία εξόδου κειμένου θα αντιστοιχούν στα αποτελέσματα.

Παράδειγμα ανοίγματος έργου με υπάρχον πηγαίος κώδικας.

Το NetBeans 5.0 είχε καλό παράδειγμαΕφαρμογές GUI, ωστόσο δεν είναι διαθέσιμο στο NetBeans 5.5. Επομένως για περαιτέρω εργασίαΘα πρέπει να αντιγράψετε ένα παρόμοιο παράδειγμα από τον ιστότοπο του συγγραφέα ή τον ιστότοπο στον οποίο δημοσιεύεται αυτό το εκπαιδευτικό σεμινάριο. Το παράδειγμα ονομάζεται JavaApplicationGUI_example.

Αρχικά, θα πρέπει να αποσυσκευάσετε το αρχείο zip και να εξαγάγετε το φάκελο με τα αρχεία του έργου που βρίσκονται σε αυτό στον φάκελο με τα έργα σας (για παράδειγμα, C:\Documents and Settings\User). Στη συνέχεια, ξεκινήστε το περιβάλλον NetBeans αν δεν εκτελούσε ήδη και κλείστε τυχόν ανοιχτά έργα για να τα κρατήσετε μακριά. Στη συνέχεια, επιλέξτε Αρχείο/Άνοιγμα έργου από το μενού ή το εικονίδιο με έναν ανοιγόμενο μωβ φάκελο στη γραμμή εργαλείων ή πατήστε το συνδυασμό πλήκτρων ++Ο. Στο παράθυρο διαλόγου που ανοίγει, επιλέξτε έναν φάκελο JavaApplicationGUI_example(είναι καλύτερα να μην μπείτε σε αυτό, αλλά απλώς ορίστε την επιλογή σε αυτόν τον φάκελο) και, στη συνέχεια, κάντε κλικ στο κουμπί Άνοιγμα φακέλου έργου.

Σε αυτήν την περίπτωση, εάν δεν καταργήσετε την επιλογή του πλαισίου ελέγχου "Άνοιγμα ως κύριο έργο", το έργο γίνεται αυτόματα το κύριο.

Το ακόλουθο κείμενο εμφανίζεται στο παράθυρο του προγράμματος επεξεργασίας πηγαίου κώδικα:

* GUI_application.java

πακέτο java_gui_example;

* @συγγραφέας Vadim Monakhov

δημόσιας κλάσης GUI_application επεκτείνει το javax.swing.JFrame (

* Δημιουργεί νέα φόρμα GUI_application

δημόσιο GUI_application() (

initComponents();

/** Αυτή η μέθοδος καλείται από τον κατασκευαστή στο

* αρχικοποίηση της φόρμας.

* ΠΡΟΕΙΔΟΠΟΙΗΣΗ: ΜΗΝ τροποποιήσετε αυτόν τον κωδικό. Το περιεχόμενο αυτής της μεθόδου είναι

* ανανεώνεται πάντα από τον Επεξεργαστή Φόρμας.

private void exitMenuItemActionPerformed(java.awt.event.ActionEvent evt)

* @param ορίζει τα ορίσματα της γραμμής εντολών

δημόσιο στατικό κενό main (String args) (

java.awt.EventQueue.invokeLater(new Runnable() (

public void run() (

new GUI_application().setVisible(true);

// Δήλωση μεταβλητών - να μην τροποποιηθεί

private javax.swing.JMenuItem aboutMenuItem;

private javax.swing.JMenuItem contentsMenuItem;

private javax.swing.JMenuItem copyMenuItem;

private javax.swing.JMenuItem cutMenuItem;

private javax.swing.JMenuItem deleteMenuItem;

private javax.swing.JMenu editMenu;

private javax.swing.JMenuItem exitMenuItem;

private javax.swing.JMenu fileMenu;

private javax.swing.JMenu helpMenu;

private javax.swing.JMenuBar menuBar;

private javax.swing.JMenuItem openMenuItem;

private javax.swing.JMenuItem pasteMenuItem;

private javax.swing.JMenuItem saveAsMenuItem;

private javax.swing.JMenuItem saveMenuItem;

// Δήλωση τέλους μεταβλητών

Ας εξηγήσουμε μερικά από τα μέρη του. Είμαστε ήδη εξοικειωμένοι με τον καθορισμό του πακέτου java_gui_example στο οποίο θα βρίσκεται ο κωδικός κλάσης εφαρμογής. Δήλωση της ίδιας της κλάσης GUI_application στο σε αυτή την περίπτωσηλίγο πιο περίπλοκο από πριν:

Η δημόσια κλάση GUI_application επεκτείνει το javax.swing.JFrame

Σημαίνει ότι ορίζεται η δημόσια κλάση GUI_application, η οποία είναι απόγονος της κλάσης JFrame που ορίζεται στο πακέτο swing, που είναι ένθετη στο πακέτο javax. Η λέξη επεκτείνεται μεταφράζεται ως «επεκτείνεται» (μια τάξη απογόνων επεκτείνει πάντα τις δυνατότητες της τάξης των προγόνων).

Ο δημόσιος κατασκευαστής GUI_application() δημιουργεί ένα αντικείμενο εφαρμογής και προετοιμάζει όλα τα στοιχεία του χρησιμοποιώντας τη μέθοδο initComponents(), η οποία δημιουργείται αυτόματα από το περιβάλλον ανάπτυξης και κρύβεται στον πηγαίο κώδικα από τον κόμβο +Generated Code.

Με την επέκταση του κόμβου, μπορείτε να δείτε την υλοποίηση αυτής της μεθόδου, αλλά δεν μπορείτε να αλλάξετε τον κώδικα. Δεν θα σταθούμε στο τι γίνεται σε αυτό.

ιδιωτικό κενό exitMenuItemActionPerformed

Θα συζητηθεί λίγο αργότερα. Μέθοδος

δημόσιο στατικό κενό κύριο (Args συμβολοσειράς)

είμαστε ήδη εξοικειωμένοι με αυτό – αυτή είναι η κύρια μέθοδος της εφαρμογής. Είναι μια μέθοδος της κλάσης εφαρμογών μας και εκτελείται αυτόματα από το μηχάνημα Java όταν ξεκινά η εφαρμογή. ΣΕ σε αυτό το παράδειγμαΗ μέθοδος δημιουργεί μια φόρμα οθόνης για την εφαρμογή και την κάνει ορατή. Για να καταλάβετε πώς γίνεται αυτό, θα χρειαστεί να μελετήσετε αρκετό υλικό σε αυτό το μάθημα.

Εκτελούμενη εφαρμογή. Μια εφαρμογή με διευρυμένο μενού.

Όταν ξεκινά η εφαρμογή, η φόρμα οθόνης μοιάζει με αυτή που φαίνεται στο σχήμα. Έχει ήδη ένα πρότυπο μενού που μπορεί να επεκταθεί και να συμπτυχθεί, ακόμη και το στοιχείο Έξοδος λειτουργεί. Κάνοντας κλικ σε αυτό βγαίνεις από την εφαρμογή.

Ο τελεστής exitMenuItemActionPerformed είναι υπεύθυνος για κλικ σε αυτό το στοιχείο μενού. Κατά το σχεδιασμό μιας φόρμας οθόνης, εκχωρείται ως χειριστής συμβάντων– μια υπορουτίνα που εκτελείται όταν συμβαίνει ένα συμβάν. Στην περίπτωσή μας, το συμβάν είναι η επιλογή του στοιχείου μενού Έξοδος και καλείται ο χειριστής exitMenuItemActionPerformed. Υπάρχει μόνο μία γραμμή μέσα του

Προκαλεί τη διακοπή της εκτέλεσης κύρια μέθοδοςκαι έξοδος από την εφαρμογή με κωδικό εξόδου μηδέν. Κατά κανόνα, ένας μη μηδενικός κωδικός εξόδου επιστρέφεται όταν μια εφαρμογή τερματίζεται ασυνήθιστα, έτσι ώστε η τιμή του να μπορεί να χρησιμοποιηθεί για τον προσδιορισμό των αιτιών της διακοπής λειτουργίας του προγράμματος.

Επεξεργαστής οθόνης

Κάντε κλικ στην καρτέλα Σχεδίαση στο επάνω αριστερό μέρος του προγράμματος επεξεργασίας πηγαίου κώδικα. Ταυτόχρονα, θα μεταβούμε από τη λειτουργία επεξεργασίας πηγαίου κώδικα (η καρτέλα Πηγή είναι ενεργή) στη λειτουργία επεξεργασίας φόρμας οθόνης, όπως φαίνεται στο σχήμα.

Επεξεργασία φόρμας οθόνης.

Αντί για τον πηγαίο κώδικα, εμφανίζεται η εμφάνιση της φόρμας οθόνης και τα στοιχεία που βρίσκονται σε αυτήν. Στα δεξιά του παραθύρου στο οποίο εμφανίζεται η φόρμα οθόνης σε λειτουργία επεξεργασίας, υπάρχουν τα παράθυρα Palette για την παλέτα στοιχείων και το παράθυρο Ιδιότητες για την εμφάνιση και την επεξεργασία των ιδιοτήτων του τρέχοντος στοιχείου.

Μια ιδιότητα είναι ένα πεδίο δεδομένων που μπορεί να εκτελέσει κάποια ενέργεια αφού αλλάξει την τιμή του. Για παράδειγμα, όταν αλλάζετε την τιμή του πλάτους ενός στοιχείου, σχεδιάστε το στοιχείο με το νέο πλάτος στην οθόνη. Ένα "κανονικό" πεδίο δεδομένων δεν είναι ικανό για αυτό. Έτσι, μια ιδιότητα είναι ένα "έξυπνο πεδίο δεδομένων".

Η παλέτα στοιχείων έχει σχεδιαστεί για να επιλέγει τον τύπο στοιχείου που πρέπει να τοποθετήσει ο προγραμματιστής στη φόρμα οθόνης. Για παράδειγμα, ας προσθέσουμε στη φόρμα μας ένα στοιχείο τύπου JButton (συντομογραφία του Java Button - «κουμπί Java»). Για να το κάνετε αυτό, κάντε κλικ στο στοιχείο JButton στην παλέτα και μετακινήστε το ποντίκι στην επιθυμητή θέση στη φόρμα οθόνης. Όταν το ποντίκι χτυπήσει μια περιοχή της φόρμας οθόνης, εμφανίζεται ένα κουμπί τυπικού μεγέθους, το οποίο κινείται με το ποντίκι. Κάντε κλικ μέσα στο σωστό μέροςφόρμα κάνει το κουμπί να παραμείνει σε αυτήν τη θέση. Ένα πλαίσιο και μικρά τετράγωνα εμφανίζονται γύρω του, υποδεικνύοντας ότι το στοιχείο μας είναι επιλεγμένο. Οι ιδιότητες για αυτό εμφανίζονται και επεξεργάζονται στο παράθυρο Ιδιότητες.

Επιπλέον, οι γραμμές προέρχονται από το επιλεγμένο στοιχείο, στο οποίο υπάρχει ένα κουμπάκι για να ορίσετε τη θέση του στοιχείου στη φόρμα.

Από προεπιλογή, οι ετικέτες στοιχείων καθορίζονται ως το όνομα τύπου ακολουθούμενο από τον αριθμό του στοιχείου. Αλλά αντί για κεφαλαίο γράμμα, σε αντίθεση με το όνομα του τύπου, χρησιμοποιείται ένα πεζό γράμμα. Επομένως, το πρώτο κουμπί θα φέρει την ετικέτα jButton1, το δεύτερο - jButton2 και ούτω καθεξής. Οι μεταβλητές που αντιστοιχούν σε κουμπιά που δημιουργούνται αυτόματα στον πηγαίο κώδικα θα έχουν τα ίδια ονόματα.

Υπάρχουν διάφοροι τρόποι για να αλλάξετε την ετικέτα σε ένα κουμπί. Πρώτα, κάντε διπλό κλικ πάνω του και επεξεργαστείτε το κείμενο. Δεύτερον, πηγαίνοντας στο παράθυρο Ιδιότητες, αλλάζοντας την τιμή της ιδιότητας Κείμενο και κάνοντας κλικ για να ολοκληρώσετε την καταχώρηση. Τρίτον, αλλάζοντας την ιδιότητα της ετικέτας με τον ίδιο τρόπο. Τέλος, στο παράθυρο Ιδιότητες μπορείτε να επεξεργαστείτε κείμενο όχι σε πεδίο εισαγωγής τιμής μίας γραμμής για τις ιδιότητες Κείμενο ή ετικέτα, αλλά ανοίγοντας έναν επεξεργαστή πολλαπλών γραμμών κάνοντας κλικ στο κουμπί στα δεξιά του στοιχείου επεξεργασίας τιμής ιδιότητας. Ωστόσο, η φύση πολλών γραμμών του προγράμματος επεξεργασίας δεν βοηθά στο να γίνει η ετικέτα στο κουμπί πολλαπλών γραμμών.

Πληκτρολογήστε "OK" στο κουμπί - χρησιμοποιήστε αυτό το κουμπί για να βγείτε από το πρόγραμμα.

Επεξεργασία ιδιοτήτων συστατικού

Το μέγεθος του εξαρτήματος ρυθμίζεται με το ποντίκι πιάνοντας το πλαίσιο και επεκτείνοντας ή συστέλλοντας προς τις κατάλληλες κατευθύνσεις. Εγκατάσταση σε νέα θέση σύροντας το στοιχείο με το ποντίκι.

Ορισμένες ιδιότητες του επιλεγμένου στοιχείου (μέγεθος, θέση, κείμενο) μπορούν να αλλάξουν απευθείας στην περιοχή εμφάνισης. Ωστόσο, οι περισσότερες ιδιότητες προβάλλονται και αλλάζουν στο παράθυρο Επεξεργασία Ιδιοτήτων. Αποτελείται από δύο στήλες: η αριστερή δείχνει τα ονόματα των ιδιοτήτων, η δεξιά δείχνει τις τιμές τους. Οι τιμές στη δεξιά στήλη μπορούν σε πολλές περιπτώσεις να επεξεργαστούν απευθείας στα κελιά του πίνακα. Σε αυτήν την περίπτωση, η είσοδος τελειώνει πατώντας ή βγαίνετε από το επεξεργασμένο κελί και μπορείτε να ακυρώσετε τα αποτελέσματα της ημιτελούς εισαγωγής πατώντας .

Στη δεξιά πλευρά κάθε κελιού υπάρχει ένα κουμπί με την ένδειξη "..." - στα σύγχρονα λειτουργικά συστήματα είναι συνηθισμένο να προσθέτετε τρεις κουκκίδες στα ονόματα των στοιχείων μενού και των κουμπιών, αφού κάνετε κλικ στο οποίο ανοίγει ένα παράθυρο διαλόγου. Σε αυτήν την περίπτωση, ανοίγει το παράθυρο του εξειδικευμένου επεξεργαστή για την αντίστοιχη ιδιότητα, εάν υπάρχει.

Εάν χρειάζεται να προβάλετε και να επεξεργαστείτε μεγάλο αριθμό ιδιοτήτων στοιχείων, ίσως είναι πιο βολικό να κάνετε δεξί κλικ το απαιτούμενο εξάρτημακαι επιλέξτε «Ιδιότητες» από το αναδυόμενο μενού που εμφανίζεται. Σε αυτήν την περίπτωση, θα ανοίξει ένα ξεχωριστό παράθυρο για την επεξεργασία των ιδιοτήτων του στοιχείου. Μπορείτε να διατηρήσετε έναν αυθαίρετο αριθμό τέτοιων παραθύρων ανοιχτά ταυτόχρονα.

Οι δυαδικές ιδιότητες στη στήλη της τιμής της ιδιότητας εμφανίζονται ως κουμπιά επιλογής πλαισίου ελέγχου - τετράγωνα με τη δυνατότητα να τοποθετήσετε ένα σημάδι επιλογής μέσα. Εάν δεν υπάρχει σημάδι επιλογής, η τιμή της ιδιότητας είναι false.

Χρησιμοποιώντας ένα κουμπί ως παράδειγμα, παραθέτουμε έναν αριθμό από μερικές από τις πιο σημαντικές ιδιότητες που μπορούν να οριστούν για στοιχεία. Πολλά από αυτά ισχύουν και για άλλα εξαρτήματα.

Όνομα ακινήτου Τι ζητάει;
φόντο Χρώμα φόντου
componentPopupMenu Σας επιτρέπει να ορίσετε ένα αναδυόμενο μενού που εμφανίζεται όταν κάνετε δεξί κλικ στην περιοχή στοιχείων.
γραμματοσειρά Η γραμματοσειρά που χρησιμοποιείται για την εγγραφή στο στοιχείο.
προσκήνιο Το χρώμα της γραμματοσειράς που χρησιμοποιείται για την επιγραφή στο στοιχείο.
εικόνισμα Μια εικόνα που σχεδιάζεται στο στοιχείο δίπλα στο κείμενο.
κείμενο Κείμενο (ετικέτα) στο στοιχείο.
toolTipText Μια επεξήγηση εργαλείου που εμφανίζεται μετά από λίγο όταν τοποθετείτε το ποντίκι πάνω από ένα στοιχείο.
σύνορο Ο τύπος πλαισίου γύρω από το εξάρτημα.
περιγράμματος ζωγραφισμένο Εάν σχεδιάζεται ένα περίγραμμα γύρω από το στοιχείο.
Περιεχόμενο AreaFilled Υπάρχει γέμιση χρώματος; εσωτερική περιοχήσυστατικό (για κουμπιά δημιουργεί ένα τρισδιάστατο εφέ· χωρίς γέμισμα, το κουμπί φαίνεται επίπεδο).
defaultCapable Μπορεί το κουμπί να είναι "προεπιλεγμένο κουμπί": όταν πατηθεί Το "προεπιλεγμένο κουμπί" πατιέται αυτόματα (θα πρέπει να υπάρχει ένα τέτοιο κουμπί στη φόρμα οθόνης).
ενεργοποιημένη Εάν το εξάρτημα είναι διαθέσιμο. Από προεπιλογή, όλα τα στοιχεία που δημιουργούνται στη φόρμα είναι διαθέσιμα. Τα απρόσιτα εξαρτήματα βάφονται με πιο θαμπά χρώματα.

Για παράδειγμα, ας προσθέσουμε μια συμβουλή εργαλείου για το κουμπί μας: πληκτρολογήστε το κείμενο "Αυτό το κουμπί προορίζεται για έξοδο από το πρόγραμμα" στο πεδίο που αντιστοιχεί στην ιδιότητα toolTipText. Δυστυχώς, η υπόδειξη μπορεί να είναι μόνο μίας γραμμής - μετάφραση χαρακτήρων σε νέα γραμμήΌταν εμφανίζονται, οι υποδείξεις αγνοούνται, ακόμα κι αν έχουν καθοριστεί μέσω προγραμματισμού στη γραμμή.

Τέλος, ας ορίσουμε την ενέργεια που θα εκτελείται όταν πατηθεί το κουμπί - χειριστής συμβάντωνκλικ στο κουμπί (χειριστής συμβάντων). Για να το κάνετε αυτό, επιλέξτε πρώτα το κουμπί, μετά κάντε δεξί κλικ πάνω του και στο αναδυόμενο μενού που εμφανίζεται, επιλέξτε Events/Action/ActionPerformed.

Εκχώρηση ενός διαχειριστή συμβάντων

Γεγονότα σημαίνει "Γεγονότα", Δράση σημαίνει "Δράση", actionPerformed σημαίνει "εκτελεσθείσα ενέργεια".

Μετά από αυτό θα συμβεί αυτόματη μετάβασηστο πρόγραμμα επεξεργασίας πηγαίου κώδικα και ένας χειριστής συμβάντων προτύπου θα εμφανιστεί εκεί:

// TODO προσθέστε τον κωδικό χειρισμού σας εδώ:

Ένα παρόμοιο αποτέλεσμα μπορεί να επιτευχθεί με πιο γρήγορο τρόπο - αφού επιλέξουμε ένα κουμπί στο παράθυρο επεξεργασίας φόρμας (Σχεδίαση), το όνομα αυτού του κουμπιού εμφανίζεται και επισημαίνεται στο παράθυρο του Navigator. Κάνοντας διπλό κλικ σε αυτό το όνομα στο παράθυρο του προγράμματος πλοήγησης οδηγεί στη δημιουργία ενός προγράμματος χειρισμού συμβάντων προτύπου.

Δίπλα στο πρόγραμμα χειρισμού jButton1ActionPerformed θα υπάρχει ένας υπάρχων χειριστής συμβάντων που ενεργοποιείται όταν κάνετε κλικ στο στοιχείο μενού "Έξοδος":

private void exitMenuItemActionPerformed(java.awt.event.ActionEvent evt) (

Ας αντικαταστήσουμε τη γραμμή με το σχόλιο στο πρόγραμμα χειρισμού συμβάντων με τον κωδικό που προκαλεί την έξοδο του προγράμματος:

ιδιωτικό void jButton1ActionPerformed(java.awt.event.ActionEvent evt) (

Τώρα, μετά την εκκίνηση της εφαρμογής μας, μετακινώντας τον κέρσορα του ποντικιού στο κουμπί θα εμφανιστεί μια επεξήγηση εργαλείου και κάνοντας κλικ στο κουμπί θα βγείτε από το πρόγραμμα.

Μια συνηθισμένη περίπτωση είναι η εμφάνιση ενός μηνύματος όταν συμβαίνει ένα συμβάν, για παράδειγμα, το πάτημα ενός κουμπιού. Σε αυτήν την περίπτωση, ο πίνακας καλείται με το μήνυμα:

javax.swing.JOptionPane.showMessageDialog(null,"Με έκαναν κλικ");

Εάν εισάγονται οι κατηγορίες πακέτων javax.swing, το πρόθεμα javax.swing δεν χρειάζεται κατά την κλήση τους.

Εμφάνιση εφαρμογής

Στο στάδιο της επεξεργασίας της εφαρμογής, η εμφάνιση των στοιχείων της αντιστοιχεί στην πλατφόρμα. Ωστόσο, μόλις ξεκινήσει, γίνεται εντελώς διαφορετικό, αφού από προεπιλογή, όλες οι εφαρμογές Java εμφανίζονται με τρόπο ανεξάρτητο από την πλατφόρμα:

Εμφάνιση εκτελούμενη εφαρμογήμε προεπιλεγμένη διεπαφή χρήστη ανεξάρτητη από την πλατφόρμα

Επιπλέον, η εφαρμογή μας εμφανίζεται στα αριστερά πάνω γωνίαοθόνη, αλλά θα ήθελα να εμφανίζεται στο κέντρο.

Για να εμφανιστεί η εφαρμογή σε μορφή συγκεκριμένης πλατφόρμας (δηλαδή στη μορφή που χρησιμοποιεί τα στοιχεία και τις ρυθμίσεις του λειτουργικού συστήματος), πρέπει να αλλάξετε τον κώδικα κατασκευής της εφαρμογής εισάγοντας έναν τύπο διεπαφής χρήστη (Διασύνδεση χρήστη, συντομογραφία UI) πριν καλέσετε τη μέθοδο initComponents:

εισαγωγή javax.swing.*;

εισαγωγή java.awt.*;

δημόσιο GUI_application() (

UIManager.setLookAndFeel(UImanager.getSystemLookAndFeelClassName());

)catch(Exception e)();

initComponents();

Διάσταση screenSize = Toolkit.getDefaultToolkit().getScreenSize();

Διάσταση frameSize = getSize();

setLocation(new Point((screenSize.width-frameSize.width)/2,

(screenSize.height-frameSize.width)/2)

Εμφάνιση εφαρμογής σε λειτουργία με διεπαφή χρήστη προσανατολισμένη στην πλατφόρμα στο χειρουργείο Σύστημα Windows ® XP

Ο κώδικας που ακολουθεί την κλήση initComponents() είναι να ρυθμίσετε το παράθυρο της εφαρμογής στο κέντρο της οθόνης.

Είναι δυνατό να καθοριστεί ένας άλλος τύπος εφαρμογής ανεξάρτητος από την πλατφόρμα - στο στυλ Motiff που χρησιμοποιείται σε λειτουργικό σύστημα Solaris®. Για να ορίσετε αυτόν τον τύπο αντί για κλήση

UIManager.setLookAndFeel(UImanager.getSystemLookAndFeelClassName()

Θα πρέπει να γραφτεί

UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");

Εμφάνιση εκτελούμενης εφαρμογής με διεπαφή χρήστη ανεξάρτητη από πλατφόρμα σε στυλ Motiff

Οι κατασκευές που χρησιμοποιούνται θα γίνουν σαφείς στον αναγνώστη αφού μελετήσει περαιτέρω ενότητες του εγχειριδίου.

Διαχείριση έργου

Για να μην μπερδεύεστε σε διαφορετικά έργα και τις εκδόσεις τους, ειδικά λαμβάνοντας υπόψη το γεγονός ότι τα εκπαιδευτικά έργα συχνά πρέπει να μεταφέρονται από τον έναν υπολογιστή στον άλλο, θα πρέπει να λάβετε σοβαρά υπόψη τη διαχείριση έργων. Ο συγγραφέας, ως αποτέλεσμα πολυετούς εμπειρίας συνεργασίας με διαφορετικές γλώσσεςκαι περιβάλλοντα προγραμματισμού που αναπτύχθηκαν επόμενο σύστημα(διορθώθηκε για να ισχύει για το περιβάλλον NetBeans):

· Για κάθε έργο δημιουργείται ένας φάκελος με το όνομα του έργου. Θα το ονομάσουμε φάκελο αρχειοθέτησης για αυτού του έργου. Τα ονόματα των φακέλων που χρησιμοποιούνται μπορούν να είναι στα ρωσικά, καθώς και τα ονόματα των εφαρμογών και των αρχείων.

· Κατά τη δημιουργία ενός νέου έργου, το περιβάλλον ανάπτυξης σάς ζητά να εισαγάγετε ένα όνομα φακέλου όπου θα το αποθηκεύσετε - θα πρέπει να καθορίσετε το όνομα του φακέλου αρχειοθέτησης. Σας ζητείται επίσης να εισαγάγετε ένα όνομα έργου. Αυτό το όνομα θα χρησιμοποιηθεί από το NetBeans για τη δημιουργία τόσο του φακέλου του έργου όσο και του ονόματος της εφαρμογής σας. Για να διευκολύνετε την εργασία με την εφαρμογή σας στο διαφορετικές χώρες, συνιστάται να κάνετε αυτό το όνομα στα αγγλικά. Στο φάκελο του έργου, το περιβάλλον ανάπτυξης θα δημιουργήσει αυτόματα ένα σύστημα υποφακέλων για το έργο και όλα τα αρχεία του. Η δομή του φακέλου του έργου NetBeans έχει περιγραφεί προηγουμένως.

· Εάν ληφθεί ένα έργο με υπάρχοντα πηγαίο κώδικα, ο φάκελός του αντιγράφεται στον φάκελο αρχειοθέτησής μας είτε χειροκίνητα είτε επιλέγοντας την κατάλληλη ακολουθία ενεργειών στον Οδηγό δημιουργίας έργου NetBeans.

· Όταν λάβετε μια κάπως εφαρμόσιμη έκδοση του έργου, θα πρέπει να δημιουργήσετε ένα αντίγραφο αρχείου του. Για να το κάνετε αυτό, σε ένα ανοιχτό έργο στο παράθυρο «Έργα», απλώς κάντε δεξί κλικ στο όνομα του έργου και επιλέξτε «Αντιγραφή έργου» από το αναδυόμενο μενού που εμφανίζεται. Θα ανοίξει μια φόρμα διαλόγου στην οποία προτείνεται ένα όνομα αντιγράφου που δημιουργείται αυτόματα - μια υπογράμμιση και ένας αριθμός αντιγράφου προστίθενται στο αρχικό όνομα του έργου. Για το πρώτο αντίγραφο είναι _1, για το δεύτερο _2, και ούτω καθεξής. Επιπλέον, ο κύριος φάκελος του αρχείου από προεπιλογή παραμένει ο ίδιος με αυτόν του αρχικού έργου. Κάτι που είναι πολύ βολικό, γιατί καθιστά δυνατή τη δημιουργία αντιγράφου με μόλις τρία κλικ του ποντικιού χωρίς να πληκτρολογήσετε τίποτα από το πληκτρολόγιο.

Δημιουργία αντίγραφο εργασίαςσχέδιο

Το έργο που αντιγράφηκε εμφανίζεται αυτόματα στο παράθυρο "Έργα", αλλά δεν γίνεται το κύριο. Δηλαδή, συνεχίζετε να εργάζεστε με το προηγούμενο έργο και όλα τα ανοιχτά παράθυρά του αποθηκεύονται. Μπορείτε να κλείσετε αμέσως ένα νέο έργο κάνοντας δεξί κλικ στο όνομά του και επιλέγοντας «Κλείσιμο έργου» από το αναδυόμενο μενού που εμφανίζεται.

Γιατί χρειάζεται ένα τέτοιο σύστημα διαχείρισης έργου; Το γεγονός είναι ότι οι αρχάριοι προγραμματιστές έχουν τη συνήθεια να καταστρέφουν τα αποτελέσματα της δουλειάς τους. Αναπτύσσουν το έργο χωρίς να διατηρούν αρχεία. Το φέρνουν σε σχεδόν λειτουργική κατάσταση, μετά το οποίο το βελτιώνουν λίγο περισσότερο, μετά λίγο ακόμα - και όλα σταματούν να λειτουργούν. Και αφού μπερδεύονται εντελώς, δεν υπάρχει τρόπος να επαναφέρετε μια λειτουργική έκδοση. Και δεν έχουν τίποτα να δείξουν στον δάσκαλο ή στο αφεντικό!

Επομένως, θα πρέπει να συνηθίσετε να αντιγράφετε στο αρχείο όλες τις ενδιάμεσες εκδόσεις του έργου που είναι πιο αποτελεσματικές από αυτές που έχουν ήδη αποθηκευτεί στο αρχείο. ΣΕ πραγματικά έργαείναι δύσκολο να θυμηθούμε όλες τις αλλαγές που έγιναν σε μια συγκεκριμένη έκδοση και, το πιο σημαντικό, όλες τις σχέσεις που προκάλεσαν αυτές τις αλλαγές. Επομένως, ακόμη και έμπειροι προγραμματιστές κατά καιρούς πρέπει να παραδεχτούν: "Τίποτα δεν λειτουργεί!" Και επαναφέρετε μια έκδοση που δεν είχε ακόμη εκείνες τις καινοτομίες που οδήγησαν σε σύγχυση. Επιπλέον, συμβαίνει συχνά αυτό νέα έκδοσηΣε ορισμένες περιπτώσεις δεν λειτουργεί σωστά. Και πρέπει να επιστρέψετε σε δεκάδες εκδόσεις αναζητώντας αυτή όπου δεν υπήρχαν τέτοιες «αστοχίες». Και στη συνέχεια συγκρίνετε προσεκτικά τη δουλειά των δύο εκδόσεων, ανακαλύπτοντας τον λόγο της λανθασμένης λειτουργίας της μεταγενέστερης έκδοσης. Ή βεβαιωθείτε ότι όλα είναι προηγούμενες εκδόσειςλειτούργησε επίσης λανθασμένα, απλά δεν παρατήρησαν το σφάλμα.

  • Η εξωτερική πολιτική της ΕΣΣΔ κατά τα χρόνια του πολέμου. Δάνειο-Μίσθωση. Διάσκεψη της Τεχεράνης. Διασκέψεις Γιάλτας και Πότσνταμ 1945 Δημιουργία του ΟΗΕ.
  • Η εξωτερική πολιτική της ΕΣΣΔ κατά τη διάρκεια του πολέμου. Διάσκεψη της Τεχεράνης. Διάσκεψη Γιάλτας και Πότσνταμ 1945 Δημιουργία του ΟΗΕ.
  • Επανέναρξη των δραστηριοτήτων της BSG. Δημιουργία πάρτι και οργανώσεων Belnats

    • Σε ορισμένες περιπτώσεις, κατά τη διάρκεια της διαδικασίας ανάπτυξης λογισμικού, καθίσταται απαραίτητο για διαφορετικές ομάδες προγραμματιστών να «συμφωνήσουν» για το πώς θα αλληλεπιδράσουν τα προγράμματά τους. Κάθε ομάδα θα πρέπει να μπορεί να γράψει τον δικό της κώδικα ανεξάρτητα από το πώς τον γράφει η άλλη ομάδα. Οι διεπαφές είναι αυτό το "συμβόλαιο". Έχουμε ήδη χρησιμοποιήσει διεπαφές στο μάθημα.
    Σε αυτό το μάθημα θα τα μελετήσουμε λεπτομερέστερα: σε τι χρησιμεύουν, πώς να τα δηλώσουμε κ.λπ.

    Φανταστείτε ένα μέλλον όπου τα αυτοκίνητα ελέγχονται από υπολογιστές χωρίς ανθρώπινη παρέμβαση. Οι κατασκευαστές αυτοκινήτων γράφουν λογισμικό (σε Java, φυσικά 🙂) που ελέγχει το αυτοκίνητο - σταμάτα, πήγαινε, στρίψε κ.λπ. Άλλοι προγραμματιστές κατασκευάζουν συστήματα που δέχονται Δεδομένα GPS(Global Positioning System) και χρησιμοποιήστε αυτά τα δεδομένα για τον έλεγχο του αυτοκινήτου. Οι κατασκευαστές αυτοκινήτων δημοσιεύουν ένα πρότυπο διεπαφής που περιγράφει μεθόδους ελέγχου του αυτοκινήτου. Με αυτόν τον τρόπο, οι προγραμματιστές τρίτων μπορούν να γνωρίζουν ποιες μεθόδους να καλέσουν για να μετακινήσουν το αυτοκίνητο και οι κατασκευαστές αυτοκινήτων μπορούν να αλλάξουν την εσωτερική εφαρμογή του προϊόντος τους ανά πάσα στιγμή. Καμία από τις ομάδες ανάπτυξης δεν γνωρίζει πώς είναι γραμμένα τα προγράμματά της.

    Διεπαφές Java

    Οι διεπαφές στην Java μοιάζουν πολύ με τις κλάσεις, αλλά μπορούν να περιέχουν μόνο σταθερές, υπογραφές μεθόδων και . Οι διεπαφές δεν περιέχουν περιγραφές μεθόδων. Δεν μπορείτε να δημιουργήσετε ένα αντικείμενο τύπου διεπαφής (αλλά μπορείτε να το χρησιμοποιήσετε ως τύπο - αναφορές διεπαφής, περισσότερα για αυτό αργότερα) - οι διεπαφές μπορούν να υλοποιηθούν μόνο από κάποια κλάση ή να κληρονομηθούν από άλλη διεπαφή. Μια δήλωση διεπαφής είναι πολύ παρόμοια με μια δήλωση κλάσης:

    Δημόσια διεπαφή OperateCar ( // σταθερές, εάν υπάρχουν // απαρίθμηση κατευθύνσεων ΔΕΞΙΑ, ΑΡΙΣΤΕΡΑ // υπογραφές μεθόδου στην στροφή (Κατεύθυνση κατεύθυνσης, διπλή ακτίνα, διπλή ταχύτητα εκκίνησης, διπλή ταχύτητα). ) ; int signalTurn (Κατεύθυνση κατεύθυνσης, boolean signalOn)

    Οι υπογραφές της μεθόδου δηλώνονται χωρίς παρενθέσεις και τελειώνουν με ερωτηματικό. Για να χρησιμοποιήσετε τη διεπαφή πρέπει να γράψετε μια κλάση που θα εργαλείοτη διεπαφή σας. Μια κλάση που υλοποιεί μια διεπαφή πρέπει να περιγράφει όλες τις μεθόδους που δηλώνονται στη διεπαφή. Για παράδειγμα:

    Το OperateBMW760i δημόσιας κλάσης υλοποιεί το OperateCar ( // εδώ είναι οι μέθοδοι της διεπαφής OperateCar με περιγραφή // για παράδειγμα: int signalTurn (Κατεύθυνση κατεύθυνσης, boolean signalOn) ( // στροφή ΔΕΞΙΑ ή ΑΡΙΣΤΕΡΑ ενεργοποίηση ή απενεργοποίηση φλας ) )

    Στο παραπάνω παράδειγμα, οι κατασκευαστές αυτοκινήτων γράφουν λογισμικό ο καθένας με τον δικό του τρόπο, αλλά με την ίδια διεπαφή. Οι προγραμματιστές τρίτων που είναι πελάτες της διεπαφής μπορούν να γράψουν το δικό τους λογισμικό χρησιμοποιώντας τις μεθόδους που δηλώνονται στη διεπαφή.

    Διεπαφές ως API

    Το παράδειγμα αυτοκινήτου δείχνει πώς οι διεπαφές μπορούν να χρησιμοποιηθούν ως API ( Διεπαφή προγραμματισμού εφαρμογών) ή διεπαφή προγραμματισμού εφαρμογών. Η χρήση API είναι μια κοινή πρακτική στην ανάπτυξη εμπορικού λογισμικού. Συνήθως, οι εταιρείες λογισμικού πωλούν λογισμικό που περιέχει ένα σύνολο τεχνικών που άλλες εταιρείες θέλουν να χρησιμοποιήσουν στα προϊόντα τους.

    Διεπαφές και πολλαπλή κληρονομικότητα

    Οι διεπαφές παίζουν άλλο ένα σημαντικό ρόλοστη γλώσσα προγραμματισμού Java. Η Java δεν επιτρέπει πολλαπλή κληρονομικότητα, αλλά οι διεπαφές παρέχουν μια εναλλακτική λύση. ΣΕ Κλάση Javaμπορεί να κληρονομήσει μόνο μία κλάση, αλλά μπορεί να υλοποιήσει πολλές διεπαφές. Έτσι, τα αντικείμενα μπορούν να έχουν διάφορους τύπους: τον τύπο τους δική της τάξηκαι τους τύπους όλων των εφαρμοζόμενων διεπαφών. Κατά τη δημιουργία αντικειμένων κλάσης, το όνομα της διεπαφής που υλοποιείται στην κλάση μπορεί να καθοριστεί ως τύπος. Με άλλα λόγια, εάν μια κλάση υλοποιεί μια διεπαφή, τότε ένα αντικείμενο αυτής της κλάσης μπορεί να αντιστοιχιστεί σε μια μεταβλητή διεπαφής - μια μεταβλητή της οποίας ο τύπος είναι το όνομα της αντίστοιχης διεπαφής.

    Δήλωση διεπαφής

    Η δήλωση διεπαφής περιέχει λέξη-κλειδίδιεπαφή , όνομα διεπαφής, λίστα γονικών διεπαφών διαχωρισμένων με κόμματα (εάν υπάρχουν) και σώμα διεπαφής. Για παράδειγμα:

    Η δημόσια διεπαφή GroupedInterface επεκτείνει τα Interface1, Interface2, Interface3 ( // αριθμός e διπλό E = 2.718282; // υπογραφές μεθόδου άκυρα doSomething (int i, διπλό x); int doSomethingElse(String s); )

    Ο τροποποιητής δημόσιας πρόσβασης σημαίνει ότι η διεπαφή μπορεί να χρησιμοποιηθεί από οποιαδήποτε κλάση σε οποιοδήποτε πακέτο. Εάν δεν ορίσετε μια διεπαφή ως δημόσια, θα είναι διαθέσιμη μόνο στο πακέτο της. Μια διεπαφή μπορεί να κληρονομήσει άλλες διεπαφές, όπως οι κλάσεις μπορούν να κληρονομήσουν μια άλλη κλάση. Σε αντίθεση με τις κλάσεις, οι διεπαφές μπορούν να κληρονομήσουν οποιονδήποτε αριθμό άλλων διεπαφών.

    Υλοποίηση διεπαφής

    Για να δηλώσετε μια κλάση που υλοποιεί μια διεπαφή, πρέπει να χρησιμοποιήσετε τη λέξη-κλειδί implements ακολουθούμενη από τις διεπαφές.
    Μια κλάση μπορεί να υλοποιήσει πολλές διεπαφές. Η δήλωση των υλοποιημένων διεπαφών έρχεται μετά τη δήλωση της κλάσης που κληρονομείται (επεκτείνεται) (εάν υπάρχει).

    Παράδειγμα απλής διεπαφής

    Εξετάστε μια διεπαφή που ορίζει μια μέθοδο σύγκρισης αντικειμένων.

    Δημόσια διεπαφή Relatable ( // αυτό (το αντικείμενο που καλεί isLargerThan) // το αντικείμενο παραμέτρου πρέπει να είναι της ίδιας κλάσης // επιστρέφει 1, 0, -1 // εάν το αντικείμενο είναι μεγαλύτερο από, ίσο ή // μικρότερο από άλλο δημόσιο int isLargerThan (Σχετικό άλλο)

    Για να μπορούμε να συγκρίνουμε αντικείμενα πρέπει να εφαρμόσουμε τη διεπαφή Relatable. Οποιαδήποτε κλάση μπορεί να υλοποιήσει τη διεπαφή Relatable αρκεί να υπάρχει τρόπος σύγκρισης των αντικειμένων. Για συμβολοσειρές μπορείτε να συγκρίνετε τον αριθμό των χαρακτήρων, για τα βιβλία - τον αριθμό των σελίδων, για τους μαθητές - το βάρος κ.λπ. Για επίπεδα γεωμετρικά σχήματα εξαιρετικό χαρακτηριστικόθα είναι η περιοχή, για τα τρισδιάστατα – όγκος. Όλες αυτές οι κλάσεις μπορούν να εφαρμόσουν τη μέθοδο isLargerThan(). Εάν γνωρίζετε ότι μια κλάση υλοποιεί τη διεπαφή Relatable, τότε μπορείτε να συγκρίνετε με ασφάλεια αντικείμενα αυτής της κλάσης.

    Υλοποίηση της διεπαφής Relatable

    Ας γράψουμε μια κλάση Rectangle που υλοποιεί τη διεπαφή Relatable.

    Εφαρμογές δημόσιας κλάσης RectanglePlus Relatable ( δημόσιο πλάτος int = 0; δημόσιο ύψος int = 0; δημόσια αρχή σημείου; // τέσσερις κατασκευαστές δημόσια RectanglePlus() ( origin = new Point(0, 0); ) public RectanglePlus(Point p) ( origin = p. πλάτος = w; ύψος = h; ( επιστροφή πλάτος * ύψος; ) // μέθοδος για την υλοποίηση της δημόσιας διεπαφής Relatable int isLargerThan(Relatable other) ( RectanglePlus otherRect = (RectanglePlus)other; if (this.getArea()< otherRect.getArea()) return -1; else if (this.getArea() >otherRect.getArea()) επιστροφή 1;

    αλλιώς επιστροφή 0?

    ) )

    Επειδή η κλάση RectanglePlus υλοποιεί το Relatable, τα μεγέθη οποιωνδήποτε δύο αντικειμένων RectanglePlus μπορούν να συγκριθούν.

    Η μέθοδος isLargerThan λαμβάνει ως όρισμα αντικείμενα τύπου Relatable. Κατά την υλοποίηση της μεθόδου στο παραπάνω παράδειγμα, χρησιμοποιούμε έναν τύπο cast επειδή ο μεταγλωττιστής δεν θα καταλάβει ότι το άλλο είναι αντικείμενο τύπου RectanglePlus και η κλήση της μεθόδου other.getArea() χωρίς cast τύπου θα έχει ως αποτέλεσμα σφάλμα.

    Χρησιμοποιώντας μια διεπαφή ως τύπο

    Όταν δηλώνετε μια διεπαφή, δηλώνετε έναν νέο τύπο δεδομένων αναφοράς. Μπορείτε να χρησιμοποιήσετε ένα όνομα διεπαφής ως τύπο δεδομένων όπως οποιοσδήποτε άλλος τύπος. Εάν δηλώσετε μια μεταβλητή τύπου διεπαφής, τότε μπορείτε να την αντιστοιχίσετε σε ένα αντικείμενο οποιασδήποτε κλάσης που υλοποιεί αυτήν τη διεπαφή.

    Ας δούμε ένα παράδειγμα - μια μέθοδο που αναζητά το μεγαλύτερο αντικείμενο οποιωνδήποτε δύο αντικειμένων των οποίων η κλάση υλοποιεί τη διεπαφή Relatable:

    Δημόσιο αντικείμενο findLargest(Αντικείμενο1, Αντικείμενο Αντικείμενο2) ( Relatable obj1 = (Relatable)object1; Relatable obj2 = (Relatable)object2; if ((obj1).isLargerThan(obj2) > 0) επιστρέφει το αντικείμενο1; αλλιώς επιστροφή αντικείμενο2; )

    Μεταφέροντας το αντικείμενο1 στον τύπο Relatable, καθιστούμε δυνατή την κλήση της μεθόδου isLargerThan.< 0) return object1; else return object2; } public boolean isEqual(Object object1, Object object2) { Relatable obj1 = (Relatable)object1; Relatable obj2 = (Relatable)object2; if ((obj1).isLargerThan(obj2) == 0) return true; else return false; }

    Επίσης, για οποιαδήποτε κλάση που υλοποιεί τη διεπαφή Relatable, μπορείτε να εφαρμόσετε μεθόδους:

    Δημόσιο αντικείμενο findSmallest(Αντικείμενο1, Αντικείμενο Αντικείμενο2) ( Relatable obj1 = (Relatable)object1; Relatable obj2 = (Relatable)object2; if ((obj1).isLargerThan(obj2)

    Επαναπροσδιορισμός διεπαφών

    Ας υποθέσουμε ότι γράψατε μια διεπαφή DoI:

    Δημόσια διεπαφή DoIt ( void doSomething(int i, double x); int doSomethingElse(String s); boolean didItWork(int i, double x, String s); )

    Εάν κάνετε αυτήν την αλλαγή, τότε όλες οι κλάσεις που υλοποιούν αυτήν τη διεπαφή θα σπάσουν, επειδή θα σταματήσουν να το εφαρμόζουν.

    Προσπαθήστε να αποφύγετε τέτοιες αλλαγές και σκεφτείτε τη διεπαφή εντελώς από την αρχή. Αλλά συχνά στην πράξη αυτό δεν είναι δυνατό και μια διέξοδος από αυτήν την κατάσταση μπορεί να είναι ο ορισμός μιας νέας διεπαφής DoItPlus, η οποία επεκτείνει το DoIt:

    Δημόσια διεπαφή DoItPlus επεκτείνει το DoIt ( boolean didItWork(int i, double x, String s); )

    Τώρα οι χρήστες της διεπαφής σας θα μπορούν να αλλάξουν στη χρήση της νέας διεπαφής ή να παραμείνουν στην παλιά χωρίς πόνο.



    Συνιστούμε να διαβάσετε