Analyser les mécanismes de gestion des événements et des exceptions en Java

1. Traitement des événements
En fait, le nom traitement des événements me rappelle naturellement le mécanisme de réponse aux messages dans MFC. D'après mon expérience, ils devraient être considérés comme la situation de Nanjue et Beizhi, je soupçonne le traitement des événements en Java. Cette « nouvelle bouteille » devrait être le message du MFC qui répond à ce « vieux vin ».
Les soi-disant « événements » sont des changements tels que les touches du clavier, les clics de souris, etc. qui sont provoqués par des actions ou quelque chose qui provoquent un changement d'état et nécessitent une réponse correspondante à ce changement. Nous pouvons diviser les événements en Java en plusieurs catégories : bouton, souris, clavier, fenêtre et autres événements.
Modèle de traitement des événements
1. Modèle de traitement des événements basé sur l'héritage (JDK1.0)
Dans JDK1.0, le traitement des événements est basé sur l'héritage. Les événements sont d'abord envoyés aux composants, puis propagés vers le haut le long du conteneur. hiérarchie. Les événements qui ne sont pas gérés par un composant sont automatiquement propagés vers le conteneur du composant. ——Cela semble être cohérent avec la séquence de réponse aux é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 un agent mentionné plus loin semble être cohérent avec le mécanisme de rappel de MFC.
Méthode de traitement spécifique
Appelez la méthode action() ou la méthode handleEvent() pour obtenir les événements qui se produisent lors de l'exécution du programme. Les événements qui se produisent dans tous les composants sont traités dans cette méthode.
2. Modèle de traitement d'événements basé sur un agent (JDK1.1)
Dans ce modèle, les événements sont envoyés directement au composant qui génère l'événement
Pour chaque composant, enregistrez un ou plusieurs auditeurs. Ces classes contiennent. gestionnaires d’événements qui reçoivent et traitent l’événement.
Un auditeur est une classe qui implémente l'interface Listener. Les événements sont des objets signalés uniquement aux auditeurs enregistrés. Chaque événement possède une interface d'écoute correspondante.
Lorsque vous cliquez avec la souris sur l'objet Button, un événement ActionEvent sera envoyé. Cet événement ActionEvent sera reçu par la méthode actionPerformed() de tous les ActionListeners enregistrés à l'aide de la méthode addActionListener().
Fonctionnalités du modèle de traitement des événements basé sur un agent
①Les événements ne seront pas gérés accidentellement. Dans le 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 des classes d'adaptateur pour classer les actions d'événements.
③Il est utile de répartir le travail en différentes catégories.
Concentrez-vous sur l'apprentissage de ce modèle de traitement d'événements
3. Événements
Les trois éléments du traitement d'événements.
(1) Source d'événement La source d'événement est le générateur d'un événement, tel que des boutons, des fenêtres, des champs de texte, etc.
(2) Type d'événement Tous les événements en Java sont encapsulés dans une classe. 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 method-getSouce(). La méthode renvoie l'objet où l'événement s'est produit.
(3) Écouteur d'événement Après que différents types d'événements se soient produits, l'écouteur d'événement reçoit l'événement et appelle la méthode de traitement d'événement correspondante. Tous les écouteurs d'événements sont en fait des interfaces du package java.awt.event, qui introduit l'interface java.util.EventListener. Les écouteurs pour différents types d'événements ont des méthodes différentes.
Étapes de traitement des événements
① Ajoutez le programme au package java.awt.event :
Importez java.awt.event
② Enregistrez un écouteur d'événement pour l'objet source d'événement requis :
Source de l'événement Object.addXXXListener(XXXListener);
③ Implémentez la méthode correspondante. Si une interface d'écoute contient plusieurs méthodes, vous devez implémenter toutes les méthodes
Exemple : b2.addActionListener(this)
4 Adaptateurs d'événement (adaptateurs)
Implémenter toutes les méthodes de chaque interface d'écoute La charge de travail est très importante. . Pour plus de commodité, le langage Java fournit la classe Adapters pour implémenter des classes avec plusieurs méthodes.
Le Listener que vous définissez peut hériter de la classe Adapter et n'a besoin que de 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, notamment windowOpened(), windowClosed(), windowClosing(), WindowIconfied(), WindowDeiconfied(), WindowActivated(), WindowDeactivated() , Cela augmente la charge de travail de programmation inutile.
Si vous héritez de WindowAdapter, vous n'avez besoin d'implémenter qu'une ou quelques méthodes, pas toutes les méthodes. La plupart des exemples suivants implémentent uniquement la méthode windowClosing(), dans le but de quitter le système lorsque la fenêtre est fermée.
4.1 Traitement des événements de bouton
L'événement qui se produit lorsqu'un bouton est cliqué est un événement d'action
La classe d'événement correspondant à l'événement d'action est la classe ActionEvent
L'écouteur d'événement correspondant à l'événement d'action est : ActionListener
La méthode principale de l'écouteur :
actionPerformed(ActionEvent e) est appelée lorsqu'un événement d'action se produit
Implémenter le projet d'opération de l'événement d'action :
La première étape consiste à enregistrer le écouteur d'événements d'action addActionListener (ActionListener).
La deuxième étape consiste à implémenter la méthode de l'interface ActionListener : actionPerformed(ActionEvent e)
4.2 Traitement des événements de souris
La source d'événement qui déclenche les événements de souris est généralement un conteneur Lorsque la souris entre ou quitte le conteneur, ou lorsque la souris est cliquée ou glissée dans le conteneur, des événements de souris se produisent
La classe d'événements correspondant à l'événement de souris est MouseEvent. class
Méthodes dans la classe MouseEvent :
getX() récupère la coordonnée X de la souris
getY() récupère la coordonnée Y de la souris
getPoint() récupère la position de la souris
Les écouteurs d'événements correspondant aux événements de souris sont au nombre de deux : MouseListener (ou MouseAdapter) correspond aux événements de souris, et MouseMotionListener (ou MouseMotionAdapter) correspond aux événements de mouvements de souris.
La méthode principale de MouseListener (ou MouseAdapter)
MousePressed(MouseEvent e) La méthode de traitement lorsque la souris est enfoncée
MouseReleased(MouseEvent e) La méthode de traitement lorsque la souris est relâchée
MouseEntered(MouseEvent e) La souris entre La méthode de traitement lorsque la souris quitte
MouseExited(MouseEvent e) La méthode de traitement lorsque la souris quitte la souris
La méthode de traitement lorsque la souris clique MouseClicked(MouseEvent e)

