L’uso di JFrames multipli: buona o ctriggers pratica?

Sto sviluppando un’applicazione che visualizza le immagini e riproduce i suoni da un database. Sto cercando di decidere se utilizzare o meno un JFrame separato per aggiungere immagini al database dalla GUI.

Mi chiedo se sia una buona pratica utilizzare più windows JFrame?

Mi sto solo chiedendo se sia una buona pratica usare più JFrames?

Ctriggers (ctriggers, ctriggers) pratica.

  • Utente ostile: l’utente vede più icone nella barra delle applicazioni quando si aspetta di vederne solo una. Inoltre gli effetti collaterali dei problemi di codifica ..
  • Un incubo da codificare e mantenere:
    • Una finestra di dialogo modale offre la facile opportunità di focalizzare l’attenzione sul contenuto di quella finestra di dialogo – scegliere / correggere / cancellare questo, quindi procedere. Cornici multiple no.
    • Una finestra di dialogo (o barra degli strumenti fluttuante) con un genitore verrà visualizzata in primo piano quando si fa clic sul genitore – bisognerebbe implementarla nei frame se questo era il comportamento desiderato.

Esistono molti modi per visualizzare molti elementi in una GUI, ad esempio:

  • CardLayout (breve demo. ). Buono per:
    1. Visualizzazione di windows di dialogo come wizard.
    2. Visualizzazione delle selezioni elenco, albero, ecc. Per gli articoli che hanno un componente associato.
    3. Capovolgimento tra nessun componente e componente visibile.
  • JInternalFrame / JDesktopPane genere utilizzato per una MDI .
  • JTabbedPane per gruppi di componenti.
  • JSplitPane Un modo per visualizzare due componenti di cui l’importanza tra l’una o l’altra (la dimensione) varia in base a ciò che l’utente sta facendo.
  • JLayeredPane molti componenti ben congegnati.
  • JToolBar contiene in genere gruppi di azioni o controlli. Può essere trascinato attorno alla GUI o distriggersto interamente in base alle esigenze dell’utente. Come accennato in precedenza, si minimizzerà / ripristinerà secondo il genitore che lo fa.
  • Come elementi in una JList (esempio semplice sotto).
  • Come nodes in un JTree .
  • Layout nidificati

Ma se quelle strategie non funzionano per un particolare caso d’uso, prova quanto segue. Stabilire un singolo JFrame principale, quindi visualizzare le istanze JDialog o JOptionPane per il resto degli elementi flottanti, utilizzando il frame come genitore per le windows di dialogo.

Molte immagini

In questo caso in cui gli elementi multipli sono immagini, sarebbe preferibile utilizzare uno dei seguenti invece:

  1. Un singolo JLabel (centrato in un riquadro di scorrimento) per visualizzare l’immagine a cui l’utente è interessato in quel momento. Come visto in ImageViewer .
  2. Una riga singola JList . Come visto in questa risposta . La parte ‘single row’ di questo funziona solo se sono tutte le stesse dimensioni. In alternativa, se sei pronto a ridimensionare le immagini al volo, e hanno tutte le stesse proporzioni (ad es. 4: 3 o 16: 9).

L’approccio multiplo di JFrame è stato qualcosa che ho implementato da quando ho iniziato a programmare le app di Swing. Per la maggior parte, l’ho fatto all’inizio perché non sapevo di meglio. Tuttavia , maturando nella mia esperienza e conoscenza come sviluppatore e avendo iniziato a leggere e ad assorbire le opinioni di tanti sviluppatori Java più esperti online, ho cercato di allontanarmi dal più approccio JFrame (sia nei progetti attuali che in quelli futuri progetti) solo per essere incontrato con … ottenere questa … resistenza dai miei clienti! Quando ho iniziato a implementare windows di dialogo modali per controllare windows “child” e JInternalFrame per componenti separati, i miei clienti hanno iniziato a lamentarsi! Sono rimasto piuttosto sorpreso, mentre stavo facendo quello che pensavo fosse il best-practice! Ma, come si suol dire, “Una moglie felice è una vita felice”. Lo stesso vale per i tuoi clienti. Certo, sono un appaltatore quindi i miei utenti finali hanno accesso diretto a me, lo sviluppatore, che ovviamente non è uno scenario comune.

