1. Manejo de eventos
De hecho, el nombre del procesamiento del evento se piensa naturalmente en el mecanismo de respuesta del mensaje en MFC. Hasta donde entiendo, deben considerarse como la situación de las naranjas del sur y los cítricos del norte. Sospecho que la "nueva botella" del procesamiento de eventos en Java debería ser la respuesta del mensaje en MFC.
Los llamados "eventos" son cambios como teclas de teclado, clics del mouse, etc. que hacen que un cierto estado cambie debido a acciones o a lo que debe responderse en consecuencia. Podemos dividir los eventos en Java en varias categorías: botones, mouse, teclado, ventana y otros eventos.
Modelo de procesamiento de eventos
1. Modelo de procesamiento de eventos heredados (JDK1.0)
En JDK1.0, el procesamiento de eventos se basa en la herencia. Los eventos se envían primero al componente y luego se propagan hacia arriba a lo largo del nivel del contenedor. Los eventos que no son procesados por el componente continuarán automáticamente propagándose al contenedor del componente. -Esto parece ser consistente con el orden de respuesta del evento original o el mecanismo de respuesta polimórfica en MFC, y el mecanismo de procesamiento de eventos basado en el poder mencionado más tarde parece ser consistente con el mecanismo de devolución de llamada MFC.
Métodos de tratamiento específicos
Llame al método Action () Método o HandleEvent () para obtener los eventos que ocurren cuando el programa se está ejecutando, y todos los eventos que ocurren en el componente se manejan en este método.
2. Modelo de procesamiento de eventos basado en agentes (JDK1.1)
En este modelo, los eventos se envían directamente al componente que produce este evento.
Para cada componente, se registran una o más clases llamadas oyentes, que contienen controladores de eventos que reciben y procesan este evento.
El oyente es una clase que implementa la interfaz del oyente. Los eventos son objetos informados solo a oyentes registrados. Cada evento tiene una interfaz del oyente correspondiente.
Al hacer clic en el objeto del botón con el mouse, se enviará un evento ActionEvent. Este evento ActionEvent será recibido por el método ActionPerformed () de todos los ActionListener registrado utilizando el método addactionListener ().
Las características del modelo de procesamiento de eventos basado en agentes ① Los eventos no se procesarán inesperadamente. En un modelo jerárquico, un evento puede propagarse al contenedor y procesarse a un nivel inesperado.
② Es posible crear y usar la clase de adaptador para clasificar las acciones de eventos.
③ Es propicio para distribuir el trabajo a varias categorías.
Concéntrese en aprender este modelo de procesamiento de eventos
3. Eventos
Tres elementos del procesamiento de eventos.
(1) Fuente del evento La fuente del evento es el generador de un evento, como botones, ventanas y campos de texto.
(2) Tipo de evento Todos los eventos en Java están encapsulados en una clase, y estas clases de eventos se concentran en el paquete Java.awt.event. Todas las clases de eventos heredan la clase Awtevent y un método GetSouce (), que devuelve el objeto donde ocurrió el evento.
(3) Después de que ocurran diferentes tipos de eventos en el oyente del evento, el oyente del evento recibe el evento y llama al método de procesamiento de eventos correspondiente. Todos los oyentes de eventos son en realidad una interfaz en el paquete java.awt.event, introduciendo la interfaz java.util.eventListener. Los oyentes de diferentes tipos de eventos tienen diferentes métodos.
Pasos de procesamiento de eventos ① El programa agrega el paquete java.awt.event:
Import java.awt.event;
② Registre un oyente de eventos para el objeto de origen del evento requerido:
Event Source Object.AddxxxListener (xxxListener);
③ Implementar el método correspondiente. Si una interfaz de oyente contiene múltiples métodos, debe implementar todos los ejemplos de métodos: B2.AddactionListener (esto)
4. Adaptadores de eventos (adaptador)
La carga de trabajo de la implementación de todos los métodos de cada interfaz del oyente es muy alta. Por conveniencia, el idioma Java proporciona la clase de adaptadores para implementar clases que contienen múltiples métodos.
El oyente que define puede heredar la clase de adaptador y simplemente anular los métodos que necesita.
Por ejemplo, el oyente correspondiente al evento de la ventana es WindowListener, que debe implementar múltiples métodos, incluidos Windowopened (), WindowsClosed (), WindowsClosing (), WindowsiConfied (), WindowsDeiConfied (), WindowActivated () y WindowDeactivated (), que aumenta la carga de trabajo de programación innecesaria.
Si hereda WindowAdapter, solo necesita implementar uno o varios de los métodos, y no necesita implementar todos los métodos. Muchos de los siguientes ejemplos solo implementan un método de WindowClosing (), con el propósito de salir del sistema al cerrar la ventana.
4.1 Manejo de eventos de botones
El evento que ocurre al hacer clic en el botón es un evento de acción. La clase de evento correspondiente al evento de acción es la clase ActionEvent. El oyente del evento correspondiente al evento de acción es: ActionListener
Los principales métodos de oyentes:
ActionPerformed (ActionEvent E) El proyecto de operación que se llama cuando ocurre un evento de acción:
El primer paso es registrar la Acción Event Listener AddactionListener (ActionListener).
El segundo paso es implementar el método de interfaz de ActionListener: ActionPerformed (ActionEvent E)
4.2 Manejo de eventos del ratón
La fuente del evento que desencadena un evento de ratón suele ser un contenedor. Cuando el mouse entra o deja el contenedor, o hace clic en el mouse, arrastra el mouse, etc. En el contenedor, el evento del mouse se producirá. La clase de evento correspondiente al evento del mouse es la clase MouseEvent.
Métodos en la clase MouseEvent:
getx () obtiene la coordenada x del mouse
gety () obtiene la coordenada y del mouse
GetPoint () obtiene la posición del mouse y el evento del mouse corresponde a dos oyentes de eventos: MouseListener (o mouseadapter) corresponde al evento del mouse, y MousemotionListener (o MousemotionAdapter) corresponde al evento de movimiento del ratón.
El método principal de MouseListener (o Mouseadapter)
Mousepressed (mouseevent e) cómo lidiar con el prensado del mouse
Mousereleaded (mouseevent e) Cómo manejar la liberación del mouse
MouseEned (mouseevent e) cómo manejar el mouse al ingresar
MouseExited (mouseevent e) cómo lidiar con el mouse cuando se va
Mouseclicked (mouseevent e) Cómo lidiar con el clic del mouse
El método principal de MousemotionListener (o MousemotionAdapter)
MouseMoved (mouseevent e) cómo manejar el mouse cuando se mueve
Mousedroged (mouseevent e) cómo manejar el arrastre del mouse
4.3 Manejo de eventos de teclado
Al presionar o liberar el teclado en un componente con el enfoque del teclado, se producen eventos de teclado. La clase de evento correspondiente al evento del teclado es la clase KeyVent
Métodos principales de clase KeyVent:
getKeyCode () Obtiene el código de tecla para presionarse o liberarse
getKeyText () obtiene la cadena de la tecla presionada o lanzada. El oyente de eventos correspondiente al evento del teclado es: KeyListener o KeyAdapter
Métodos principales:
KeyPressed (Keyvent e) Cómo manejar al presionar el teclado
Key Releaded (tecla Event e) Cómo manejar el teclado al soltarlo
4.4 Manejo de eventos de ventana
Solo si hay ventana y sus clases extendidas (cuadro, diálogo), etc., se pueden activar los eventos de la ventana, lo que indica que la ventana está en un estado activo/inválido, icono/estado no icon, o estado abierto/cierre, etc. La clase correspondiente es WindowEvent, y el oyente es Windowlistener (o WindowAdapter)
Métodos principales:
Windowopened (WindowVent e) Manejo de eventos de la ventana de apertura
WindowClosed (WindowVent e) Manejo de eventos de la ventana de cierre
WindowClosing (WindowEvent e) Procesamiento de eventos de cierre de la ventana
Manejo de eventos del estado de activación de WindowActivated (WindowEvent E)
Manejo de eventos del estado no válido de WindowDeactivated (WindowEvent E)
4.5 Manejo de otros eventos
4.5.1 La clase de eventos para la casilla de verificación y el procesamiento del evento del botón de opción es ItemEvent:
El oyente del evento correspondiente al evento de opción es: itemListener
método:
itemStateChanged (ItemEvent E) se llama cuando ocurre el evento de opción 4.5.2 La clase de evento correspondiente a la clase de ajuste de procesamiento de eventos de ScrollBar es la clase AjusteVent:
El oyente de eventos correspondiente al evento de ajuste es: AjusteListener
método:
AjusteValueChanged (ajuste Event e) se llama cuando ocurre el evento de ajuste
4.5.3 La clase de eventos de procesamiento de eventos en la lista desplegable es ItemEvent:
El oyente del evento correspondiente al evento de opción es: itemListener
método:
itemStateChanged (ItemEvent e) se llama cuando se produce una acción en la lista desplegable
(Se puede ver que el procesamiento de eventos de la lista desplegable es el mismo que el tipo de evento, el oyente de eventos y el método, como el procesamiento de eventos de la casilla de verificación, el tipo de evento, el oyente de eventos y el método del procesamiento de eventos de la caja de radio)
4.5.4 Manejo de eventos de menú Los eventos de menú son generalmente un evento que ocurre cuando hacemos clic en un elemento de menú.
Hay dos tipos de elementos de menú:
Evento de acción de Menuitem
CheckboxMenuitem, evento de opción
El primer paso en el procesamiento de eventos de Menuitem es registrar la Acción del Evento del Evento AddactionListener (ActionListener) para todos los elementos del menú Menuitem.
El segundo paso es implementar el método de interfaz ActionListener: ActionPerformed (ActionEvent E). En este método, use E.GetSource () para obtener el elemento de menú seleccionado por el usuario y realizar el procesamiento correspondiente.
El primer paso en el manejo de eventos de CheckBoxMenuitem es registrar el oyente de eventos de opción para todos los elementos del menú Checkmenuitem en AddItemListener (itemListener).
El segundo paso es implementar el método de la interfaz itemListener: itemStateChanged (itemEvent E). En este método, use E.GetSource () para obtener el elemento de menú seleccionado por el usuario, E.GetItem () para obtener la etiqueta del elemento de menú seleccionado por el usuario y E.getStateChange () para obtener si se selecciona y realizar el procesamiento correspondiente.
2. Manejo de excepciones
Ningún buen lenguaje o programador de programación ignorará el manejo de excepciones. Como un lenguaje de programación popular orientado a objetos, Java, el mecanismo de manejo de excepciones es naturalmente una de sus características importantes.
En términos generales, las excepciones se describen como: errores en la programación. Sin embargo, de hecho, este error es muy frecuente, con muchos tipos, tales como: errores de compilación y errores de operación (específicamente, se divide en: errores de operación del sistema y errores de operación lógica. Qué errores de operación del sistema rara vez se consideran errores de programación, antes).
En Java, una excepción es una clase que hereda de la clase lanzable. Cada clase de excepción representa un error de ejecución (nota: es un error de ejecución). La clase de excepción contiene información sobre el error de operación y el método para manejar el error.
Mecanismo de manejo de excepciones de Java:
Cada vez que se produce un error de ejecución identificable durante la operación del programa Java, (es decir, cuando el error tiene una clase de excepción correspondiente a él), el sistema generará un objeto correspondiente de la clase de excepción (nota: se llama generar un objeto de clase de excepción). Es decir, se genera una excepción.
Una vez que se genera un objeto de excepción, debe haber un mecanismo correspondiente en el sistema para manejarlo para garantizar que no haya accidentes, bucles muertos u otro daño al sistema operativo, asegurando así la seguridad de la operación de todo el programa.
Clases de excepción y excepción:
Error: generado y lanzado por la máquina virtual Java, y el programa Java no lo maneja.
Excepción de tiempo de ejecución (errores del sistema como 0, subíndices de matriz exceden el rango): detectado por el sistema, el programa Java del usuario no se puede procesar y el sistema los entregó al controlador de excepción predeterminado (nota: Hay un manejo de excepción predeterminado).
Excepción (problemas en el programa, Predecible): el compilador Java requiere que el programa Java debe atrapar o declarar todas las excepciones que no son de run tiempo que los usuarios generan sus propias excepciones.
Constructor de clase de excepción:
excepción pública ();
excepción pública (cadena S); Puede aceptar la información aprobada por los parámetros de cadena, que generalmente es una descripción del error correspondiente a la excepción.
La clase de excepciones también hereda varios métodos del padre que se puede tirar, entre los cuales los usados comúnmente son:
1) cadena pública toString ();
El método toString () devuelve una cadena que describe la información de clase de excepción actual.
2) public void printStackTrace ();
El método printStackTrace () no tiene valor de retorno. Su función es completar una operación de impresión e imprimir la pista de uso de la pila del objeto de excepción actual en la salida estándar actual (generalmente la pantalla), es decir, el programa llama a los objetos o clases para ejecutar, qué métodos del objeto de excepción se generan durante la operación.
Excepción de operación definida por el sistema
Algunas de estas subclases están definidas por adelantado por el sistema e incluidos en la biblioteca de clase Java, y se denominan excepciones de operación definidas por el sistema
Excepciones definidas por el usuario
Para errores de operación únicos para una determinada aplicación, los programadores deben crear clases de excepción definidas por el usuario y objetos de excepción en el programa de usuario de acuerdo con la lógica especial del programa. Las excepciones definidas por el usuario generalmente se usan como la clase principal de la clase de excepción. Sin embargo, hay un problema que aún no se ha entendido: ¿cómo sabe el sistema que ocurre un error y es reconocible? ¿Cómo generar los objetos de clase de excepción correspondientes? ¿Cómo sabe cómo resolver el objeto de clase de excepción utilizando el método correspondiente? ¿Cada objeto de clase de excepción que maneja la excepción correspondiente tiene solo un método de manejo de excepción? "" "..... ... ... ..... .....-- ...
Al crear excepciones definidas por el usuario, generalmente se requieren las siguientes tareas:
1) Declare una nueva clase de excepción, de modo que tome la clase de excepción u otra clase de excepción del sistema existente o excepción del usuario como la clase principal.
2) Definir atributos y métodos para la nueva clase de excepción, o sobrecargar los atributos y métodos de la clase principal para que estos atributos y métodos puedan reflejar la información de error correspondiente a la clase.
Excepción lanzada
Si un programa Java plantea un error identificable cuando se ejecuta, generará un objeto de la clase de excepción correspondiente al error. Este proceso se llama lanzamiento de excepción.
En realidad, está lanzando una instancia del objeto de clase de excepción correspondiente.
Dependiendo de la clase de excepción, hay dos formas de lanzar excepciones: lanzamiento automático del sistema y lanzamiento del usuario:
1. El sistema lo tirará automáticamente
Las excepciones de error de operación definidas por el sistema son lanzadas automáticamente por el sistema.
2. Lanzamientos de usuario
Las excepciones definidas por el usuario no pueden ser arrojadas automáticamente por el sistema, sino que debe ser arrojada por el usuario en declaraciones Java. En las declaraciones de Java, la declaración de lanzamiento se usa para lanzar explícitamente una "excepción".
Nombre del método de tipo de retorno (Lista de parámetros) en el formato lanza Lista de lanza de nombres de clase de excepción que se lanzarán {
…
Lanzar instancia de clase de excepción; // nota aquí ...
}
Aviso:
1) En general, se lanza una excepción cuando se cumple una determinada condición en el programa;
A menudo ponga la declaración de lanzamiento en la rama if de la declaración if,
if (i> 100)
tirar (nueva myException ());
2) Para los métodos que contienen declaraciones de lanzamiento, se deben agregar las siguientes partes a la definición del encabezado del método:
Lanza la lista de nombres de clase de excepción para ser lanzados. Esto es principalmente para informar el método superior para llamar a este método y prepararse para aceptar y manejar las excepciones que puede lanzar durante el tiempo de ejecución. Si hay más de una declaración de lanzamiento en el método, todas las excepciones posibles deben enumerarse en los lanzamientos de encabezado del método.
3) El lenguaje Java requiere que todas las clases declaradas con la palabra clave y los objetos lanzados con lanzamiento deben ser una clase tirada o su subclase. Si intenta lanzar un objeto que no se puede lanzar, el compilador Java informará una excepción de error:
Considere principalmente cómo atrapar excepciones, cómo saltar después de captar excepciones y cómo escribir declaraciones de manejo de excepciones
1. Intenta ... atrapar ... finalmente bloquear
1) Prueba
El {} en la instrucción Try contiene un código de programa que puede lanzar una o más excepciones. Estos códigos en realidad especifican el rango de excepciones que pueden ser capturados por el bloque de captura después de él.
Si se produce una excepción cuando un programa Java se ejecuta en una declaración en un bloque de try, ya no continúa ejecutando otras declaraciones en el bloque de try, sino que ingresa directamente al bloque de captura para encontrar el primer tipo de excepción de coincidencia y procesarlo.
2) Bloque de captura
Los parámetros de la declaración de captura son similares a la definición de un método, incluido un tipo de excepción y un objeto de excepción.
El tipo de excepción debe ser una subclase de la clase lanzable, que especifica el tipo de excepción manejado por la declaración de captura;
El objeto de excepción es el código de método para manejar el objeto de excepción en los aparatos ortopédicos rizados lanzados por el sistema de tiempo de ejecución Java en el bloque de código de programa especificado por la prueba.
Puede haber múltiples declaraciones de captura que manejen diferentes tipos de excepciones por separado.
El sistema de tiempo de ejecución Java detecta el tipo de excepción procesado por cada declaración de captura de arriba a abajo, hasta que encuentra una declaración de captura que la coincide.
Aquí, el tipo de coincidencia significa que el tipo de excepción en captura es exactamente el mismo que el tipo del objeto de excepción generado o la clase principal del objeto de excepción. Por lo tanto, la orden de clasificación de la declaración de captura debe ser de especial a general. (¿Piensas por qué?)
3) Finalmente bloquear
Se puede decir que la declaración finalmente es un mecanismo de limpieza proporcionado para eventos de manejo de excepciones. Generalmente se usa para cerrar archivos o liberar otros recursos del sistema. La declaración de prueba-Catch-Finalmente puede tener una declaración con una parte finalmente.
Si no hay finalmente parte, cuando el código del programa especificado por TRAT lanza una excepción, no se ejecutarán otros códigos de programa;
Si finalmente hay una parte, no importa si se produce una excepción en el bloque de try o si se ha ejecutado una parte de captura, la declaración finalmente parte debe ser ejecutada.
Se puede ver que la parte finalmente de la declaración proporciona una salida unificada para el manejo de excepciones.
Múltiples excepciones pueden producir múltiples excepciones diferentes, y si desea tomar diferentes métodos para lidiar con estas excepciones, debe utilizar un mecanismo de manejo de múltiples excepciones.
El procesamiento de excepciones múltiples se logra definiendo varios bloques de captura después de un bloque de TRY. Cada bloque de captura se utiliza para recibir y procesar un objeto de excepción específico. A través de los parámetros del bloque de captura, determina si un objeto de excepción debe ser una excepción recibida y procesada por este bloque de captura.
¿Qué bloque de captura se obtiene? Según la coincidencia de los parámetros de excepción del objeto de excepción y el bloque de captura: cuando cumplen con cualquiera de las siguientes tres condiciones, se considera que el objeto de excepción y el parámetro coinciden:
1) El objeto de excepción pertenece a la misma clase de excepción que el parámetro.
2) El objeto de excepción pertenece a una subclase de la clase de excepción del parámetro.
3) El objeto de excepción implementa la interfaz definida por los parámetros.
Si el objeto de excepción generado por el bloque de try es recibido por el primer bloque de captura, el flujo del programa saltará directamente a este bloque de instrucciones de captura. Después de ejecutar el bloque de instrucciones, se saldrá el método actual. Se ignorarán las declaraciones que no se han ejecutado en el bloque de try y otros bloques de captura. Si el objeto de excepción generado por el bloque de try no coincide con el primer bloque de captura, el sistema irá automáticamente al segundo bloque de captura para la coincidencia. Si el segundo todavía no coincide, se convertirá en el tercero, cuarto ... hasta que se encuentre un bloque de captura que pueda recibir el objeto de excepción, y el proceso se completará.
Si el objeto de excepción generado por el bloque de try es recibido por el primer bloque de captura, el flujo del programa saltará directamente a este bloque de instrucciones de captura. Después de ejecutar el bloque de instrucciones, se saldrá el método actual. Se ignorarán las declaraciones que no se han ejecutado en el bloque de try y otros bloques de captura. Si el objeto de excepción generado por el bloque de try no coincide con el primer bloque de captura, el sistema irá automáticamente al segundo bloque de captura para la coincidencia. Si el segundo todavía no coincide, se convertirá en el tercero, cuarto ... hasta que se encuentre un bloque de captura que pueda recibir el objeto de excepción, y el proceso se completará.
Si la ejecución de todas las declaraciones en el bloque de try no plantea una excepción, todos los bloques de captura serán ignorados y no ejecutados.
Aviso:
1) Las declaraciones en el bloque de captura deben realizar diferentes operaciones de acuerdo con las diferentes excepciones, por lo que al tratar con múltiples excepciones, debe prestar atención para diseñar cuidadosamente el orden de disposición de cada bloque de captura. En general, los bloques de captura que se ocupan de excepciones más específicas y comunes deben colocarse en el frente, mientras que los bloques de captura que pueden igualar múltiples excepciones deben colocarse en la parte posterior.
/*Pruebe al usuario para ejecutar el manejo de la excepción de error: el problema es este. Cuando el valor inicial del salario del usuario ingresado es inferior a 800, está mal. Por supuesto, si el cambio en el salario excede el 20%, también está mal*/ import java.awt.*; import java.applet.*; import java.awt.event.*; Public Class UserExceptionApplet extiende Applet implementa ActionListener {etiqueta indic1 = nueva etiqueta ("Ingrese el nombre del empleado y el valor inicial del salario:"); Etiqueta indic2 = nueva etiqueta ("Ingrese el salario que se modificará"); Textfield Nombre, Isal, NSAL; Cadena msg; Empleado emp; Botón OKBTN = nuevo botón ("Aceptar"); Botón cancelBtn = nuevo botón ("Cancelar"); public void init () {name = new TextField (5); isal = nuevo TextField (5); nsal = new TextField (5); agregar (indic1); agregar (nombre); agregar (isal); agregar (indic2); agregar (nsal); agregar (okbtn); okbtn.addactionListener (esto); cancelBtn.AddactionListener (esto); agregar (cancelarBTN); } 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 (ilegalSalaryException es) {msg = new String (ISe.ToString ()); }} public void ChangeMempsal (doble cambio) {try {emp.SetEmsalario (cambia); msg = new String (emp.toString ()); } catch (ilegalStaryException illsal) {msg = new String (illsal.ToString ()); } catch (ilegalSalaryChangeException illsalChange) {msg = new String (emp.ToString ()+illsalchange.ToString ()); }} public void ActionPerformed (ActionEvent E) {String EmpName; Doble Empsal, cambios en los cambios; Object obj = e.getSource (); if (obj == okbtn) {empname = new String (name.gettext ()); if (empname == null) {msg = new String ("Por favor ingrese el nombre y el salario del empleado primero y cree"); } if (nsal.gettext () == null) {empsal = double.ValueOf (isal.gettext ()). DoubleValue (); CreateEmp (empname, empsal); } else {chogle = double.ValueOf (nsal.gettext ()). doubleValue (); Cambio ímal (cambiando); }} if (obj == cancelbtn) {naem.setText (""); isal.settext (""); nsal.settext (""); } repint (); }} empleado de clase {string m_empname; doble m_empsalario; Empleado (nombre de cadena, doble inicial) lanza ilegalSarioyException {m_empname = name; // ver si hay algún problema aquí, el código de referencia es m_empname = new String (nombre); if (initsalary <800) {throw (new IlegalSalaryException (this, inSitSalary)); // Declaración de lanzamiento} m_empsalary = initsalary; } public String getempname () {return m_empname; } public Double GetEmsaltary () {return m_empsalary; } Public boolean setempsalary (doble newsal) lanza ilegalitaryexception, ilegalialarychangeException {if (newsal <800) throw (nueva ilegalariaException (this, newsal)); else if (getMpsalario () == 0.0) {m_empsalario = newsal; devolver verdadero; } else if (math.abs (newsal-getempsalary ())/getempsalario ()> = 0.2) throw (nuevo ilegalSalaryChangeException (this, newsal-getempsalario ())); else {m_empsalario = newsal; devolver verdadero; }} public String toString () {String S; s = "nombre:"+m_empname+"salario:"+m_empsalario; regreso s; }} Clase IlegalStaryException extiende la excepción {Empleado privado m_concernedemp; Privado Doble M_ILLEGALSALARY; ILEGALALARYEXCEPTION (Employee EMP, Double Isal) {super ("El salario es más bajo que el salario mínimo"); m_concerneMp = emp; M_ILLEGALSALARY = isal; } public String toString () {String S; S = "Los salarios proporcionados a los empleados son ilegales: empleados:"+m_concernedemp.getempname ()+"salario ilegal:"+m_illegalsalary+"inferior al salario mínimo de RMB 800"; regreso s; }} Clase IlegalSalaryChangeException extiende la excepción {empleado privado m_concernedemp; Doble privado M_ILLEGALSALARYCHIVE; ILEGALALARYCHIVECHECTION (Empleado EMP, doble CSAL) {super ("el cambio salarial es demasiado grande"); m_concerneMp = emp; M_ILLEGALSALARYCHIVE = CSAL; } public String toString () {String S; S = "El cambio salarial proporcionado a los empleados es ilegal: empleado:"+m_concernedemp.getempname ()+"cambio ilegal del cambio salarial:"+m_illegalSalaryChange+"20% más alto que el salario original"; regreso s; }}