1. Manuseio de eventos
De fato, o nome do processamento de eventos é naturalmente pensado no mecanismo de resposta a mensagens no MFC. Até onde eu entendo, eles devem ser considerados como a situação das laranjas do sul e do norte. Suspeito que a "nova garrafa" do processamento de eventos em Java seja a resposta da mensagem no MFC.
Os chamados "eventos" são alterações como teclas de teclado, cliques de mouse etc. que fazem com que um determinado estado mude devido a ações ou o que precisa ser respondido de acordo. Podemos dividir eventos em Java em várias categorias: botões, mouse, teclado, janela e outros eventos.
Modelo de processamento de eventos
1. Modelo de processamento de eventos herdados (JDK1.0)
No JDK1.0, o processamento de eventos é baseado na herança. Os eventos são enviados para o componente primeiro e depois propagados para cima ao longo do nível do contêiner. Os eventos que não são processados pelo componente continuarão automaticamente a se propagar para o contêiner do componente. -Isso parece ser consistente com a ordem de resposta original ou o mecanismo de resposta polimórfica no MFC, e o mecanismo de processamento de eventos baseado em proxy mencionado mais tarde parece ser consistente com o mecanismo de retorno de chamada MFC.
Métodos de tratamento específicos
Chame o método Action () ou HandleEvent () para obter os eventos que ocorrem quando o programa está em execução e todos os eventos que ocorrem no componente são tratados nesse método.
2. Modelo de processamento de eventos baseado em agente (JDK1.1)
Neste modelo, os eventos são enviados diretamente para o componente que produz este evento.
Para cada componente, uma ou mais classes chamadas ouvintes são registradas, que contêm manipuladores de eventos que recebem e processam este evento.
O ouvinte é uma classe que implementa a interface do ouvinte. Eventos são objetos relatados apenas para ouvintes registrados. Cada evento possui uma interface do ouvinte correspondente.
Ao clicar no objeto de botão com o mouse, um evento ActionEvent será enviado. Este evento ActionEvent será recebido pelo método ActionPerformed () de todos os ActionListener registrado usando o método AddactionListener ().
Recursos do modelo de processamento de eventos baseados em agentes ① Os eventos não serão processados inesperadamente. Em um modelo hierárquico, um evento pode se propagar para o contêiner e ser processado em um nível inesperado.
② É possível criar e usar a classe adaptadora para classificar as ações do evento.
③ é propício à distribuição de trabalhos para várias categorias.
Concentre -se em aprender este modelo de processamento de eventos
3. Eventos
Três elementos do processamento de eventos.
(1) Fonte do evento A fonte de evento é o gerador de um evento, como botões, Windows e campos de texto.
(2) Tipo de evento Todos os eventos em Java são encapsulados em uma classe, e essas classes de eventos estão concentradas no pacote java.awt.event. Todas as classes de eventos herdam a classe Awtevent e um método - getSouce (), que retorna o objeto onde o evento ocorreu.
(3) Depois que diferentes tipos de eventos ocorrem no ouvinte, o ouvinte do evento recebe o evento e chama o método de processamento de eventos correspondente. Todos os ouvintes de eventos são na verdade uma interface no pacote java.awt.event, introduzindo a interface java.util.eventListener. Os ouvintes de diferentes tipos de eventos têm métodos diferentes.
Etapas de processamento de eventos ① O programa adiciona o pacote java.awt.event:
Importar java.awt.event;
② Registre um ouvinte de evento para o objeto de origem do evento necessário:
OBRIGE DE EVENTO OBJETO.ADDXXXListener (xxxListener);
③ Implementar o método correspondente. Se uma interface do ouvinte contiver vários métodos, você precisará implementar todos os exemplos de métodos: b2.addactionListener (this)
4. Adaptadores de eventos (adaptador)
A carga de trabalho da implementação de todos os métodos de cada interface do ouvinte é muito alta. Por conveniência, o idioma Java fornece a classe Adaptadores para implementar classes contendo vários métodos.
O ouvinte que você definir pode herdar a classe adaptadora e apenas substituir os métodos necessários.
Por exemplo, o ouvinte correspondente ao evento da janela é o WindowListener, que deve implementar vários métodos, incluindo windowopened (), windowcleosed (), windowclosing (), windowiconfied (), windowDeiconFied (), WindowActivated () e WindowDectivated (), que aumentam a carga programada desnecessária.
Se você herdar WindowAdapter, precisará implementar apenas um ou vários métodos e não precisa implementar todos os métodos. Muitos dos exemplos a seguir implementam apenas um método de WindowClosing (), com o objetivo de sair do sistema ao fechar a janela.
4.1 Manuseio de eventos de botão
O evento que ocorre ao clicar no botão é um evento de ação. A classe de evento correspondente ao evento de ação é a classe ActionEvent. O ouvinte do evento correspondente ao evento de ação é: ActionListener
Os principais métodos dos ouvintes:
ActionPerformed (ActionEvent E) O projeto de operação chamado quando ocorre um evento de ação:
A primeira etapa é registrar o ouvinte de evento de ação AddactionListener (ActionListener).
A segunda etapa é implementar o método da interface ActionListener: ActionPormed (ActionEvent E)
4.2 Manuseio de eventos de mouse
A fonte de evento que desencadeia um evento de mouse geralmente é um recipiente. Quando o mouse entra ou sai do recipiente ou clica no mouse, arrasta o mouse, etc. No recipiente, o evento do mouse ocorrerá. A classe de evento correspondente ao evento do mouse é a classe Mouseevent.
Métodos na aula de mouseevent:
getx () obtém a coordenada x do mouse
gety () obtém a coordenada y do mouse
getPoint () obtém a posição do mouse e o evento do mouse corresponde a dois ouvintes de eventos: MouseListener (ou MouseAdapter) corresponde ao evento do mouse, e o MouseMotionListener (ou MouseMotionAdapter) corresponde ao evento de movimento do mouse.
O principal método de MouseListener (ou MouseAdapter)
Mouse pressionado (Mouseevent e) Como lidar com a pressão do mouse
MouseReledEd (Mouseevent e) Como lidar com a liberação do mouse
MouseEntered (Mouseevent e) Como lidar com o mouse ao entrar
Mouseexited (mouseevent e) como lidar com o mouse ao sair
Mouseclicked (mouseevent e) Como lidar com o clique do mouse
O principal método de MousemotionListener (ou MouseMotionAdapter)
MouseMoved (mouseevent e) como lidar com o mouse ao se mover
Mousedraged (mouseevent e) como lidar com o arrasto do mouse
4.3 Manuseio de eventos de teclado
Ao pressionar ou liberar o teclado em um componente com foco no teclado, ocorrem eventos de teclado. A classe de evento correspondente ao evento do teclado é a classe KeyEvent
Métodos principais da classe KeyEvent:
getKeyCode () faz com que o código da chave seja pressionado ou liberado
getKeyText () recebe a string da tecla pressionada ou liberada. O ouvinte do evento correspondente ao evento do teclado é: KeyListener ou KeyAdapter
Métodos principais:
KeyPressed (KeyEvent E) Como lidar ao pressionar o teclado
KeyrelEardeed (keyevent e) como lidar com o teclado ao liberá -lo
4.4 Manuseio de eventos de janela
Somente se houver janela e suas classes estendidas (quadro, diálogo) etc., os eventos das janelas podem ser acionados, indicando que a janela está em um estado ativo/inválido, estado de ícone/não-icon, ou estado aberto/fechado, etc. A classe correspondente é a janela e o ouvinte é o WindowListener (WindowadApter)
Métodos principais:
Windowopened (WindowEvent E) Manipulação de eventos da janela de abertura
Windowclosed (WindowEvent E) Manipulação de eventos da janela de fechamento
WindowClosing (WindowEvent E) Processamento de eventos de fechamento da janela
Manuseio de eventos de status de ativação da WindowActivated (WindowEvent E)
Manipulação de eventos do status inválido de WindowDeActivated (WindowEvent E)
4.5 Manuseio de outros eventos
4.5.1 A classe de evento para caixa de seleção e processamento de eventos de botão de rádio é ItemEvent:
O ouvinte do evento correspondente ao evento de opção é: ItemListener
método:
ItemStateChanged (ItemEvent E) é chamado quando o evento de opção ocorre 4.5.2 A classe de evento correspondente ao evento de ajuste de processamento de eventos de scrollbar é a classe de ajustevent:
O ouvinte do evento correspondente ao evento de ajuste é: AjustmentListener
método:
AjustmentValuechanged (AjustmentEvent E) é chamado quando o evento de ajuste ocorre
4.5.3 A classe de evento de processamento de eventos na lista suspensa é ItemEvent:
O ouvinte do evento correspondente ao evento de opção é: ItemListener
método:
ItemstateChanged (ItemEvent E) é chamado quando ocorre uma ação na lista suspensa
(Pode-se observar que o processamento de eventos da lista suspensa é o mesmo do tipo de evento, ouvinte de eventos e método, como o processamento de eventos da caixa de seleção, o tipo de evento, o ouvinte de eventos e o método do processamento de eventos da caixa de rádio)
4.5.4 Manuseio de eventos de menu Os eventos de menu geralmente é um evento que ocorre quando clicamos em um item de menu.
Existem dois tipos de itens de menu:
Evento de Ação Menuitem
CheckboxMenuitem, evento de opção
A primeira etapa do processamento de eventos de Menuitem é registrar o AddactionListener AddactionListener (ActionListener) para todos os itens do menu Menuitem.
A segunda etapa é implementar o método da interface ActionListener: ActionPerformed (ActionEvent E). Neste método, use o e.getSource () para obter o item de menu selecionado pelo usuário e execute o processamento correspondente.
A primeira etapa do manuseio de eventos do CheckBoxMenuitem é registrar o ouvinte de eventos de opções para todos os itens de menu CheckMenuitem para AddItemListener (ItemListener).
A segunda etapa é implementar o método ItemListener Interface: ItemStateChanged (ItemEvent E). Neste método, use o e.getSource () para obter o item de menu selecionado pelo usuário, e.getItem () para obter o rótulo do item de menu selecionado pelo usuário e e.getStatechange () para obter se ele é selecionado e executar processamento correspondente.
2. Manuseio de exceção
Nenhuma boa linguagem de programação ou programador ignorará o manuseio de exceções. Como uma linguagem de programação popular orientada a objetos, Java, o mecanismo de manuseio de exceção é naturalmente um de seus recursos importantes.
De um modo geral, as exceções são descritas como: erros na programação. No entanto, de fato, esse erro é muito frequente, com muitos tipos, como: erros de compilação e erros de operação (especificamente, ele é dividido em: erros de operação do sistema e erros de operação lógica. Quais erros de operação do sistema raramente são considerados como erros de programação antes.)
Em Java, uma exceção é uma classe que herda da classe jogável. Cada classe de exceção representa um erro de execução (Nota: é um erro de execução). A classe de exceção contém informações sobre o erro de operação e o método de lidar com o erro.
Mecanismo de manuseio de exceção de Java:
Sempre que ocorre um erro de execução identificável durante a operação do programa Java (ou seja, quando o erro tem uma classe de exceção correspondente a ele), o sistema gerará um objeto correspondente da classe de exceção (Nota: é chamado de geração de um objeto de classe de exceção.) Ou seja, uma exceção é gerada.
Depois que um objeto de exceção é gerado, deve haver um mecanismo correspondente no sistema para lidar com ele para garantir que não haja falhas, loops mortos ou outros danos ao sistema operacional, garantindo assim a segurança da operação de todo o programa.
Classes de exceção e exceção:
Erro: gerado e jogado pela Java Virtual Machine, e o programa Java não lida com isso.
Exceção de tempo de execução (erros do sistema como 0, os subscritos de matriz excedem o intervalo): detectado pelo sistema, o programa Java do usuário não pode ser processado e o sistema os entregou ao manipulador de exceção padrão (Nota: há um manuseio de exceção padrão).
Exceção (problemas no programa, previsível): o compilador Java exige que o programa Java deve capturar ou declarar todas as exceções não intermediárias que os usuários geram suas próprias exceções.
Construtor de classe de exceção:
exceção pública ();
Exceção pública (strings); pode aceitar informações aprovadas pelos parâmetros da string, que geralmente é uma descrição do erro correspondente à exceção.
A classe de exceção também herda vários métodos do pai arremessado, entre os quais os comumente usados são:
1) public string tostring ();
O método tostring () retorna uma string que descreve as informações da classe de exceção atual.
2) public void PrintStackTrace ();
O método PrintStackTrace () não tem valor de retorno. Sua função é preencher uma operação de impressão e imprimir a faixa de uso da pilha do objeto de exceção atual na saída padrão atual (geralmente a tela), ou seja, o programa chama quais objetos ou classes a executar, quais métodos do objeto de exceção são gerados durante a operação.
Exceção de operação definida pelo sistema
Algumas dessas subclasses são definidas com antecedência pelo sistema e incluídas na biblioteca da classe Java e são chamadas de exceções de operação definida pelo sistema
Exceções definidas pelo usuário
Para erros de operação exclusivos para um determinado aplicativo, os programadores precisam criar classes de exceção definidas pelo usuário e objetos de exceção no programa de usuário de acordo com a lógica especial do programa. Exceções definidas pelo usuário geralmente são usadas como a classe pai da classe de exceção. No entanto, há um problema que ainda não foi entendido: como o sistema sabe que ocorre um erro e é reconhecível? Como gerar objetos de classe de exceção correspondentes? Como você sabe como resolver o objeto de classe de exceção usando o método correspondente? Cada objeto de classe de exceção que lida com a exceção correspondente tem apenas um método de manuseio de exceção? ――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――�
Ao criar exceções definidas pelo usuário, geralmente são necessárias as seguintes tarefas:
1) Declare uma nova classe de exceção, para que ele faça a classe de exceção ou outra classe de exceção do sistema existente ou exceção do usuário como a classe pai.
2) Defina atributos e métodos para a nova classe de exceção ou sobrecarregar os atributos e métodos da classe pai para que esses atributos e métodos possam refletir as informações de erro correspondentes à classe.
Exceção lançada
Se um programa Java levantar um erro identificável quando for executado, ele gerará um objeto da classe de exceção correspondente ao erro. Esse processo é chamado de exceção de arremesso.
Na verdade, está lançando uma instância do objeto de classe de exceção correspondente.
Dependendo da classe de exceção, há duas maneiras de lançar exceções: arremesso automático do sistema e arremesso de usuário:
1. O sistema jogará fora automaticamente
As exceções de erro de operação definidas pelo sistema são lançadas automaticamente pelo sistema.
2. O usuário joga
Exceções definidas pelo usuário não podem ser jogadas automaticamente pelo sistema, mas devem ser jogadas pelo usuário nas instruções Java. Nas declarações Java, a declaração de arremesso é usada para lançar explicitamente uma "exceção".
Nome do método do tipo de retorno (lista de parâmetros) no formato lança lança Lista de nomes de classe de exceção a serem jogados {
...
lança instância da classe de exceção; // Nota aqui ...
}
Perceber:
1) Geralmente, uma exceção é lançada quando uma certa condição é atendida no programa;
Costuma colocar a declaração de arremesso no ramo if da declaração if,
se (i> 100)
lançar (New MyException ());
2) Para métodos contendo declarações de arremesso, as seguintes peças devem ser adicionadas à definição do cabeçalho do método:
joga a lista de nomes de classe de exceção a serem jogados. Isso é principalmente para informar o método superior para chamar esse método e se preparar para aceitar e lidar com exceções que ele pode lançar durante o tempo de execução. Se houver mais de uma declaração de arremesso no método, todas as exceções possíveis devem ser listadas no cabeçalho do método.
3) O idioma Java exige que todas as classes declaradas com a palavra -chave e os objetos lançados com arremesso devem ser jogáveis ou sua subclasse. Se você tentar jogar um objeto que não é jogável, o compilador Java relatará uma exceção de erro:
Considere principalmente como capturar exceções, como pular depois de capturar exceções e como escrever declarações de manuseio de exceções
1. Tente… pegar… finalmente bloco
1) Tente
O {} na instrução Try contém um código de programa que pode lançar uma ou mais exceções. Na verdade, esses códigos especificam o intervalo de exceções que podem ser capturadas pelo bloco de captura depois dele.
Se ocorrer uma exceção quando um programa Java chegar a uma declaração em um bloco de tentativa, ele não continua mais a executar outras instruções no bloco de tentativa, mas entra diretamente no bloco de captura para encontrar o primeiro tipo de exceção correspondente e processá -lo.
2) Catch bloco
Os parâmetros da declaração de captura são semelhantes à definição de um método, incluindo um tipo de exceção e um objeto de exceção.
O tipo de exceção deve ser uma subclasse da classe jogável, que especifica o tipo de exceção tratado pela instrução CATCH;
O objeto de exceção é o código do método para lidar com o objeto de exceção nos aparelhos encaracolados jogados pelo sistema de tempo de execução Java no bloco de código do programa especificado pela tentativa.
Pode haver várias instruções de captura que lidam com diferentes tipos de exceções separadamente.
O sistema de tempo de execução do Java detecta o tipo de exceção processado por cada instrução de captura de cima para baixo, até encontrar uma declaração de captura que a corresponda.
Aqui, a correspondência de tipos significa que o tipo de exceção em captura é exatamente o mesmo que o tipo do objeto de exceção gerado ou a classe pai do objeto de exceção. Portanto, a ordem de classificação da declaração de captura deve ser de especial para geral. (Pense em por quê?)
3) finalmente bloqueie
Pode -se dizer que a declaração finalmente é um mecanismo de limpeza fornecido para eventos de manuseio de exceções. Geralmente é usado para fechar arquivos ou liberar outros recursos do sistema. A instrução Try-Catch-Finally pode ter uma declaração com uma parte finalmente.
Se não houver parte finalmente, quando o código do programa especificado por tentativa lança uma exceção, outros códigos de programa não serão executados;
Se houver uma parte finalmente, não importa se ocorre uma exceção no bloco de tentativa ou se uma peça de captura foi executada, a declaração de parte finalmente deve ser executada.
Pode -se observar que a parte finalmente parte da instrução fornece uma saída unificada para o manuseio de exceções.
Várias exceções podem produzir várias exceções diferentes e, se você deseja tomar métodos diferentes para lidar com essas exceções, precisará usar um mecanismo de manuseio de exceção múltipla.
O processamento de exceção múltipla é alcançado definindo vários blocos de captura após um bloco de tentativa. Cada bloco de captura é usado para receber e processar um objeto de exceção específico. Através dos parâmetros do bloco de captura, ele determina se um objeto de exceção deve ser uma exceção recebida e processada por este bloco de captura.
Qual bloco de captura é obtido? De acordo com a correspondência dos parâmetros de exceção do objeto de exceção e do bloco de captura: quando eles atendem a qualquer uma das três condições a seguir, o objeto de exceção e o parâmetro são considerados para corresponder:
1) O objeto de exceção pertence à mesma classe de exceção que o parâmetro.
2) O objeto de exceção pertence a uma subclasse da classe de exceção do parâmetro.
3) O objeto de exceção implementa a interface definida pelos parâmetros.
Se o objeto de exceção gerado pelo bloco de tentativa for recebido pelo primeiro bloco de captura, o fluxo do programa irá diretamente para este bloco de declaração de captura. Depois que o bloco de declaração for executado, o método atual será excitado. As declarações que não foram executadas no bloco de tentativa e outros blocos de captura serão ignoradas. Se o objeto de exceção gerado pelo bloco de tentativa não corresponder ao primeiro bloco de captura, o sistema irá automaticamente para o segundo bloco de captura para corresponder. Se o segundo ainda não corresponder, ele voltará ao terceiro, quarto ... até que um bloco de captura que possa receber o objeto de exceção seja encontrado e o processo será concluído.
Se o objeto de exceção gerado pelo bloco de tentativa for recebido pelo primeiro bloco de captura, o fluxo do programa irá diretamente para este bloco de declaração de captura. Depois que o bloco de declaração for executado, o método atual será excitado. As declarações que não foram executadas no bloco de tentativa e outros blocos de captura serão ignoradas. Se o objeto de exceção gerado pelo bloco de tentativa não corresponder ao primeiro bloco de captura, o sistema irá automaticamente para o segundo bloco de captura para corresponder. Se o segundo ainda não corresponder, ele voltará ao terceiro, quarto ... até que um bloco de captura que possa receber o objeto de exceção seja encontrado e o processo será concluído.
Se a execução de todas as instruções no bloco de tentativa não aumentar uma exceção, todos os blocos de captura serão ignorados e não executados.
Perceber:
1) As declarações no bloco de captura devem executar operações diferentes de acordo com as diferentes exceções; portanto, ao lidar com várias exceções, você deve prestar atenção para projetar cuidadosamente a ordem de arranjo de cada bloco de captura. Geralmente, os blocos de captura que lidam com exceções mais específicos e comuns devem ser colocados na frente, enquanto os blocos de captura que podem corresponder a várias exceções devem ser colocados na parte traseira.
/*Tente o usuário executar o tratamento da exceção de erro: o problema é esse. Quando o valor inicial do salário do usuário inserido é inferior a 800, está errado. Obviamente, se a mudança no salário exceder 20%, também está errado*/ importar java.awt.*; importar java.Applet.*; importar java.awt.event.*; classe pública userexceptionApplet estende o applem implementa o ActionListener {etiquet prompt1 = new Label ("Por favor, insira o nome do funcionário e o valor inicial do salário:"); Rótulo prompt2 = novo rótulo ("insira o salário a ser modificado"); Nome do campo de texto, Isal, Nsal; String msg; EMP do funcionário; Botão okbtn = novo botão ("ok"); Botão cancelbtn = new Button ("Cancelar"); public void init () {name = new textfield (5); isal = novo campo de texto (5); nsal = novo campo de texto (5); add (prompt1); add (nome); add (isal); add (prompt2); add (nsal); add (okbtn); okbtn.addactionListener (this); cancelbtn.addactionListener (isto); add (cancelbtn); } public void Paint (gráficos G) {G.DrawString (MSG, 0,80); } public void createemp (string empname, duplo sa) {try {emp = new funcionário (empname, sa); msg = new String (Emp.toString ()); } catch (ilegalsalaryException é) {msg = new String (ise.toString ()); }} public void changeempsal (alterações duplas) {try {emp.setempSalary (alterações); msg = new String (Emp.toString ()); } catch (ilegalaryexception illsal) {msg = new String (illsal.toString ()); } catch (ilegalaryChangeException illsalchange) {msg = new String (emp.toString ()+illsalchange.toString ()); }} public void ActionPerformed (ActionEvent e) {string empname; duplo empsal, mudanças; Objeto obj = e.getSource (); if (obj == okbtn) {empname = new string (name.getText ()); if (empname == null) {msg = new String ("Por favor, insira o nome e o salário do funcionário primeiro e crie -o"); } if (nsal.getText () == null) {empal = duplo.valueof (isal.getText ()). DoubleValue (); CreateEMP (empname, Empsal); } else {alteraçõesLe = duplo.valueof (nsal.getText ()). DoubleValue (); Alteração de alteração (alterações); }} if (obj == cancelbtn) {naem.settext (""); isal.settext (""); nsal.settext (""); } repaint (); }} classe funcionário {string m_empname; duplo m_empsalary; Funcionário (nome da string, dupla inicial) lança ilegalaryexception {m_empname = name; // veja se há algum problema aqui, o código de referência é m_empName = new String (nome); if (initsalary <800) {throw (nova ilegalaryexception (isto, initsalary)); // declaração de tiro} m_empsalary = initsalary; } public string getempName () {return m_empName; } public duplo getempsalary () {return m_empsalary; } public boolean setempsalary (duplo notícias) lança ilegalaryexception, ilegalaryChangeException {if (Newsal <800) arremesso (nova ilegalaryexception (isto, notícias)); caso contrário, if (getempsalary () == 0.0) {m_empsalary = Newsal; retornar true; } else if (math.abs (newsal-getempsalary ())/getempsalary ()> = 0.2) arremesso (novo ilegalaryChangeException (isto, newsal-getempsalary ())); else {m_empsalary = Newsal; retornar true; }} public string tostring () {string s; s = "nome:"+m_empname+"salário:"+m_empsalary; retorno s; }} classe IllegalSalaryException estende a exceção {funcionário privado m_concernedemp; m_illegalyary duplo privado; IllegalsalaryException (Empury EMP, Isal duplo) {Super ("O salário é menor que o salário mínimo"); M_CONCERNEDEMP = EMP; m_illeGalsalary = isal; } public string tostring () {string s; s = "Os salários fornecidos aos funcionários são ilegais: funcionários:"+m_concernedemp.getempname ()+"Salário ilegal:"+m_illegalsalary+"menor que o salário mínimo de RMB 800"; retorno s; }} classe IllegalSalaryChangeException estende a exceção {funcionário privado m_concernedemp; Double m_illeGalaryChange privado; IlegalaryChangeException (funcionário Emp, duplo csal) {super ("mudança de salário é muito grande"); M_CONCERNEDEMP = EMP; m_illeGalSalaryChange = csal; } public string tostring () {string s; s = "A alteração salarial fornecida aos funcionários é ilegal: funcionário:"+m_concernedemp.getempname ()+"mudança ilegal de mudança de salário:"+m_illegalaryChange+"20% maior que o salário original"; retorno s; }}