Principales méthodes de MouseMotionListener (ou MouseMotionAdapter)
MouseMoved(MouseEvent e) Méthode de traitement lorsque la souris se déplace
MouseDraged(MouseEvent e) Méthode de traitement lorsque la souris glisse
4.3 Traitement des événements de clavier
Des événements de clavier se produisent lorsque le clavier est enfoncé ou relâché dans un composant avec le focus clavier.
La classe d'événement correspondant à l'événement clavier est la classe KeyEvent.
La méthode principale de la classe KeyEvent :
getKeyCode(). code enfoncé ou relâché
getKeyText() récupère la chaîne de la touche enfoncée ou relâchée
L'écouteur d'événement correspondant à l'événement clavier est : KeyListener ou KeyAdapter
Méthode principale :
KeyPressed(KeyEvent e) Processing méthode lorsque le clavier est enfoncé
Méthode de traitement lorsque le clavier est relâché KeyReleased (KeyEvent e)
4.4 Traitement des événements de fenêtre
Il ne peut être déclenché que par Window et ses classes étendues (Frame, Dialog), etc. . Les événements de fenêtre, indiquant que la fenêtre est dans un état actif/invalide, un état icône/non-icône ou un état ouvert/fermé, etc.
La classe correspondant à l'événement fenêtre est WindowEvent, et l'écouteur est WindowListener (ou . WindowAdapter)
Méthode principale :
traitement événementiel windowOpened (WindowEvent e) pour ouvrir la fenêtre
traitement événementiel windowClosed (WindowEvent e) pour fermer la fenêtre
traitement événementiel windowClosing (WindowEvent e) pour fermer la fenêtre
Traitement des événements WindowActivated (WindowEvent e) pour activer l'état
WindowDeactivated (WindowEvent e) Traitement des événements d'état invalide
4.5 Autres traitements d'événements
4.5.1 Traitement des événements de case à cocher et de bouton radio
Le la classe d'événement est ItemEvent :
Correspondance d'événement d'option L'écouteur d'événement est : ItemListener
Méthode :
ItemStateChanged (ItemEvent e) est appelé lorsqu'un événement d'option se produit
4.5.2 Traitement des événements de la barre de défilement
La classe d'événement correspondant à l'événement d'ajustement est la classe AdjustmentEvent :
L'écouteur d'événement correspondant à l'événement d'ajustement est : AdjustmentListener
Méthode :
ajustementValueChanged (AdjustmentEvent e) est appelé lorsqu'un événement d'ajustement se produit
4.5.3 Traitement événementiel de la liste déroulante
La classe d'événement est Item Event :
L'écouteur d'événement correspondant à l'option event 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 et le type d'événement de la liste déroulante, les écouteurs et les méthodes d'événements sont les mêmes que les gestionnaires d'événements pour les cases à cocher et les boutons radio )
4.5.4 Traitement des événements de menu
Les événements de menu se produisent généralement lorsque nous cliquons sur des événements de menu survenus pendant l'élément.
Il existe deux types d'éléments de menu :
Événement d'action MenuItem
CheckboxMenuItem, événement d'option
Traitement des événements MenuItem
La première étape consiste à enregistrer les moniteurs d'événements d'action pour tous les éléments de menu MenuItem Listener addActionListener( ActionListener ).
La deuxième étape consiste à implémenter la méthode de l'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 le traitement correspondant.
Gestion des événements de CheckboxMenuItem
La première étape consiste à enregistrer l'option d'écoute d'événement addItemListener (ItemListener) pour tous les éléments du menu CheckMenuItem.
La deuxième étape consiste à implémenter la méthode de l'interface ItemListener : itemStateChanged(ItemEvent e). Dans cette méthode, utilisez e.getSource() pour obtenir l'élément de menu sélectionné par l'utilisateur, e.getItem() pour obtenir l'étiquette de l'élément de menu sélectionné par l'utilisateur et e.getStateChange() pour savoir s'il est sélectionné. , et effectuez le traitement correspondant.

