JAVA 定义一个负数 用java定义一个复数类

二、上机内容：

1、观看视频：“第05章：面向对象基础”。

 

2、编写一个类实现复数的运算。

复数类ComplexNumber的属性：

 m_dRealPart：实部，代表复数的实数部分。

 m_dImaginPart：虚部，代表复数的虚数部分。

复数类ComplexNumber的方法：

ComplexNumber()：构造函数，将实部、虚部都置为０。

ComplexNumber(double r,double i)：构造函数，创建复数对象的同时完成复数的实部、虚部的初始化，r为实部的初值，i为虚部的初值。

getRealPart()：获得复数对象的实部。

getImaginPart()：获得复数对象的虚部。

setRealPart(double d)：把当前复数对象的实部设置为给定的形式参数的数字。

setImaginaryPart(double d)：把当前复数对象的虚部设置为给定的形式参数的数字。

complexAdd(ComplexNumber c)：当前复数对象与形式参数复数对象相加，所得的结果也是复数值，返回给此方法的调用者。

complexAdd(double c)：当前复数对象与形式参数实数对象相加，所得的结果仍是复数值，返回给此方法的调用者。

complexMinus(ComplexNumber c) ：当前复数对象与形式参数复数对象相减，所得的结果也是复数值，返回给此方法的调用者。

complexMinus(double c) ：当前复数对象与形式参数实数对象相减，所得的结果仍是复数值，返回给此方法的调用者。

complexMulti(ComplexNumber c)：当前复数对象与形式参数复数对象相乘，所得的结果也是复数值，返回给此方法的调用者。

complexMulti(double c)：当前复数对象与形式参数实数对象相乘，所得的结果仍是复数值，返回给此方法的调用者。

toString()：把当前复数对象的实部、虚部组合成a+bi的字符串形式，其中和分别为实部和虚部的数据。

 

3、编写Java Application程序使用上题定义的类，检查类定义是否正确。

二。代码参考

public class ComplexNumber{
	double m_dRealPart,m_dImaginPart;
	//ComplexNumber()：构造函数，将实部、虚部都置为０。
	public ComplexNumber()
	{
		this.m_dRealPart=0;
		this.m_dImaginPart=0;
	}
	//ComplexNumber(double r,double i)：构造函数，创建复数对象的同时完成复数的实部、虚部的初始化，
	//r为实部的初值，i为虚部的初值。
	public ComplexNumber(double r,double i)
	{
		this.m_dRealPart=r;
		this.m_dImaginPart=i;
	}


	public double get_dRealPart() {
		return m_dRealPart;
	}

	public void set_dRealPart(double mDRealPart) {
		m_dRealPart = mDRealPart;
	}

	public double get_dImaginPart() {
		return m_dImaginPart;
	}

	public void set_dImaginPart(double mDImaginPart) {
		m_dImaginPart = mDImaginPart;
	}
	//complexAdd(ComplexNumber c)：当前复数对象与形式参数复数对象相加，所得的结果也是复数值，返回给此方法的调用者。
	
	public ComplexNumber complexAdd(ComplexNumber c)
	{
		ComplexNumber cm=new ComplexNumber();
		cm.m_dImaginPart=c.m_dImaginPart+this.m_dImaginPart;
		cm.m_dRealPart=c.m_dRealPart+this.m_dRealPart;
		return cm;
	}
	//complexAdd(double c)：当前复数对象与形式参数实数对象相加，所得的结果仍是复数值，返回给此方法的调用者。
	
	public ComplexNumber complexAdd(double c)
	{
		ComplexNumber cm=new ComplexNumber();
		cm.m_dImaginPart=this.m_dImaginPart;
		cm.m_dRealPart=this.m_dRealPart+c;
		return cm;
	}
	//complexMinus(ComplexNumber c) ：当前复数对象与形式参数复数对象相减，所得的结果也是复数值，返回给此方法的调用者。
	public ComplexNumber complexMinus(ComplexNumber c)
	{
		ComplexNumber cm=new ComplexNumber();
		cm.m_dImaginPart=this.m_dImaginPart-c.m_dImaginPart;
		cm.m_dRealPart=this.m_dRealPart-c.m_dRealPart;
		return cm;
	}
	
	//complexMinus(double c) ：当前复数对象与形式参数实数对象相减，所得的结果仍是复数值，返回给此方法的调用者。
	
	public ComplexNumber complexMinus(double c)
	{
		ComplexNumber cm=new ComplexNumber();
		cm.m_dRealPart=this.m_dRealPart-c;
		cm.m_dImaginPart=this.m_dImaginPart;
		return cm;
	}
	
	//complexMulti(ComplexNumber c)：当前复数对象与形式参数复数对象相乘，所得的结果也是复数值，返回给此方法的调用者。
	
	public ComplexNumber complexMulti(ComplexNumber c)
	{
		ComplexNumber cm=new ComplexNumber();
		cm.m_dImaginPart=this.m_dImaginPart*c.m_dImaginPart;
		cm.m_dRealPart=this.m_dRealPart*c.m_dRealPart;
		return cm;
	}
	
	//complexMulti(double c)：当前复数对象与形式参数实数对象相乘，所得的结果仍是复数值，返回给此方法的调用者。 
	
	public ComplexNumber complexMulti(double c)
	{
		ComplexNumber cm=new ComplexNumber();
		cm.m_dImaginPart=this.m_dImaginPart;
		cm.m_dRealPart=this.m_dRealPart*c;
		return cm;
	}
	
	//toString()：把当前复数对象的实部、虚部组合成a+bi的字符串形式，其中和分别为实部和虚部的数据。
	
	public String toString()
	{
		String s1,s2;
		s1=((Double)this.m_dRealPart).toString();
		s2=((Double)this.m_dImaginPart).toString();
		if(this.m_dRealPart<0)s1="("+s1+")";
		if(this.m_dImaginPart<0)s2="("+s2+")";
		return s1+"+"+s2+"i";
	}
	
}

2）	ChooseComplexNumber：
  
public class ChooseComplexNumber {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        ComplexNumber c=new ComplexNumber();
        System.out.println("ComplexNumber 的无参构造函数初始化结果："+c.toString());
        c.set_dRealPart(1.0);
        System.out.println("ComplexNumber 的set_dRealPart结果："+c.toString());
        c.set_dImaginPart(2.0);
        System.out.println("ComplexNumber 的set_dImaginPart结果："+c.toString());
        ComplexNumber c1=new ComplexNumber(12,25.0);
        System.out.println("ComplexNumber 的双double参数构造函数初始化结果："+c1.toString());
        ComplexNumber c2=new ComplexNumber();
        c2=c.complexAdd(c1);
        System.out.println("复数"+c.toString()+"和复数"+c1.toString()+"相加结果:"+c2.toString());
        c2=c.complexAdd(10);
        System.out.println("复数"+c.toString()+"和实数"+((Double)(10.0)).toString()+"相加结果:"+c2.toString());
        c2=c.complexMinus(c1);
        System.out.println("复数"+c.toString()+"和复数"+c1.toString()+"相减结果:"+c2.toString());
        c2=c.complexMinus(10);
        System.out.println("复数"+c.toString()+"和实数"+((Double)(10.0)).toString()+"x相减结果:"+c2.toString());
        c2=c.complexMulti(c1);
        System.out.println("复数"+c.toString()+"和复数"+c1.toString()+"相乘结果:"+c2.toString());
        c2=c.complexMulti(10);
        System.out.println("复数"+c.toString()+"和实数"+((Double)(10.0)).toString()+"相乘结果:"+c2.toString());
	}

}