Oscillation (Java)

L'oscillation est une trousse à outils de gadget de pour le Java . Ce fait partie le &mdash des classes ('JFC) de base de Java de de Sun Microsystems de ; un api pour fournir une interface utilisateurs graphique (GUI) pour des programmes de Java. L'oscillation inclut les gadgets de GUI tel que des boîtes des textes, des boutons, des dédoubler-carreaux, et des tables.

Les gadgets d'oscillation fournissent des composants plus sophistiqués de GUI que la trousse à outils plus tôt de fenêtre d'abrégé sur . Ils sont conçus pour être conformés à travers toutes les plates-formes, à la différence des gadgets d'AWT, qui tracent directement à l'interface de graphiques de la plate-forme courante sans modification. L'oscillation soutient un regard que l'on peut brancher de du et la sensation en employant l'interface de graphiques de la plate-forme courante pour réaliser l'uniformité par des modifications apportées par api additionnel appelle. Ceci signifie que l'application peut employer n'importe quel regard soutenu et se sentir sur n'importe quelle plate-forme. L'inconvénient des composants légers est une exécution plus lente. L'avantage est comportement uniforme sur toutes les plates-formes.

Histoire

Les classes (IFC) de base d'Internet de étaient une bibliothèque de graphiques de pour Java à l'origine développé par la société de Netscape Communications de et d'abord libéré sur le 1996 du 16 décembre . Sur le le 1997 du 2 avril , Sun Microsystems et société de Netscape Communications de a annoncé leur intention d'incorporer IFC avec d'autres technologies pour former les classes de base de Java de .

L'oscillation a présenté un mécanisme qui a permis le regard de et la sensation de chaque composant dans une application à changer sans faire la partie essentielle change en code d'application. L'introduction du soutien d'un regard et d'une sensation que l'on peut brancher permet à des composants d'oscillation d'émuler l'aspect des composants indigènes tout en maintenant toujours les avantages de l'indépendance de plate-forme. Ce dispositif le rend également facile de faire une demande écrite dans le regard d'oscillation très différent des programmes indigènes si désiré.

À l'origine distribué comme bibliothèque séparément téléchargeable, l'oscillation a été incluse en tant qu'élément de l'édition standard de Java de depuis la version 1. Les classes d'oscillation sont contenues dans la hiérarchie du paquet .

Pour l'origine de l'oscillation nommée de , voir le List_of_computer_term_etymologies

Architecture

L'oscillation est une plate--indépendante, cadre de GUI du Modèle-Vue-Contrôleur de pour Java. Elle suit un modèle de programmation monofil , et possède les traits suivants :
l'indépendance de plate-forme de de

: L'oscillation est indépendant de plate-forme en termes de son expression (Java) et son exécution (rendu universel non-natif des gadgets).
extensibilité de

: L'oscillation est une architecture fortement divisée, qui tient compte du " ; plugging" ; de diverses réalisations faites sur commande de cadre spécifique connecte : Les utilisateurs peuvent fournir leurs propres réalisations faites sur commande de ces composants pour dépasser les réalisations de défaut. Généralement les utilisateurs d'oscillation peuvent prolonger le cadre en prolongeant les classes existantes (de cadre) et/ou en fournissant des réalisations alternatives des composants de noyau.
le de

Composant-A orienté : L'oscillation est un cadre à base de composants. La distinction entre les objets et les composants est un point assez subtile : avec concision, un composant est un objet poli avec mode de comportement caractéristique connu/spécifique. Balancer les événements du feu d'objets asynchrone, avoir le " ; bound" ; les propriétés, et répondent à un ensemble bien connu de commandes (spécifiques au composant.) Spécifiquement, les composants d'oscillation sont des composants des haricots de Java de , conformes avec les caractéristiques composantes d'architecture d'haricots de Java.
personnalisable de