2. Gestion des exceptions
Tout bon langage de programmation et les programmeurs n'ignoreront pas la gestion des exceptions. En tant que langage de programmation orienté objet populaire - Java, le mécanisme de gestion des exceptions est naturellement l'une de ses fonctionnalités importantes.
Généralement, lorsqu'on explique les exceptions, on dit qu'il s'agit d'erreurs de programmation. Cependant, en fait, cette erreur est très fréquente et il en existe de nombreux types, tels que : erreur de compilation, erreur de fonctionnement (plus précisément, elle est divisée en : erreur de fonctionnement du système et erreur d'opération logique. Ce type d'erreur de fonctionnement du système, je l'ai rarement comptez-le comme c'est une erreur de programmation, avant. )
En JAVA, une exception est une classe qui hérite de la classe Throwable. 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 les erreurs d'exécution et les méthodes de gestion des erreurs.
Mécanisme de gestion des exceptions de Java :
Chaque fois qu'une erreur d'exécution reconnaissable se produit lors de l'exécution d'un programme Java (c'est-à-dire lorsque l'erreur est associée à une classe d'exception), le système génère un objet An correspondant du classe d'exception (remarque : cela s'appelle générer un objet de classe d'exception.) signifie générer une exception.
Une fois qu'un objet anormal est généré, le système doit disposer d'un mécanisme correspondant pour le gérer afin de garantir qu'aucun crash, boucle infinie ou autre dommage au système d'exploitation ne se produira, garantissant ainsi la sécurité de l'ensemble du programme
Exceptions et classes d'exception :
Erreur : générée et lancée par la machine virtuelle Java, et non traitée par le programme Java.
Exception d'exécution (erreurs système telles que division par 0, indice de tableau hors plage) : détectée par le système, les programmes Java de l'utilisateur n'ont pas besoin d'être traités et le système les remettra au gestionnaire d'exceptions par défaut (remarque : il existe une gestion des exceptions par défaut
Exception (problèmes dans le programme, prévisibles) : Le Java). le compilateur nécessite Java Le programme doit capturer ou déclarer toutes les exceptions non-exécutables
Exceptions générées par l'utilisateur
Classe d'exception
Constructeur :
public Exception();
public Exception(String s); accepter les caractères Les informations transmises en tant que paramètre de chaîne sont généralement une description de l'erreur correspondant à l'exception.
La classe Exception hérite également de plusieurs méthodes de son père Throwable, parmi lesquelles les plus couramment utilisées sont :
1) public String toString();
La méthode toString() renvoie une chaîne décrivant la classe Exception actuelle information.
2) public void printStackTrace();
La méthode printStackTrace() n'a pas de valeur de retour. Sa fonction est de terminer une opération d'impression et d'imprimer l'utilisation de la pile de l'objet d'exception actuel sur la sortie standard actuelle (généralement). l'écran). La trajectoire, c'est-à-dire quelles méthodes d'objets ou de classes sont appelées et exécutées successivement par le programme, provoquant la génération de cet objet d'exception pendant le processus en cours.
Exceptions d'exécution définies par le système
Certaines de ces sous-classes sont prédéfinies par le système et incluses dans la bibliothèque de classes Java, appelées exceptions d'exécution définies par le système
Exceptions définies par l'utilisateur
Pour une certaine application -les erreurs d'exécution spécifiques obligent les programmeurs à créer des classes d'exception et des objets d'exception définis par l'utilisateur dans le programme utilisateur selon la logique spéciale du programme
Les exceptions définies par l'utilisateur utilisent généralement Exception comme classe parent de la classe d'exception
Mais il y a une question qui n'est pas encore comprise : lorsqu'une erreur survient, comment le système sait-il qu'elle est reconnue ? Comment générer l’objet de classe d’exception correspondant ? Comment un objet d’exception sait-il utiliser la méthode correspondante pour le résoudre ? Existe-t-il une seule méthode de gestion des exceptions pour chaque objet de classe d’exception qui gère l’exception correspondante ? ————————————Il s'avère que les exceptions définies par l'utilisateur sont levées via l'instruction throw.
Lors de la création d'une exception définie par l'utilisateur, vous devez généralement effectuer le travail suivant :
1) Déclarez une nouvelle classe d'exception et faites-lui utiliser la classe Exception ou une autre classe d'exception système existante ou une exception utilisateur comme classe parent .
2) Définissez les attributs et les méthodes de 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.
Lancement d'exception
Si un programme Java déclenche une erreur identifiable lors de son exécution, un objet de la classe d'exception correspondant à l'erreur sera généré. Ce processus est appelé lancement d'exception,
En fait, il s'agit d'un lancement d'exception. une instance de l’objet de classe d’exception correspondant.
Selon le type d'exception, il existe deux manières de lancer des exceptions : automatiquement lancées par le système et lancées par l'utilisateur :
1. Automatiquement levées par le système
Les exceptions d'erreur en cours d'exécution définies par le système sont toutes levées par le système Lancer automatiquement
2.
lancées par l'utilisateur Les exceptions définies par l'utilisateur ne peuvent pas être automatiquement levées par le système, mais doivent être lancées par l'utilisateur à l'aide d'instructions Java, l'instruction throw est utilisée. lancer explicitement Throw une "exception"
au format d'instruction throw
Le nom de la méthode de type de retour (liste de paramètres) est lancé Liste des noms de classes d'exception à lancer {
                                                                                                 ​🎜> Remarque :
