ch5_e5_13b.java

《java语言与面向对象程序设计题解及实验指导》源代码

import java.applet.*; 
import java.awt.*;
import java.awt.event.*;

public class ch5_e5_13b extends Applet implements ActionListener
{
    final int NUMBER = 4;
    ComplexNumber cNumber_1;
    ComplexNumber cNumber_2;
    ComplexNumber cResult;
    double d = 0.0;
    
    TextField numComplexTfd[][],subComplexTfd[][];
    Label resComplexLbl[][];
    Button caculateBtn[];
    final String COMMAND_NAME[] = {"ADD","MINUS","MULTIPLE","DIVIDE"};
        
    public ch5_e5_13b()
    {        
        //初始化
        numComplexTfd = new TextField[NUMBER][2];
        subComplexTfd = new TextField[NUMBER][2];
        resComplexLbl = new Label[NUMBER][2];
        caculateBtn = new Button[NUMBER];
        
        for(int i=0; i<NUMBER; i++)
        {
            for(int j=0; j<2; j++)
            {
                numComplexTfd[i][j] = new TextField(5);
                subComplexTfd[i][j] = new TextField(5);
                resComplexLbl[i][j] = new Label("     ");
            }
            caculateBtn[i] = new Button("=");
            caculateBtn[i].addActionListener(this);
            caculateBtn[i].setActionCommand(COMMAND_NAME[i]);
        }
        
        cNumber_1 = new ComplexNumber();
        cNumber_2 = new ComplexNumber();
        cResult = new ComplexNumber();
        
        //加入各图形界面成分
        for(int i=0; i<NUMBER; i++)
        {            
            //第一个操作数的输入界面成分
            add(new Label("  ("));
            add(numComplexTfd[i][0]);
            add(new Label("+"));
            add(numComplexTfd[i][1]);
            add(new Label("i  )  "));
            
            //操作符
            switch(i)
            {
                case 0: add(new Label(" + "));
                        break;
                case 1: add(new Label(" - "));
                        break;
                case 2: add(new Label(" * "));
                        break;
                case 3: add(new Label(" / "));
                        break;
            }
            
            //第二个操作数的输入界面成分
            add(new Label("  ("));
            add(subComplexTfd[i][0]);
            add(new Label("+"));
            add(subComplexTfd[i][1]);
            add(new Label("i  )"));
            
            //启动运算的按钮
            add(caculateBtn[i]);

            //运算结果的输出界面成分
            add(new Label("  ("));
            add(resComplexLbl[i][0]);
            add(new Label("+"));
            add(resComplexLbl[i][1]);
            add(new Label("i  )          "));
        }//for
        
    }//构造函数
    
    public void init()
    {
        resetTextField();
    }
    
    public void actionPerformed(ActionEvent e)
    {
        int flag = 0;
        
        try
        {
            //确定何种运算
            if(e.getActionCommand().equals(COMMAND_NAME[0]))
                flag = 0;
            else if(e.getActionCommand().equals(COMMAND_NAME[1]))
                flag = 1;
            else if(e.getActionCommand().equals(COMMAND_NAME[2]))
                flag = 2;
            else if(e.getActionCommand().equals(COMMAND_NAME[3]))
                flag = 3;
            else
            {
                showStatus("未定义这种事件的处理操作" + e.toString());
                return;
            }

            //取得第一个操作数的数值
            cNumber_1.setRealPart(
                Double.parseDouble(numComplexTfd[flag][0].getText()));
            cNumber_1.setImaginaryPart(
                Double.parseDouble(numComplexTfd[flag][1].getText()));
            //若第二个操作数是实数，则完成相应的计算
            if(subComplexTfd[flag][1].getText().equals(""))
            {
                d = Double.parseDouble(subComplexTfd[flag][0].getText());
                switch(flag)
                {
                    case 0: cResult = cNumber_1.complexAdd(d);
                            break;
                    case 1: cResult = cNumber_1.complexMinus(d);
                            break;
                    case 2: cResult = cNumber_1.complexMulti(d);
                            break;
                    case 3: cResult = cNumber_1.complexDivide(d);
                            break;
                }
            }
            //若第二个操作数是复数，则完成相应的计算
            else
            {
                cNumber_2.setRealPart(
                    Double.parseDouble(subComplexTfd[flag][0].getText()));
                cNumber_2.setImaginaryPart(
                    Double.parseDouble(subComplexTfd[flag][1].getText()));
                switch(flag)
                {
                    case 0: cResult = cNumber_1.complexAdd(cNumber_2);
                            break;
                    case 1: cResult = cNumber_1.complexMinus(cNumber_2);
                            break;
                    case 2: cResult = cNumber_1.complexMulti(cNumber_2);
                            break;
                    case 3: cResult = cNumber_1.complexDivide(cNumber_2);
                            break;
                }
            }
            //显示运算结果
            resComplexLbl[flag][0].setText(
                    Double.toString(cResult.getRealPart()));
            resComplexLbl[flag][1].setText(
                    Double.toString(cResult.getImaginaryPart()));
        }
        catch(NumberFormatException nfe)
        {
            showStatus("数据格式错误，请重新输入。");
            resetTextField();
        }
    }
    