: Etant donné le modèle selon les programmes de rendu du cadre d'oscillation, le contrôle fin des détails du rendu d'un composant est possible dans l'oscillation. Comme modèle général, la représentation visuelle d'un composant d'oscillation est une composition d'un ensemble standard d'éléments, tels qu'un " ; border" ; , " ; inset" ; , décorations, etc. Typiquement, les utilisateurs adapteront programmatically un composant standard d'oscillation (tel qu'un JTable) en assignant les frontières spécifiques, couleurs, milieux, etc., comme propriétés de ce composant. Le composant de noyau emploiera alors ces la propriété (arrangements) pour déterminer les renderers appropriés pour employer en peignant ses divers aspects. Cependant, il est également complètement possible de créer des commandes uniques de GUI avec la représentation visuelle fortement adaptée aux besoins du client. (Les composants d'oscillation soutiennent le rendu transparent.)
configurable de

: La confiance lourde de l'oscillation dans les mécanismes d'exécution et les modèles indirects de composition lui permet de répondre au temps d'exécution aux changements fondamentaux de ses arrangements. Par exemple, une application Balancer-basée peut changer son regard et se sentir au temps d'exécution. De plus, les utilisateurs peuvent fournir leur propre regard et sentir l'exécution, qui tient compte des changements uniformes du regard et de la sensation des applications existantes d'oscillation sans n'importe quel changement selon les programmes au code d'application.
UI léger de

: La configuration de l'oscillation est un résultat d'un choix pour ne pas employer les commandes du GUI de l'OS indigène de centre serveur pour se montrer. " d'oscillation ; paints" ; ses commandes programmatically par l'utilisation api de Java des 2D, plutôt qu'appelant dans une trousse à outils indigène d'interface utilisateurs. Ainsi, un composant d'oscillation n'a pas un composant indigène correspondant de GUI d'OS, et est libre pour se rendre de quelque façon qui est possible avec les api fondamentaux de graphiques.

Cependant, à son noyau, chaque composant d'oscillation se fonde sur un récipient d'AWT, depuis (l'oscillation) JComponent prolonge le récipient (AWT). Ceci permet à l'oscillation de brancher au cadre de gestion du GUI de l'OS de centre serveur, y compris les tracés cruciaux de dispositif/écran et les interactions d'utilisateur (telles que la clef presse, des mouvements de souris, etc.) balancent simplement le " ; transposes" ; ses propres (OS agnostique) sémantique au-dessus des composants étant à la base (de détail d'OS). Ainsi, par exemple, chaque composant d'oscillation peint son interprétation sur le dispositif graphique en réponse à un appel à component.paint (), qui est défini dans le récipient (AWT). Mais à la différence des composants d'AWT, qui ont délégué la peinture à leur " OS-indigène ; heavyweight" ; le gadget, composants d'oscillation sont responsable de leur propre rendu.

De plus, cette transposition et le découplage n'est pas simplement visuel, et se prolonge à la gestion de l'oscillation, et à l'application de sa propre sémantique OS-indépendante pour, des événements mises le feu dans ses hiérarchies composantes de retenue.

De façon générale, l'architecture d'oscillation délègue la tâche de tracer les diverses saveurs de la sémantique de GUI d'OS sur un simple, mais généralisé, modèle dans le récipient d'AWT. Puis, établissant sur celle la plate-forme généralisée, elle établit sa propre sémantique riche et complexe de GUI, sous forme de modèle de JComponent. (Le lecteur intéressé est encouragé à passer en revue la source des classes de Container.java et de JComponent.java pour d'autres perspicacités dans la nature de l'interface entre les composants légers de l'oscillation et les gadgets lourds d'AWT.)

Loosely-Coupled/MVC : La bibliothèque d'oscillation fait l'utilisation lourde le modèle de conception de de de modèle/vue/contrôleur de logiciel, qui découple conceptuellement les données étant regardées des commandes d'interface utilisateurs par lesquelles elle est regardée. Pour cette raison, la plupart des composants d'oscillation ont associé les modèles (qui de sont spécifiés en termes de de Java connectent ), et le programmeur peut employer de diverses réalisations de défaut ou fournir leurs propres. Le cadre fournit des réalisations de défaut des interfaces modèles pour tous ses composants concrets.

Typiquement, les objets modèles composants d'oscillation sont responsables de fournir une interface concise définissant des événements mis le feu, et des propriétés accessibles pour le modèle de données (conceptuel) à l'usage du JComponent associé. Étant donné que le modèle MVC global est un modèle de collaboration légèrement connecté de rapport d'objet, le modèle fournit les moyens selon les programmes pour attacher des auditeurs d'événement à l'objet de modèle de données. Typiquement, ces événements sont centraux modèle (ex : un " ; inserted" de rangée ; l'événement dans un modèle de table) et sont tracés par la spécialisation de JComponent dans un événement signicatif pour le composant de GUI.

Par exemple, fait appeler un modèle qui décrit une interface pour la façon dont une table accéderait à des données tabulaires. Une exécution de défaut de ceci opère une rangée bidimensionnelle .

Le composant de vue d'une oscillation JComponent est l'objet utilisé graphiquement au " ; represent" ; la commande conceptuelle de GUI. Une distinction d'oscillation, comme cadre de GUI, est dans sa confiance dans des commandes programmatically-rendues de GUI (par opposition à l'utilisation des commandes du GUI de l'OS indigène de centre serveur). (Cette distinction est une source des complications en mélangeant les commandes d'AWT, qui emploient des commandes indigènes, avec l'oscillation commande dans un GUI.)

Il doit noter que l'utilisation typique du cadre d'oscillation n'exige pas la création des modèles faits sur commande, car le cadre fournit un ensemble de réalisations de défaut qui sont d'une manière transparente, par défaut, lié à la classe correspondante d'enfant de JComponent dans la bibliothèque d'oscillation. Généralement seulement les composants complexes, tels que des tables, des arbres et parfois des listes, peuvent exiger les réalisations modèles faites sur commande autour des structures de données spécifiques à l'application.

(Cependant, pour obtenir un bon sens du potentiel que l'architecture d'oscillation rend possible, considérer la situation hypothétique où fait sur commande des modèles pour des tables et les listes sont des emballages au-dessus des services de DAO et/ou d'EJB.)

En conclusion, en termes de composition et gestion visuelles, l'oscillation favorise les dispositions relatives (qui spécifient les rapports de position entre les composants) par opposition aux dispositions absolues (qui spécifient l'endroit et la taille exacts des composants). Cette polarisation vers le " ; fluid" ; la 'commande de visuel est due à ses origines dans l'environnement de fonctionnement de l'applet qui a encadré la conception et le développement de la trousse à outils originale de GUI de Java. (Conceptuellement, cette vue de la gestion de disposition est tout à fait semblable à cela qui informe le rendu du contenu de HTML en navigateurs, et aborde le même ensemble de soucis qui ont motivé l'ancien.)

Regarder et sentir

Regard et sensation que l'on peut brancher

L'oscillation permet à on de spécialiser le regard de et de sentir des gadgets , en modifiant le défaut (par l'intermédiaire des paramètres d'exécution), dérivant de existant, en créant un à partir de zéro, ou, commençant par le J2SE 5.0 , en employant le regard et la sensation du synth de Skinnable (voir), qui est configurée avec un dossier de propriété du XML . Le regard et la sensation peuvent être changés au temps d'exécution, et les démonstrations tôt de l'oscillation ont fréquemment fourni une manière de faire ceci.

Rapport avec AWT

Depuis des versions tôt de Java, une partie de la trousse à outils (AWT) de fenêtre d'abrégé sur a fourni des api plate--indépendants pour des composants d'interface utilisateurs. Dans AWT, chaque composant est rendu et commandé par un détail composant de pair indigène au système fondamental de fenêtrage.

En revanche, des composants d'oscillation sont souvent décrits comme léger parce qu'ils n'exigent pas l'allocation des ressources indigènes dans la trousse à outils du système d'exploitation de fenêtrage. Les composants d'AWT désigné sous le nom des composants lourds de .

Une grande partie de l'oscillation api est généralement une prolongation complémentaire de l'AWT plutôt qu'un remplacement direct. En fait, chaque interface légère d'oscillation existe finalement dans un composant lourd d'AWT parce que tous les composants supérieurs dans l'oscillation (, et) prolongent un récipient supérieur d'AWT. Cependant, l'utilisation des composants légers et lourds dans la même fenêtre est généralement due découragé aux incompatibilités du Z-ordre .

La fonctionnalité de rendu de noyau employée par l'oscillation pour dessiner ses composants légers est fournie par le Java le 2D , une autre partie de JFC.

Rapport avec SWT

La trousse à outils standard (SWT) de gadget de est une trousse à outils de concurrence à l'origine développée par IBM et maintenant maintenue par la base d'éclipse de . L'exécution de SWT a plus en commun avec les composants lourds d'AWT. Ceci confère des avantages tels qu'une fidélité plus précise avec la trousse à outils indigène fondamentale de fenêtrage, au coût d'une exposition accrue à la plate-forme indigène dans le modèle de programmation.

L'arrivée de SWT a provoqué beaucoup de division parmi les lotisseurs de bureau de Java, avec beaucoup favorisant fortement SWT ou oscillation. Le développement de Sun sur l'oscillation continue à se concentrer sur le regard de plate-forme et à sentir (PLAF) la fidélité avec la trousse à outils du fenêtrage de chaque plate-forme dans le dégagement de approche de Se 7 de Java de ( en date du décembre 2006 ). En attendant, il y a d'autres sources de PLAFs de haute fidélité, beaucoup dont sont rassemblés sur l'emplacement de javootoo.

Il y a eu discussion et de spéculation significatives au sujet de l'exécution de SWT contre l'oscillation ; La dépendance lourde de SWT à l'égard le JNI le rend plus lent quand le composant et Java de GUI doivent communiquer des données, mais plus rapidement au rendu quand le modèle de données a été chargé dans le GUI.

SWT sert la plate-forme de Windows très bien mais est considéré comme étant par certains moins efficace comme technologie pour le développement de croix-plate-forme. En employant les dispositifs à niveau élevé de chaque trousse à outils indigène de fenêtrage, SWT revient aux issues vues au milieu des années 90 (avec des trousses à outils comme le zApp, le zinc, le XVT et l'IBM/Smalltalk) où les trousses à outils ont essayé de masquer des différences dans le comportement de foyer, le déclenchement d'événement et la disposition graphique. Le manque d'assortir le comportement sur chaque plate-forme peut causer subtile mais difficile-à-résout les bogues qui effectuent l'interaction d'utilisateur et l'aspect du GUI.

Exemple

Ce qui suit est un programme du monde bonjour using l'oscillation. lang=" de importation javax.JFrame ; importation javax.JLabel ; importation java.EventQueue ;

la classe finale publique HelloWorld met en application praticable {

force publique de vide de charge statique (args de corde) {

L'oscillation de/* a son propre fil d'expédition, qui est distinct du fil principal de JVM (lanceur). Ceci signifie que même si le fil (de lanceur) a sorti (ceci) la méthode principale, le fil de GUI d'oscillation être toujours fonctionnement, attendant pour répondre à l'entrée d'utilisateur, etc. et si l'utilisateur clôture la fenêtre, puis le programme continuer à courir (en raison du fil de phase de GUI). En date de Java 6, Le fil de GUI s'arrêtera automatiquement si tous les composants sont cachés et disposé. Exécuter tout le code de GUI dans le fil d'expédition d'événement, même initialisation : *

EventQueue.invokeLater (nouveau HelloWorld ()); }

le vide de public fonctionnent () {

// créent l'armature avec le " de titre ; Bonjour, monde ! " ;

JFrame f = nouveau JFrame (" ; Bonjour, monde ! " ;);

/* précédemment, nous avons typiquement attaché un auditeur de fenêtre à notre force JFrame et sur () le rappel de service windowClosing d'avis d'événement, nous appeler explicitement System.exit (stat) ou une autre une telle méchanceté. Ce qui suit est la nouvelle manière (propre) de définir la fin de défaut comportement pour un JFrame. Ce qui suit disposera simplement le JFrame mais lui pas arrêter l'application à moins que le *all* Windows soient disposés.setDefaultCloseOperation (JFrame.DISPOSE_ON_CLOSE) ;

/* ceci arrête le $$etAPP sur la fin de fenêtre. (Il est commenté dehors.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE) ; JFrame, qui est le " ; window" ; le composant de l'oscillation, a un intéressant dispositif : il a une architecture contente posée dont (conceptuellement) tient compte placement d'un composant du JFrame dans une couche indiquée. Les couches peuvent être conceptuellement vu comme série de transparents a placé un au-dessus des autres dans aérien projecteur. L'oscillation place typiquement des composants d'utilisateur (tels que des boutons, etc.) dedans ce qu'elle appelle son " ; pane" content ;. Ce carreau est dans la couche qui est au-dessous des la plupart de autre (transparent) couches. Pour quoi sont-elles les couches ? Penser à quand vous right-click sur a commander et il " ; pops" ; un " contextuel de menu ; over" ; la commande originale ; ou, quand vous presser le " ; help" ; pour une commande ou planent la souris pour un " ; tip" d'outil ; et l'information est " ; placé plus de le control" ;. Comment est-ce que cela est allé ? En rendant l'information dans a " de couche ; above" ; le " plus bas ; content" ; carreau. Ainsi : La manière standard d'ajouter un composant à un " ; multi-pane" ; récipient comme JFrame est en établissant d'abord une référence à son " ; pane" content ; (qui est, près défaut, juste a JPanel avec BorderLayout) et ajoutant les composants du JFrame à le carreau content et pas directement au JFrame. (Le dernier dégagement d'oscillation, cependant, change sémantique du JFrame.) pour assumer l'addition commode au carreau content).add (nouveau JLabel (" ; Bonjour, monde ! " ;)); //center l'armature sur l'écran f.setLocationRelativeTo (nulle) ; /* se rappellent les dispositions relatives de l'oscillation ? le paquet () indique le conteneur à remplir (ici " ; this" ; JFrame) pour qu'il emballe de façon optimale ses composants selon sa disposition.setVisible (vrai) ; } }

Voir également

Verre de regard de projet
Événement de expédiant le fil
Directeur de disposition de
SwingWorker
CookSwing
Trousse à outils de gadget de
SwingLabs
Cadre d'application d'oscillation de
Bibliothèque de classe de Java de

Random links: