1. Gestion des événements
En fait, le nom du traitement des événements est naturellement pensé au mécanisme de réponse des messages dans MFC. Pour autant que je comprends, ils doivent être considérés comme la situation des oranges du sud et des agrumes du nord. Je soupçonne que la "nouvelle bouteille" de traitement d'événements en Java devrait être la réponse du message dans MFC.
Les soi-disant «événements» sont des modifications telles que les clés du clavier, les clics de souris, etc. Nous pouvons diviser les événements en Java en plusieurs catégories: boutons, souris, clavier, fenêtre et autres événements.
Modèle de traitement des événements
1. Modèle de traitement des événements hérités (JDK1.0)
Dans JDK1.0, le traitement des événements est basé sur l'héritage. Les événements sont d'abord envoyés au composant, puis se propagent vers le haut le long du niveau de conteneur. Les événements qui ne sont pas traités par le composant continueront automatiquement à se propager au conteneur du composant. - Cela semble être cohérent avec l'ordre de réponse des événements d'origine ou le mécanisme de réponse polymorphe dans MFC, et le mécanisme de traitement des événements basé sur proxy mentionné plus loin semble être cohérent avec le mécanisme de rappel MFC.
Méthodes de traitement spécifiques
Appelez la méthode Action () ou HandleEvent () pour obtenir les événements qui se produisent lorsque le programme est en cours d'exécution, et tous les événements qui se produisent dans le composant sont gérés dans cette méthode.
2. Modèle de traitement d'événements basé sur des agents (JDK1.1)
Dans ce modèle, les événements sont envoyés directement au composant qui produit cet événement.
Pour chaque composant, une ou plusieurs classes appelées auditeurs sont enregistrées, qui contiennent des gestionnaires d'événements qui reçoivent et traitent cet événement.
L'auditeur est une classe qui implémente l'interface de l'écoute. Les événements sont des objets signalés uniquement aux auditeurs enregistrés. Chaque événement a une interface d'écoute correspondante.
Lorsque vous cliquez sur l'objet du bouton avec la souris, un événement ActionEvent sera envoyé. Cet événement ActionEvent sera reçu par la méthode ActionPerformEd () de toutes les ActionListener enregistrées à l'aide de la méthode addActionListener ().
Les fonctionnalités des événements de traitement d'événements basées sur des agents ① ne seront pas traitées de manière inattendue. Dans un modèle hiérarchique, un événement peut se propager au conteneur et être traité à un niveau inattendu.
② Il est possible de créer et d'utiliser la classe d'adaptateur pour classer les actions d'événements.
③Ce est propice à la distribution de travaux à diverses catégories.
Concentrez-vous sur l'apprentissage de ce modèle de traitement d'événements
3. Événements
Trois éléments de traitement des événements.
(1) Source de l'événement La source d'événement est le générateur d'un événement, tel que les boutons, les fenêtres et les champs de texte.
(2) Type d'événements Tous les événements de Java sont encapsulés dans une classe, et ces classes d'événements sont concentrées dans le package java.awt.event. Toutes les classes d'événements héritent de la classe Awtevent et d'une méthode de méthode - getouce (), qui renvoie l'objet où l'événement s'est produit.
(3) Après que différents types d'événements se produisent dans l'écouteur d'événements, l'écouteur d'événements reçoit l'événement et appelle la méthode de traitement des événements correspondante. Tous les écouteurs d'événements sont en fait une interface du package java.awt.event, introduisant l'interface java.util.eventListener. Les auditeurs de différents types d'événements ont des méthodes différentes.
Étapes de traitement des événements ① Le programme ajoute le package java.awt.event:
Import java.awt.event;
② Enregistrez un écouteur d'événements pour l'objet source d'événement requis:
Event Source Object.AddxxxListener (xxxListener);
③ Implémentez la méthode correspondante. Si une interface d'écoute contient plusieurs méthodes, vous devez implémenter tous les exemples de méthode: b2.AddactionListener (this)
4. Adaptateurs d'événements (adaptateur)
La charge de travail de la mise en œuvre de toutes les méthodes de chaque interface d'écoute est très élevée. Pour plus de commodité, le langage Java fournit la classe Adaptors pour implémenter des classes contenant plusieurs méthodes.
L'auditeur que vous définissez peut hériter de la classe d'adaptateur et simplement remplacer les méthodes dont vous avez besoin.
Par exemple, l'écouteur correspondant à l'événement Window est WindowListener, qui doit implémenter plusieurs méthodes, y compris WindowOpenned (), WindowClosed (), WindowCling (), WindowIconfied (), WindowDeIConfied (), WindowActivated () et WindowDeativated (), qui augmente la charge de travail de programmation non inutile.
Si vous héritez de WindowAdapter, vous n'avez qu'à implémenter une ou plusieurs des méthodes, et vous n'avez pas besoin d'implémenter toutes les méthodes. Beaucoup des exemples suivants implémentent une seule méthode de WindowClosing (), dans le but de quitter le système lors de la fermeture de la fenêtre.
4.1 Gestion des événements boutonnés
L'événement qui se produit lorsque vous cliquez sur le bouton est un événement d'action. La classe d'événements correspondant à l'événement d'action est la classe ActionEvent. L'auditeur de l'événement correspondant à l'événement d'action est: ActionListener
Les principales méthodes des auditeurs:
ActionPerformed (ActionEvent E) Le projet d'opération qui est appelé lorsqu'un événement d'action se produit:
La première étape consiste à enregistrer l'écouteur de l'événement Action AddActionListener (ActionListener).
La deuxième étape consiste à implémenter la méthode de l'interface ActionListener: ActionPerformed (ActionEvent E)
4.2 Gestion des événements de souris
La source d'événement qui déclenche un événement de souris est généralement un conteneur. Lorsque la souris entre ou quitte le conteneur ou clique sur la souris, traîne la souris, etc. Dans le conteneur, l'événement de la souris se produira. La classe d'événements correspondant à l'événement de la souris est la classe Mouseevent.
Méthodes en classe Mouseevent:
getX () obtient la coordonnée x de la souris
gety () obtient la coordonnée y de la souris
GetPoint () obtient la position de la souris et l'événement de la souris correspond à deux auditeurs d'événements: MouseListener (ou Mouseadapter) correspond à l'événement de souris, et MouseMotionListener (ou MousemotionAdapter) correspond à l'événement de mouvement de la souris.
La principale méthode de MouseListener (ou Mouseadapter)
Mousprimé (Mouseevent E) Comment gérer la pression de la souris
MouseLelent (Mouseevent E) Comment gérer la libération de la souris
Mouseentered (Mouseevent E) Comment gérer la souris lors de l'entrée
Mousexited (Mouseevent E) Comment gérer la souris en quittant
Mouseclicked (Mouseevent E) Comment gérer le clic de la souris
La principale méthode de MouseMotionListener (ou MousemotionAdapter)
MousMoved (Mouseevent E) Comment gérer la souris lors du déménagement
MousedRaged (Mouseevent E) Comment gérer la traînée de la souris
4.3 Gestion des événements de clavier
Lorsque vous appuyez ou relâchez le clavier dans un composant avec une mise au point du clavier, des événements de clavier se produisent. La classe d'événements correspondant à l'événement du clavier est la classe KeyEvent
Méthodes principales de la classe KeyEvent:
getKeyCode () obtient le code de clé à appuyer ou libéré
getKeyText () obtient la chaîne de la touche appuyée ou libérée. L'auditeur d'événements correspondant à l'événement du clavier est: KeyListener ou KeyAdapter
Méthodes principales:
KeyPressed (KeyEvent E) Comment gérer lors de l'appuyer sur le clavier
Keyreled (KeyEvent E) Comment gérer le clavier lors de la libération
4.4 Gestion des événements de fenêtre
Seulement s'il y a une fenêtre et ses classes étendues (cadre, boîte de dialogue), etc., les événements de fenêtre peuvent être déclenchés, indiquant que la fenêtre est à l'état actif / non valide, à l'état d'icône / non-ICON ou à l'état ouvert / ferme, etc. La classe correspondante est WindowEvent, et l'auditeur est WindowListener (ou WindowAdapter)
Méthodes principales:
Windowovered (WindowEvent E) Gestion des événements de la fenêtre d'ouverture
WindowClosed (WindowEvent E) Gestion des événements de la fenêtre de clôture
WindowClosing (WindowEvent E) Clôture Traitement des événements de la fenêtre
Gestion des événements de l'état d'activation des fenêtres (WindowEvent E)
Gestion des événements du statut non valide de WindowDeativated (WindowEvent E)
4.5 Gestion des autres événements
4.5.1 La classe d'événements pour la case à cocher et le traitement de l'événement des boutons radio est itemEvent:
L'auditeur d'événements correspondant à l'événement d'option est: itemListener
méthode:
itemStateChanged (itemEvent e) est appelé lorsque l'événement d'option se produit 4.5.2 La classe d'événements correspondant à l'événement de réglage de traitement de l'événement de la barre de scroll est la classe Régalation de Réglage:
L'auditeur d'événements correspondant à l'événement de réglage est: AjustementListener
méthode:
ajustementValueChanged (ajustementEvent e) est appelé lorsque l'événement de réglage se produit
4.5.3 La classe d'événements de traitement des événements dans la liste déroulante est itemEvent:
L'auditeur d'événements correspondant à l'événement d'option est: itemListener
méthode:
ItemStateChanged (itemEvent E) est appelé lorsqu'une action se produit dans la liste déroulante
(On peut voir que le traitement des événements de la liste déroulante est le même que le type d'événement, l'écouteur d'événements et la méthode, car le traitement des événements de la case, le type d'événement, l'écouteur d'événements et la méthode du traitement des événements de la zone de radio)
4.5.4 Gestion des événements des événements de menu Les événements de menu sont généralement un événement qui se produit lorsque nous cliquons sur un élément de menu.
Il existe deux types d'éléments de menu:
Événement d'action MenuItem
CheckboxMenuem, événement d'option
La première étape du traitement de l'événement de MenuItem consiste à enregistrer l'événement Action Event Addiner AddActionListener (ActionListener) pour tous les éléments de menu MeniUtem.
La deuxième étape consiste à implémenter la méthode d'interface ActionListener: ActionPerformed (ActionEvent E). Dans cette méthode, utilisez e.getsource () pour obtenir l'élément de menu sélectionné par l'utilisateur et effectuer un traitement correspondant.
La première étape de la gestion de l'événement de CheckBoxMenuItem consiste à enregistrer l'écouteur de l'événement d'option pour tous les éléments de menu CheckMenuItem sur additemListener (itemListener).
La deuxième étape consiste à implémenter la méthode d'interface ItemListener: itemStateChanged (itemEvent E). Dans cette méthode, utilisez e.getSource () pour effectuer l'élément de menu sélectionné par l'utilisateur, e.getItem () pour effectuer l'étiquette de l'élément de menu sélectionné par l'utilisateur, et e.getStateChange () pour obtenir s'il est sélectionné et effectuer un traitement correspondant.
2. Gestion des exceptions
Aucun bon langage de programmation ou programmeur n'ignorera la gestion des exceptions. En tant que langage de programmation populaire orienté objet, Java, le mécanisme de gestion des exceptions est naturellement l'une de ses caractéristiques importantes.
D'une manière générale, les exceptions sont décrites comme: Erreurs dans la programmation. Cependant, en fait, cette erreur est très fréquente, avec de nombreux types, tels que: les erreurs de compilation et les erreurs de fonctionnement (en particulier, il est divisé en: erreurs de fonctionnement du système et erreurs de fonctionnement logiques. Quelles erreurs de fonctionnement du système sont rarement considérées comme des erreurs de programmation, avant.)
En Java, une exception est une classe qui hérite de la classe jetable. Chaque classe d'exception représente une erreur d'exécution (Remarque: il s'agit d'une erreur d'exécution). La classe d'exception contient des informations sur l'erreur de fonctionnement et la méthode de gestion de l'erreur.
Mécanisme de manipulation des exceptions Java:
Chaque fois qu'une erreur de fonctionnement identifiable se produit pendant l'opération du programme Java (c'est-à-dire lorsque l'erreur a une classe d'exception correspondant à lui), le système générera un objet correspondant de la classe d'exception (note: il s'appelle générer un objet de classe d'exception.) C'est-à-dire une exception est générée.
Une fois un objet d'exception généré, il doit y avoir un mécanisme correspondant dans le système pour le gérer pour s'assurer qu'il n'y aura pas de plantages, de boucles mortes ou d'autres dommages au système d'exploitation, garantissant ainsi la sécurité du fonctionnement de l'ensemble du programme.
Classes d'exception et d'exception:
Erreur: généré et lancé par la machine virtuelle Java, et le programme Java ne le gère pas.
Exception d'exécution (erreurs système telles que 0, les indices de tableau dépassent la plage): détecté par le système, le programme Java de l'utilisateur ne peut pas être traité et le système les a remis au gestionnaire d'exceptions par défaut (Remarque: il y a une manipulation d'exception par défaut).
Exception (Problèmes dans le programme, prévisible): Le compilateur Java exige que le programme Java doit attraper ou déclarer toutes les exceptions non runtimes que les utilisateurs génèrent leurs propres exceptions.
Constructeur de classe d'exception:
Exception publique ();
Exception publique (chaînes S); Peut accepter les informations transmises par les paramètres de chaîne, qui est généralement une description de l'erreur correspondant à l'exception.
La classe d'exception hérite également de plusieurs méthodes du père jetable, parmi lesquels les couramment utilisés sont:
1) public String toString ();
La méthode toString () renvoie une chaîne décrivant les informations actuelles de classe d'exception.
2) public void printstackTrace ();
La méthode printStackTrace () n'a aucune valeur de retour. Sa fonction consiste à terminer une opération d'impression et à imprimer la piste d'utilisation de la pile de l'objet d'exception actuel sur la sortie standard actuelle (généralement l'écran), c'est-à-dire que le programme appelle quels objets ou classes pour exécuter des méthodes, afin que cet objet d'exception soit généré pendant l'opération.
Exception de fonctionnement défini par le système
Certaines de ces sous-classes sont définies à l'avance par le système et incluses dans la bibliothèque de classe Java, et sont appelées exceptions de fonctionnement défini par le système
Exceptions définies par l'utilisateur
Pour les erreurs de fonctionnement uniques à une certaine application, les programmeurs doivent créer des classes d'exception définies par l'utilisateur et des objets d'exception dans le programme utilisateur en fonction de la logique spéciale du programme. Les exceptions définies par l'utilisateur sont généralement utilisées comme classe parent de la classe d'exception. Cependant, il y a un problème qui n'a pas encore été compris: comment le système sait-il qu'une erreur se produit et qu'elle est reconnaissable? Comment générer des objets de classe d'exception correspondants? Comment savez-vous comment résoudre l'objet de classe d'exception en utilisant la méthode correspondante? Chaque classe de classe d'exception qui gère l'exception correspondante n'a-t-elle qu'une seule méthode de gestion d'exception? - `` are
Lors de la création d'exceptions définies par l'utilisateur, les tâches suivantes sont généralement requises:
1) Déclarez une nouvelle classe d'exception, afin qu'il prenne la classe d'exception ou toute autre classe d'exception système existante ou exception utilisateur comme classe parent.
2) Définissez les attributs et les méthodes pour la nouvelle classe d'exception, ou surchargez les attributs et les méthodes de la classe parent afin que ces attributs et méthodes puissent refléter les informations d'erreur correspondant à la classe.
Exception lancée
Si un programme Java soulève une erreur identifiable lors de son exécution, elle générera un objet de la classe d'exception correspondant à l'erreur. Ce processus est appelé lancer des exceptions.
Il lance en fait une instance de l'objet de classe d'exception correspondant.
Selon la classe des exceptions, il existe deux façons de lancer des exceptions: le lancer automatique du système et le lancer des utilisateurs:
1. Le système le jettera automatiquement
Les exceptions d'erreur de fonctionnement définies par le système sont automatiquement lancées par le système.
2. Les lancers de l'utilisateur
Les exceptions définies par l'utilisateur ne peuvent pas être automatiquement lancées par le système, mais doivent être lancées par l'utilisateur dans les instructions Java. Dans les instructions Java, l'instruction Throw est utilisée pour lancer explicitement une "exception".
Nom de la méthode de retour de type (liste de paramètres) au format lance la liste des noms de classe d'exception à lancer {
…
lancer une instance de classe d'exception; // note ici ...
}
Avis:
1) Généralement, une exception est lancée lorsqu'une certaine condition est remplie dans le programme;
Mettez souvent la déclaration de lancer dans la branche if de la déclaration IF,
si (i> 100)
lancer (new myException ());
2) Pour les méthodes contenant des instructions de lancer, les parties suivantes doivent être ajoutées à la définition de l'en-tête de méthode:
Jette la liste des noms de classe d'exception à lancer. Il s'agit principalement d'informer la méthode supérieure pour appeler cette méthode et de se préparer à accepter et à gérer les exceptions qu'il peut lancer pendant l'exécution. S'il y a plusieurs instructions de lancer dans la méthode, toutes les exceptions possibles doivent être répertoriées dans les lancers d'en-tête de méthode.
3) La langue Java exige que toutes les classes déclarées avec le mot-clé lance et les objets lancées avec Throw soient une classe jetable ou sa sous-classe. Si vous essayez de lancer un objet qui n'est pas jetable, le compilateur Java rapportera une exception d'erreur:
Considérez principalement comment prendre des exceptions, comment sauter après avoir attrapé des exceptions et comment rédiger des déclarations de traitement des exceptions
1. Essayez… attraper… enfin bloquer
1) Essayez
L'instruction {} dans l'instruction Try contient un code de programme qui peut lancer une ou plusieurs exceptions. Ces codes spécifient en fait la plage d'exceptions qui peuvent être capturées par le bloc de capture après.
Si une exception se produit lorsqu'un programme Java se heurte à une instruction dans un bloc d'essai, il ne continue plus d'exécuter d'autres instructions dans le bloc d'essai, mais entre directement dans le bloc Catch pour trouver le premier type d'exception correspondant et le traiter.
2) Catch Block
Les paramètres de l'instruction Catch sont similaires à la définition d'une méthode, y compris un type d'exception et un objet d'exception.
Le type d'exception doit être une sous-classe de la classe jetable, qui spécifie le type d'exception géré par l'instruction Catch;
L'objet Exception est le code de méthode pour gérer l'objet d'exception dans les accolades bouclées lancées par le système d'exécution Java dans le bloc de code de programme spécifié par l'essai.
Il peut y avoir plusieurs instructions de capture qui gèrent séparément différents types d'exceptions.
Le système Java Runtime détecte le type d'exception traité par chaque instruction de capture de haut en bas, jusqu'à ce qu'il trouve une instruction CATCH qui correspond.
Ici, la correspondance de type signifie que le type d'exception dans Catch est exactement le même que le type de l'objet d'exception généré ou la classe parent de l'objet d'exception. Par conséquent, l'ordre de tri de l'énoncé de capture devrait être de spécial au général. (Pensez à pourquoi?)
3) Bloquer enfin
La déclaration finalement peut être considérée comme un mécanisme de nettoyage prévu pour les événements de gestion des exceptions. Il est généralement utilisé pour fermer les fichiers ou libérer d'autres ressources système. L'énoncé d'essai et finalement peut avoir une déclaration avec une partie enfin.
S'il n'y a pas de pièce enfin, lorsque le code de programme spécifié par TRY lance une exception, d'autres codes de programme ne seront pas exécutés;
S'il y a une partie enfin, peu importe si une exception se produit dans le bloc d'essai ou si une pièce de capture a été exécutée, l'instruction enfin de la pièce doit être exécutée.
On peut voir que la partie enfin de l'instruction fournit une sortie unifiée pour la gestion des exceptions.
Plusieurs exceptions peuvent produire plusieurs exceptions différentes, et si vous souhaitez prendre différentes méthodes pour gérer ces exceptions, vous devez utiliser un mécanisme de gestion des exceptions à plusieurs exceptions.
Le traitement des exceptions multiples est obtenu en définissant plusieurs blocs de capture après un bloc d'essai. Chaque bloc de capture est utilisé pour recevoir et traiter un objet d'exception spécifique. Grâce aux paramètres du bloc de capture, il détermine si un objet d'exception doit être une exception reçue et traitée par ce bloc de capture.
Quel bloc de capture est obtenu? Selon la correspondance des paramètres d'exception de l'objet d'exception et du bloc de capture: lorsqu'ils remplissent l'une des trois conditions suivantes, l'objet d'exception et le paramètre sont considérés comme correspondant:
1) L'objet d'exception appartient à la même classe d'exception que le paramètre.
2) L'objet d'exception appartient à une sous-classe de la classe d'exception des paramètres.
3) L'objet d'exception implémente l'interface définie par les paramètres.
Si l'objet exceptionnel généré par le bloc d'essai est reçu par le premier bloc de capture, le flux du programme sautera directement à ce bloc de déclaration de capture. Une fois le bloc d'instructions exécuté, la méthode actuelle sera sortie. Les instructions qui n'ont pas été exécutées dans le bloc d'essai et d'autres blocs de capture seront ignorées. Si l'objet d'exception généré par le bloc d'essai ne correspond pas au premier bloc de capture, le système passera automatiquement au deuxième bloc de capture pour la correspondance. Si la seconde ne correspond toujours pas, elle passera au troisième, quatrième ... jusqu'à ce qu'un bloc de capture puisse recevoir l'objet d'exception est trouvé et que le processus sera terminé.
Si l'objet exceptionnel généré par le bloc d'essai est reçu par le premier bloc de capture, le flux du programme sautera directement à ce bloc de déclaration de capture. Une fois le bloc d'instructions exécuté, la méthode actuelle sera sortie. Les instructions qui n'ont pas été exécutées dans le bloc d'essai et d'autres blocs de capture seront ignorées. Si l'objet d'exception généré par le bloc d'essai ne correspond pas au premier bloc de capture, le système passera automatiquement au deuxième bloc de capture pour la correspondance. Si la seconde ne correspond toujours pas, elle passera au troisième, quatrième ... jusqu'à ce qu'un bloc de capture puisse recevoir l'objet d'exception est trouvé et que le processus sera terminé.
Si l'exécution de toutes les instructions du bloc Try ne soulève pas d'exception, tous les blocs de capture seront ignorés et non exécutés.
Avis:
1) Les déclarations du bloc Catch doivent effectuer différentes opérations en fonction des différentes exceptions, donc lorsque vous traitez avec plusieurs exceptions, vous devez prêter attention à concevoir soigneusement l'ordre d'arrangement de chaque bloc de capture. Généralement, les blocs de capture qui traitent des exceptions plus spécifiques et courants doivent être placés devant, tandis que les blocs de capture qui peuvent correspondre à plusieurs exceptions doivent être placés à l'arrière.
/ * Essayez l'utilisateur pour exécuter la gestion de l'exception d'erreur: le problème est le suivant. Lorsque la valeur initiale du salaire de l'utilisateur entré est inférieure à 800, c'est faux. Bien sûr, si le changement de salaire dépasse 20%, il est également faux * / import java.awt. *; import java.applet. *; import java.awt.event. *; classe publique UseRexceptionApplet étend Applet implémente ActionListener {label prompx1 = new Label ("Veuillez saisir le nom de l'employé et la valeur initiale du salaire:"); Étiquette invite2 = new Label ("Veuillez saisir le salaire à modifier"); Nom de TextField, Isal, NSAL; String msg; Employée EMP; Bouton okbtn = nouveau bouton ("ok"); Button Annulebtn = nouveau bouton ("COMMER"); public void init () {name = new TextField (5); ISAL = new TextField (5); nsal = new TextField (5); ajouter (prompt1); ajouter (nom); Ajouter (ISAL); ajouter (prompt2); ajouter (nsal); ajouter (okbtn); okbtn.addactionListener (this); CancelBtn.AddActionListener (this); ajouter (annuler); } public void peinture (graphiques g) {g.drawstring (msg, 0,80); } public void CreateEmp (String EmpName, double sa) {try {emp = nouvel employé (empname, sa); msg = new String (emp.ToString ()); } catch (illégalsalaryException est) {msg = new String (ise.toString ()); }} public void ChangeEmpsal (double changeal) {try {emp.sempsalary (changeal); msg = new String (emp.ToString ()); } catch (illégalsalaryException illSal) {msg = new String (illsal.toString ()); } catch (illégalsalaryChangeException illsalchange) {msg = new String (emp.toString () + illsalchange.toString ()); }} public void ActionPerformed (ActionEvent e) {String EmpName; double empsal, changeant; Objet obj = e.getSource (); if (obj == okbtn) {empname = new String (name.getText ()); if (empname == null) {msg = new String ("Veuillez d'abord entrer le nom et le salaire de l'employé et le créer"); } if (nsal.getText () == null) {empsal = double.valueof (isal.getText ()). doubleValue (); CreateEmp (empname, empsal); } else {changeal = double.valueof (nsal.getText ()). doubleValue (); ChangeEmppsal (changeant); }} if (obj == ansemblbtn) {naem.setText (""); ISAL.SETTEXT (""); nsal.setText (""); } repeain (); }} classe Employee {String m_empname; Double M_EMPSALARY; Employee (String Name, Double Initial) lève illégalsAlaryException {m_empname = name; // voir s'il y a un problème ici, le code de référence est m_empname = new String (name); if (initsalary <800) {throw (new illégalsalaryException (this, initsalary)); // instruction} m_empsalary = initsalary; } public String getEmpName () {return m_empname; } public double getEmpsalary () {return m_Empsalary; } public Boolean SetEmpsalary (Double Newsal) lève illégalsalaryException, illégalsalaryChangeException {if (newal <800) Throw (new illégalsalaryException (this, newsal)); else if (getEmpsalary () == 0,0) {m_Empsalary = newsal; Retour Vrai; } else if (math.abs (newsal-getEmpsalary ()) / getEmpsalary ()> = 0,2) Throw (new illégalaryChangeException (this, newsal-getEmpsalary ())); else {m_Empsalary = newsal; Retour Vrai; }} public String toString () {String S; s = "name:" + m_empname + "salaire:" + m_empsalary; retour s; }} classe illégalsalaryException étend une exception {employé privé m_concerndemp; Double privé M_ILLEGalSalary; IllégalsalaryException (Employee EMP, double isal) {super ("salaire est inférieur au salaire minimum"); m_concerndemp = emp; m_illegalsalary = isal; } public String toString () {String S; S = "Les salaires fournis aux employés sont illégaux: les employés:" + m_concernedemp.getempname () + "Salaire illégal:" + m_illegalary + "inférieur au salaire minimum du montant de RMB 800"; retour s; }} classe illégalsalaryChangeException étend une exception {employé privé m_concerndemp; Double privé M_ILLEGALSALARYCHANGE; IllégalsalaryChangeException (employé EMP, double csal) {super ("Le changement de salaire est trop grand"); m_concerndemp = emp; m_illegalsalarychange = csal; } public String toString () {String S; S = "Le changement de salaire fourni aux employés est illégal: Employé:" + m_concernedemp.getempname () + "Changement illégal du changement de salaire:" + m_illegalsalarychange + "20% plus élevé que le salaire d'origine"; retour s; }}