Quindi, spiegherò i vantaggi dell’approccio multiplo di JFrame , così come la mitizzazione di alcuni degli aspetti negativi che altri hanno presentato.

  1. Massima flessibilità nel layout : consentendo di separare i JFrame , si offre all’utente finale la possibilità di estendere e controllare ciò che è sul suo schermo. Il concetto si sente “aperto” e non costrittivo. Lo perdi quando vai verso un grosso JFrame e un gruppo di JInternalFrame .
  2. Funziona bene per applicazioni molto modularizzate – Nel mio caso, la maggior parte delle mie applicazioni ha 3 – 5 grandi “moduli” che in realtà non hanno nulla a che fare l’uno con l’altro. Ad esempio, un modulo potrebbe essere un cruscotto di vendita e uno potrebbe essere un cruscotto contabile. Non parlano tra loro o niente. Tuttavia, l’esecutivo potrebbe voler aprire entrambi e quelli che sono frame separati sulla barra delle applicazioni gli semplifica la vita.
  3. Fa in modo che gli utenti finali facciano riferimento a materiale esterno . Una volta, avevo questa situazione: la mia app aveva un “visualizzatore di dati”, da cui era ansible fare clic su “Aggiungi nuovo” e si apriva una schermata di immissione dei dati. Inizialmente, entrambi erano JFrame s. Tuttavia, volevo che lo schermo di immissione dei dati fosse un JDialog cui genitore era il visualizzatore di dati. Ho apportato la modifica, e immediatamente ho ricevuto una chiamata da un utente finale che si basava molto sul fatto che poteva minimizzare o chiudere lo spettatore e tenere aperto l’ editor mentre faceva riferimento a un’altra parte del programma (o un sito Web, io Ricordo). Non è su un monitor multiplo, quindi ha avuto bisogno della finestra di dialogo di immissione per essere il primo e qualcos’altro per essere il secondo, con il visualizzatore di dati completamente nascosto. Questo era imansible con un JDialog e certamente sarebbe stato imansible anche con un JInternalFrame . L’ho rimpiazzato malvolentieri per essere separato da JFrames per la sua sanità mentale, ma mi ha insegnato una lezione importante.
  4. Mito: difficile da codificare – Questo non è vero nella mia esperienza. Non vedo perché sarebbe più facile creare un JInternalFrame di un JFrame . In effetti, nella mia esperienza, JInternalFrames offre molta meno flessibilità. Ho sviluppato un modo sistematico di gestire l’apertura e la chiusura di JFrame nelle mie app che funziona davvero bene. Controllo il canvasio quasi completamente dall’interno del codice del frame stesso; la creazione del nuovo frame, SwingWorker s che controlla il recupero dei dati su thread in background e il codice GUI su EDT, ripristinando / portando in primo piano il frame se l’utente prova ad aprirlo due volte, ecc. Tutto ciò che serve per aprire il mio JFrame s è chiamare un metodo statico pubblico open() e il metodo open, combinato con un evento windowClosing() gestisce il resto (è il frame già aperto? non è aperto, ma il caricamento? ecc.) Ho fatto questo approccio a un template così non è difficile da implementare per ogni frame.
  5. Mito / non dimostrato: pesante risorsa – Mi piacerebbe vedere alcuni fatti dietro questa affermazione speculativa. Sebbene, forse, si possa dire che un JFrame bisogno di più spazio di un JInternalFrame , anche se apri 100 JFrame , quante altre risorse utilizzeresti davvero? Se la tua preoccupazione è la perdita di memoria a causa delle risorse: chiamando dispose() libera tutte le risorse utilizzate dal frame per la garbage collection (e, ancora una volta, un JInternalFrame dovrebbe richiamare esattamente la stessa preoccupazione).

Ho scritto molto e mi sento come se potessi scrivere di più. Ad ogni modo, spero di non essere minimamente votato perché è un’opinione impopolare. La domanda è chiaramente preziosa e spero di aver fornito una risposta valida, anche se non è l’opinione comune.

Un ottimo esempio di frame multipli / singolo documento per frame ( SDI ) rispetto a frame singolo / più documenti per frame ( MDI ) è Microsoft Excel. Alcuni dei vantaggi di MDI:

  • è ansible avere poche windows in forma non rettangular, in modo che non nascondano il desktop o altre windows da un altro processo (es. browser web)
  • è ansible aprire una finestra da un altro processo su una finestra di Excel mentre si scrive in una seconda finestra di Excel – con MDI, provare a scrivere in una finestra interna darà fuoco all’intera finestra di Excel, nascondendo quindi la finestra da un altro processo
  • è ansible avere documenti diversi su schermi diversi, il che è particolarmente utile quando le schermate non hanno la stessa risoluzione

SDI (Interfaccia a documento singolo, cioè ogni finestra può avere un solo documento):

inserisci la descrizione dell'immagine qui

MDI (Multiple-Document Interface, cioè ogni finestra può avere più documenti):

inserisci la descrizione dell'immagine qui

Mi piacerebbe contrastare l’argomento “non facile da usare” con un esempio con il quale sono stato appena coinvolto.

Nella nostra applicazione abbiamo una finestra principale in cui gli utenti eseguono vari ‘programmi’ come tabs separate. Per quanto ansible abbiamo cercato di mantenere la nostra applicazione su questa singola finestra.