    //将各输入、输出域清空
    void resetTextField()
    {
        for(int i=0; i<NUMBER; i++)
        {
            for(int j=0; j<2; j++)
            {
                numComplexTfd[i][j].setText("");
                subComplexTfd[i][j].setText("");
                resComplexLbl[i][j].setText("     ");
            }
        }
    }
    
}

class ComplexNumber
{
    //域
    private double m_dRealPart;
    private double m_dImaginPart;
    
    //构造函数
    ComplexNumber()
    {
        m_dRealPart = 0.0;
        m_dImaginPart = 0.0;
    }
    ComplexNumber(double r,double i)
    {
        m_dRealPart = r;
        m_dImaginPart = i;
    }
    ComplexNumber(ComplexNumber c)
    {
        m_dRealPart = c.getRealPart();
        m_dImaginPart = c.getImaginaryPart();
    }
    
    //get,set方法
    double getRealPart()
    {
        return m_dRealPart;
    }
    double getImaginaryPart()
    {
        return m_dImaginPart;
    }
    void setRealPart(double d)
    {
        m_dRealPart = d;
    }
    void setImaginaryPart(double d)
    {
        m_dImaginPart = d;
    }
    
    //复数的共轭
    ComplexNumber complexConjugate()
    {
        return new ComplexNumber(m_dRealPart,
            -1 * m_dImaginPart);
    }
    
    //复数运算方法
    ComplexNumber complexAdd(ComplexNumber c)
    {
        return new ComplexNumber(
            this.m_dRealPart + c.getRealPart(),
            this.m_dImaginPart + c.getImaginaryPart());
    }
    ComplexNumber complexAdd(double c)
    {
        return new ComplexNumber(
            this.m_dRealPart + c, this.m_dImaginPart);
    }
    ComplexNumber complexMinus(ComplexNumber c)
    {
        return new ComplexNumber(
            this.m_dRealPart - c.getRealPart(),
            this.m_dImaginPart - c.getImaginaryPart());
    }
    ComplexNumber complexMinus(double c)
    {
        return new ComplexNumber(
            this.m_dRealPart - c, this.m_dImaginPart);
    }
    ComplexNumber complexMulti(ComplexNumber c)
    {
        return new ComplexNumber(
            this.m_dRealPart * c.getRealPart() 
                - this.m_dImaginPart * c.getImaginaryPart(),
            this.m_dRealPart * c.getImaginaryPart()
                + this.m_dImaginPart * c.getRealPart());
    }
    ComplexNumber complexMulti(double c)
    {
        return new ComplexNumber(
            this.m_dRealPart * c, this.m_dImaginPart * c);
    }
    ComplexNumber complexDivide(double d)
    {
        return new ComplexNumber(this.m_dRealPart / d,
            this.m_dImaginPart /d);
    }
    ComplexNumber complexDivide(ComplexNumber c)
    {
        double mod = c.getRealPart()*c.getRealPart()
            + c.getImaginaryPart()*c.getImaginaryPart();
        if(mod == 0)
            return new ComplexNumber(0,0);
        else
            return this.complexMulti(
                c.complexConjugate()).complexDivide(mod);
    }
    
    //toString()
    public String toString()
    {
        return "(" + m_dRealPart + " + " 
            + m_dImaginPart + " i" + ")";
    }
    
}