1) Généralement, une exception est levée lorsqu'une certaine condition est remplie dans le programme
 ; Souvent, l'instruction throw est placée dans la branche if de l'instruction if,
if(I>100)
throw (new MyException() ; La méthode supérieure est prête à accepter et à gérer les exceptions qu'elle peut lancer pendant l'opération.
S'il y a plus d'une instruction throw dans la méthode, toutes les exceptions possibles doivent être répertoriées dans l'en-tête de la méthode throws
3) Langage Java Il est requis que toutes les classes déclarées avec le mot-clé throws et les objets lancés avec throw doivent être des classes Throwable ou leurs sous-classes. Si vous essayez de lancer un objet qui ne peut pas être lancé, le compilateur Java signalera une erreur
Gestion des exceptions :
Considérez principalement comment intercepter les exceptions, comment sauter le programme après avoir intercepté l'exception et comment écrire une exception traitement des déclarations
1． try...catch...finally block
1) try
Le { } de l'instruction try contient un morceau de code de programme qui peut lever une ou plusieurs exceptions
Ces codes spécifient en fait le catch derrière lui La plage d’exceptions que le bloc peut intercepter.
Si une exception se produit lorsque le programme Java exécute l'instruction dans le bloc try, il ne continuera plus à exécuter d'autres instructions dans le bloc try, mais entrera directement dans le bloc catch pour trouver le premier type d'exception correspondant et l'exécutera . traiter.
2) Bloc Catch
Les paramètres de l'instruction catch sont similaires à la définition d'une méthode, comprenant un type d'exception et un objet d'exception.
Le type d'exception doit être une sous-classe de la classe Throwable, qui spécifie le type d'exception géré par l'instruction catch ;
L'objet d'exception est lancé par le système d'exécution Java entre les accolades dans le bloc de code du programme spécifié par try Contient le code de méthode pour gérer les objets d’exception.
Il peut y avoir plusieurs instructions catch pour gérer respectivement différents types d'exceptions.
Le système d'exécution Java détecte le type d'exception géré par chaque instruction catch de haut en bas jusqu'à ce qu'une instruction catch correspondante soit trouvée.
Ici, la correspondance de type signifie que le type d'exception dans le catch est complètement cohérent avec le type de l'objet d'exception généré ou est la classe parent de l'objet d'exception. Par conséquent, l'ordre de tri de l'instruction catch doit être de spécial à. général. (Considérez pourquoi ?)
3) Bloc final
L'instruction final peut être considérée comme un mécanisme de nettoyage fourni pour les événements de gestion des exceptions. Elle est généralement utilisée pour fermer des fichiers ou libérer d'autres ressources système
Dans le try. Instruction -catch-finally Il ne peut y avoir aucune partie final de l'instruction.
S'il n'y a pas de partie final, lorsque le code de programme spécifié par try lève une exception, les autres codes de programme ne seront pas exécutés
S'il y a une partie final, qu'une exception se produise ou non dans le bloc try ; if Après avoir exécuté l'instruction dans la partie catch, l'instruction dans la partie enfin doit être exécutée.
On peut voir que la dernière partie de l'instruction fournit une sortie unifiée pour la gestion des exceptions.
Gestion de plusieurs exceptions
Un bloc try peut générer plusieurs exceptions différentes. Si vous souhaitez utiliser différentes méthodes pour gérer ces exceptions, vous devez utiliser un mécanisme de gestion de plusieurs exceptions.
La gestion des exceptions multiples est obtenue en définissant plusieurs blocs catch après un bloc try. Chaque bloc catch est utilisé pour recevoir et traiter un objet d'exception spécifique
Jugez un objet d'exception via les paramètres du bloc catch. être reçu et traité par ce bloc catch.
est obtenu par quel bloc catch, basé sur la correspondance de l'objet d'exception et des paramètres d'exception du bloc catch : lorsqu'ils remplissent l'une des trois conditions suivantes, l'objet d'exception et les paramètres sont considérés comme correspondant :
1) Objet d'exception et paramètres Appartiennent à la même classe d'exception.
2) L'objet exception appartient à une sous-classe de la classe d'exception paramètre.
3) L'objet exception implémente l'interface définie par les paramètres.
Si l'objet d'exception généré par le bloc try est reçu par le premier bloc catch, le flux du programme passera directement à ce bloc d'instruction catch. Une fois le bloc d'instruction exécuté, la méthode actuelle se terminera et les autres blocs catch. sera ignoré
Si l'objet d'exception généré par le bloc try ne correspond pas au premier bloc catch, le système ira automatiquement au deuxième bloc catch pour la correspondance. Si le second ne correspond toujours pas, il ira au deuxième bloc catch. troisième, quatrième... jusqu'à ce que vous trouviez un bloc catch qui peut recevoir l'objet d'exception et terminer le saut de processus.
Si l'objet d'exception généré par le bloc try est reçu par le premier bloc catch, le flux du programme passera directement à ce bloc d'instruction catch. Une fois le bloc d'instruction exécuté, la méthode actuelle se terminera. sera ignoré
Si l'objet d'exception généré par le bloc try ne correspond pas au premier bloc catch, le système ira automatiquement au deuxième bloc catch pour la correspondance. Si le second ne correspond toujours pas, il ira au deuxième bloc catch. troisième, quatrième... jusqu'à ce que vous trouviez un bloc catch qui peut recevoir l'objet d'exception et terminer le saut de processus.
Si l'exécution de toutes les instructions du bloc try ne provoque pas d'exception, tous les blocs catch seront ignorés et ne seront pas exécutés.
Remarque :
1) Les instructions du bloc catch doivent effectuer différentes opérations en fonction de différentes exceptions.
Par conséquent, lors de la gestion de plusieurs exceptions, il convient de prêter attention à la conception minutieuse de l'ordre de chaque bloc catch. Généralement, les blocs catch qui gèrent des exceptions plus spécifiques et courantes doivent être placés à l'avant, tandis que les blocs catch qui peuvent correspondre à plusieurs exceptions doivent être placés à l'arrière.