Uno dei ‘programmi’ che eseguono presenta un elenco di report che sono stati generati dal sistema e l’utente può fare clic su un’icona su ogni riga per aprire una finestra di dialogo del visualizzatore di report. Questo visualizzatore mostra l’equivalente delle pagine A4 di ritratto / paesaggio del report, quindi gli utenti come questa finestra sono piuttosto grandi, quasi a riempire gli schermi.

Alcuni mesi fa abbiamo iniziato a ricevere richieste dai nostri clienti per rendere queste windows di visualizzazione dei report non modali, in modo che potessero avere più report aperti contemporaneamente.

Per qualche tempo ho resistito a questa richiesta perché non pensavo che questa fosse una buona soluzione. Tuttavia, la mia mente è cambiata quando ho scoperto come gli utenti si aggirassero in questa “carenza” del nostro sistema.

Stavano aprendo un visualizzatore, usando la funzione “Salva con nome” per salvare il rapporto come PDF in una directory specifica, usando Acrobat Reader per aprire il file PDF, e poi farebbero lo stesso con il prossimo rapporto. Avrebbero più Acrobat Reader in esecuzione con i vari output di report che volevano esaminare.

Quindi ho ceduto e reso il viewer modale. Ciò significa che ogni visualizzatore ha un’icona della barra delle attività.

Quando l’ultima versione è stata rilasciata loro la settimana scorsa, la risposta travolgente da loro è che LOVE it. È stato uno dei nostri più recenti miglioramenti del sistema.

Quindi vai avanti e dici ai tuoi utenti che quello che vogliono è cattivo, ma alla fine non ti farà alcun favore.

ALCUNE NOTE:

  • Sembra essere una buona pratica usare JDialog per queste windows non modali
  • Utilizzare i costruttori che utilizzano il nuovo ModalityType anziché l’argomento modal booleano. Questo è ciò che dà a queste windows di dialogo l’icona della barra delle applicazioni.
  • Per le windows di dialogo non modali, passare un genitore nullo al costruttore, ma individuarli in relazione alla finestra “padre”.
  • La versione 6 di Java su Windows ha un bug che significa che la finestra principale può diventare “sempre in primo piano” senza che tu la dica. Passa alla versione 7 per risolvere questo problema

Crea un jInternalFrame nel frame principale e rendilo invisibile. Quindi puoi usarlo per ulteriori eventi.

 jInternalFrame.setSize(300,150); jInternalFrame.setVisible(true); 

È passato un po ‘dall’ultima volta che touch swing, ma in generale è una ctriggers pratica farlo. Alcuni dei principali svantaggi che vengono in mente:

  • È più costoso: dovrai allocare molte più risorse per disegnare un JFrame che un altro tipo di contenitore di windows, come Dialog o JInternalFrame.

  • Non facile da usare: non è facile entrare in un gruppo di JFrame incollati insieme, sembrerà che la tua applicazione sia un insieme di applicazioni incoerenti e mal progettate.

  • È facile da usare JInternalFrame Questo è un po ‘retorico, ora è molto più semplice e altre persone più intelligenti (o con più tempo libero) di quanto abbiamo già pensato attraverso il pattern Desktop e JInternalFrame, quindi consiglierei di usarlo.

Ctriggers pratica sicuramente. Una ragione è che non è molto “user-friendly” per il fatto che ogni JFrame mostra una nuova icona sulla barra delle applicazioni. Il controllo di più JFrame ti farà strappare i capelli.

Personalmente, JFrame ONE JFrame per il tuo tipo di applicazione. Metodi di visualizzazione di più cose dipende da te, ce ne sono molti. Canvas es, JInternalFrame , CardLayout , forse anche JPanel .

Più oggetti JFrame = Dolore, problemi e problemi.

Penso che l’uso di più Jframe non sia una buona idea.

Invece possiamo usare JPanel più di uno o più JPanel nello stesso JFrame .

Inoltre possiamo passare da questo JPanel s. Quindi ci dà la libertà di mostrare più cose su JFrame .

Per ogni JPanel possiamo progettare cose diverse e tutto questo JPanel può essere visualizzato sul singolo JFrame uno alla volta.

Per passare da questo JPanel usa JMenuBar con JMenuBar per ogni JPanel o ‘JButton for each JPanel`.

Più di un JFrame non è una buona pratica, ma non c’è nulla di male se vogliamo più di un JFrame .

Ma è meglio cambiare un JFrame per le nostre diverse esigenze piuttosto che avere più JFrame .

Se i frame avranno le stesse dimensioni, perché non creare il frame e passare il frame come riferimento ad esso.

Una volta passato il frame, puoi decidere come popolarlo. Sarebbe come avere un metodo per calcolare la media di un insieme di cifre. Vuoi creare il metodo più e più volte?

Non è una buona pratica, ma anche se si desidera utilizzarlo, è ansible utilizzare il modello singleton come buono. Ho usato i modelli singleton nella maggior parte del mio progetto è buono.