/*尝试用户运行错误的异常处理： 
 问题是这样的，当输入的用户工资初值少于800则是错误的，当然工资的变化如果超过20%，则也是错误的 
*/
import java.awt.*; 
import java.applet.*; 
import java.awt.event.*; 
public class UserExceptionApplet extends Applet implements ActionListener{ 
 Label prompt1=new Label("请输入雇员姓名和工资初值:"); 
 Label prompt2=new Label("请输入欲修改的工资"); 
 TextField name,isal,nsal; 
 String msg; 
 Employee Emp; 
 Button okBtn=new Button("OK"); 
 Button cancelBtn=new Button("Cancel"); 
 public void init(){ 
  name=new TextField(5); 
  isal=new TextField(5); 
  nsal=new TextField(5); 
  add(prompt1); 
  add(name); 
  add(isal); 
  add(prompt2); 
  add(nsal); 
  add(okBtn); 
  okBtn.addActionListener(this); 
  cancelBtn.addActionListener(this); 
  add(cancelBtn); 
 } 
 public void paint(Graphics g){ 
  g.drawString(msg,0,80); 
 } 
 public void CreateEmp(String empName,double sa){ 
  try{ 
   Emp=new Employee(empName,sa); 
   msg=new String(Emp.toString()); 
  } 
  catch(IllegalSalaryException ise){ 
   msg=new String(ise.toString()); 
  } 
 } 
 public void ChangeEmpSal(double changeSal){ 
  try{ 
   Emp.setEmpSalary(changeSal); 
   msg=new String(Emp.toString()); 
  } 
  catch(IllegalSalaryException illSal){ 
   msg=new String(illSal.toString()); 
  } 
  catch(IllegalSalaryChangeException illSalChange){ 
   msg=new String(Emp.toString()+illSalChange.toString()); 
  } 
 } 
 public void actionPerformed(ActionEvent e){ 
  String empName; 
  double empSal,changeSal; 
  Object obj=e.getSource(); 
  if(obj==okBtn){ 
   empName=new String(name.getText()); 
   if(empName==null){ 
    msg=new String("请先输入雇员姓名工资并创建之");  
   } 
   if(nsal.getText()==null){ 
    empSal=Double.valueOf(isal.getText()).doubleValue(); 
    CreateEmp(empName,empSal); 
   } 
   else{ 
    changeSal=Double.valueOf(nsal.getText()).doubleValue(); 
    ChangeEmpSal(changeSal); 
   } 
  } 
  if(obj==cancelBtn){ 
   naem.setText(""); 
   isal.setText(""); 
   nsal.setText(""); 
  } 
  repaint(); 
 }  
} 
  
class Employee{ 
 String m_EmpName; 
 double m_EmpSalary; 
   
 Employee(String name,double initsalary)throws IllegalSalaryException{ 
  m_EmpName=name;//看这里有问题没，参考代码为m_EmpName=new String(name); 
  if(initsalary<800){ 
   throw(new IllegalSalaryException(this,initsalary));//throw语句 
  } 
  m_EmpSalary=initsalary; 
 } 
 public String getEmpName(){ 
  return m_EmpName; 
 } 
 public double getEmpSalary(){ 
  return m_EmpSalary; 
 } 
   
 public boolean setEmpSalary(double newSal) throws IllegalSalaryException,IllegalSalaryChangeException{ 
  if(newSal<800) 
   throw(new IllegalSalaryException(this,newSal)); 
  else if(getEmpSalary()==0.0){ 
   m_EmpSalary=newSal; 
   return true; 
  } 
  else if(Math.abs(newSal-getEmpSalary())/getEmpSalary()>=0.2) 
   throw(new IllegalSalaryChangeException(this,newSal-getEmpSalary()));  
  else{ 
   m_EmpSalary=newSal; 
   return true; 
  } 
 } 
 public String toString(){ 
  String s; 
  s="姓名:"+m_EmpName+"工资: "+m_EmpSalary; 
  return s; 
 } 
} 
  
class IllegalSalaryException extends Exception{ 
 private Employee m_ConcernedEmp; 
 private double m_IllegalSalary; 
  
 IllegalSalaryException(Employee emp,double isal){ 
  super("工资低于最低工资"); 
  m_ConcernedEmp=emp; 
  m_IllegalSalary=isal; 
 } 
 public String toString(){ 
  String s; 
  s="为雇员提供的工资不合法：雇员:"+m_ConcernedEmp.getEmpName()+"非法工资:"+m_IllegalSalary+"低于最低工资数额800元"; 
  return s; 
 } 
} 
  
class IllegalSalaryChangeException extends Exception{ 
 private Employee m_ConcernedEmp; 
 private double m_IllegalSalaryChange; 
  
 IllegalSalaryChangeException(Employee emp,double csal){ 
  super("工资变动太大"); 
  m_ConcernedEmp=emp; 
  m_IllegalSalaryChange=csal; 
 } 
 public String toString(){ 
  String s; 
  s="为雇员提供的工资变动不合法:雇员:"+m_ConcernedEmp.getEmpName()+"非法变动工资变化:"+m_IllegalSalaryChange+"高于原工资的20%"; 
  return s; 
 } 
}

Pour plus d'articles analysant les mécanismes de traitement des événements et de gestion des exceptions en Java, veuillez faire attention au site Web PHP chinois !