我将在java重复我要做的事情，就像我认为我需要思考的方式来完成这项任务一样。 （对不起，我是编程新手。）
头等舱;定义复数的类。我觉得这很容易，我的答案如下。
public class Complex {
private double real;
private double imaginary;
public Complex()
{
this( 0.0, 0.0 );
}
public Complex( double r, double i )
{
real = r;
imaginary = i;
}
}
第二课;使用公共静态方法添加和减去，从第一类中调用实数和虚数。这部分我发现有点挑战，因为我没有100％掌握这一点。
Public class ComplexArith
public static ComplexAdd(Complex one, Complex two)
return Complex(one.getReal() + two.getReal(), one.getImaginary() + two.getImaginary());
public static ComplexSub(Complex one, Complex two)
return Complex(one.getReal() - two.getReal(), one.getImaginary - two.getImaginary());
第三部分是要求用户输入，并添加和减去复数的集合。我对此并不熟悉，因为我从来没有要求（0.0,0.0）格式的用户输入。
对整体代码的任何见解？我甚至走在正确的轨道上吗？
编辑：
我打出的第一堂课。谢谢你们。
第二课我正在编写问题因为我没有完全理解某些东西。
public class ComplexArith{
public static Complex add(Complex one, Complex two)
{
return Complex(one.getReal() + two.getReal(), one.getImaginary() + two.getImaginary());
}
public static Complex sub(Complex one, Complex two)
{
return Complex(one.getReal() - two.getReal(), one.getImaginary - two.getImaginary());
}
}
我知道需要定义一个和两个，但我不了解如何定义它们。我将它们定义为什么？我以为它是从复合类中调用双r，双i。
我还认为在第一堂课中也定义了.getImaginary。这是第一堂课。
public class Complex
{
private double real;
private double imaginary;
public Complex()
{
this( 0.0, 0.0 );
}
public Complex( double r, double i )
{
real = r;
imaginary = i;
}
public double getReal() {
return this.real;
}
public double getImaginary() {
return this.imaginary;
}
}
答案 0 :(得分：2)
嗯，你走在正确的轨道上，但你需要Complex对象的吸气剂。
例如：
public class Complex
{
private double real;
private double imaginary;
public Complex()
{
this( 0.0, 0.0 );
}
public Complex( double r, double i )
{
real = r;
imaginary = i;
}
public double getReal() {
return this.real;
}
public double getImaginary() {
return this.imaginary;
}
}
您还需要使用方法返回类型：
public class ComplexArith
{
public static Complex complexAdd(Complex one, Complex two) {
return Complex(one.getReal() + two.getReal(),
one.getImaginary() + two.getImaginary());
}
public static Complex complexSub(Complex one, Complex two) {
return Complex(one.getReal() - two.getReal(),
one.getImaginary - two.getImaginary());
}
}
此外，它与您的程序功能无关，但习惯上让您的方法使用camelCase。所以你的方法应该是这样的：
public static Complex complexAdd(Complex one, Complex two) {
return Complex(one.getReal() + two.getReal(),
one.getImaginary() + two.getImaginary());
}
答案 1 :(得分：1)
就个人而言，我将这些算术运算放在Complex类中。这些是对复数的真正操作，所以我不会将它们封装在Complex类之外。
我会考虑使复杂不可变。这样就是线程安全的。
我喜欢静态的add，sub，mul，div方法。确保他们返回一个复合体（他们现在不会）。其他方法，如余弦，正弦等，可能属于复杂包中的Math类。有关实数的示例，请参阅java.lang.Math。
您需要返回“new Complex”。你编写的代码不会编译。
答案 2 :(得分：1)
这是我的实现，我在一个类上做了所有事情：
package name.puzio.math;
public final class ComplexNumber {
private final double imaginary;
private final double real;
@Override
public final boolean equals(Object object) {
if (!(object instanceof ComplexNumber))
return false;
ComplexNumber a = (ComplexNumber) object;
return (real == a.real) && (imaginary == a.imaginary);
}
public ComplexNumber(double real, double imaginary) {
this.imaginary = imaginary;
this.real = real;
}
public static final ComplexNumber createPolar(double amount, double angel) {
return new ComplexNumber(amount * Math.cos(angel), amount * Math.sin(angel));
}
public final double getImaginary() {
return imaginary;
}
public final double getReal() {
return real;
}
public final double getAmount() {
return Math.sqrt((real * real) + (imaginary * imaginary));
}
public final double getAngle() {
return Math.atan2(imaginary, real);
}
public final ComplexNumber add(ComplexNumber b) {
return add(this, b);
}
public final ComplexNumber sub(ComplexNumber b) {
return sub(this, b);
}
public final ComplexNumber div(ComplexNumber b) {
return div(this, b);
}
public final ComplexNumber mul(ComplexNumber b) {
return mul(this, b);
}
public final ComplexNumber conjugation() {
return conjugation(this);
}
/**
* Addition:
* @param a
* @param b
* @return
*/
private final static ComplexNumber add(ComplexNumber a, ComplexNumber b) {
return new ComplexNumber(a.real + b.real, a.imaginary + b.imaginary);
}
/**
* Subtraktion:
* @param a
* @param b
* @return
*/
private final static ComplexNumber sub(ComplexNumber a, ComplexNumber b) {
return new ComplexNumber(a.real - b.real, a.imaginary - b.imaginary);
}
/**
* Multiplikation:
* @param a
* @param b
* @return
**/
private final static ComplexNumber mul(ComplexNumber a, ComplexNumber b) {
return new ComplexNumber((a.real * b.real) - (a.imaginary * b.imaginary), (a.imaginary * b.real) + (a.real * b.imaginary));
}
/**
* Division:
* @param a
* @param b
* @return
**/
private final static ComplexNumber div(ComplexNumber a, ComplexNumber b) {
double d = (b.real * b.real) + (b.imaginary * b.imaginary);
if (d == 0)
return new ComplexNumber(Double.NaN, Double.NaN);
return new ComplexNumber(((a.real * b.real) + (a.imaginary * b.imaginary)) / d, ((a.imaginary * b.real) - (a.real * b.imaginary)) / d);
}
/**
* Konjugation:
* @param a
* @return
**/
private final static ComplexNumber conjugation(ComplexNumber a) {
return new ComplexNumber(a.real, -a.imaginary);
}
}
答案 3 :(得分：0)
考虑到你所说的作业，你有点走在正确的轨道上。
但是，在第二堂课中，您在getReal()个对象上调用getImaginary()和Complex方法。但是他们的定义没有出现在Complex类定义的任何地方。
ComplexArith中的方法没有返回类型。
单独这些将阻止您的代码按原样编译。
答案 4 :(得分：0)
正确将格式为String的{{1}}转换为(r,i)的方法是使用正则表达式。但是，如果您不熟悉编程，那么教师可能会怀疑您从Internet复制了该解决方案:)请尝试以下方法：
Complex您可以在此处找到有关Java String类的更多信息：http://docs.oracle.com/javase/6/docs/api/java/lang/String.html
答案 5 :(得分：0)
虽然这已经得到了解答，但我认为人们可能会受益于以下类，它可以完成许多与复数相关的功能。
这已在MIT许可下发布，GitHub项目为here。
/**
* <code>ComplexNumber</code> is a class which implements complex numbers in Java.
* It includes basic operations that can be performed on complex numbers such as,
* addition, subtraction, multiplication, conjugate, modulus and squaring.
* The data type for Complex Numbers.
* <br /><br />
* The features of this library include:<br />
* <ul>
* <li>Arithmetic Operations (addition, subtraction, multiplication, division)</li>
* <li>Complex Specific Operations - Conjugate, Inverse, Absolute/Magnitude, Argument/Phase</li>
* <li>Trigonometric Operations - sin, cos, tan, cot, sec, cosec</li>
* <li>Mathematical Functions - exp</li>
* <li>Complex Parsing of type x+yi</li>
* </ul>
*
* @author Abdul Fatir
* @version 1.1
*
*/
public class ComplexNumber
{
/**
* Used in <code>format(int)</code> to format the complex number as x+yi
*/
public static final int XY = 0;
/**
* Used in <code>format(int)</code> to format the complex number as R.cis(theta), where theta is arg(z)
*/
public static final int RCIS = 1;
/**
* The real, Re(z), part of the <code>ComplexNumber</code>.
*/
private double real;
/**
* The imaginary, Im(z), part of the <code>ComplexNumber</code>.
*/
private double imaginary;
/**
* Constructs a new <code>ComplexNumber</code> object with both real and imaginary parts 0 (z = 0 + 0i).
*/
public ComplexNumber()
{
real = 0.0;
imaginary = 0.0;
}
/**
* Constructs a new <code>ComplexNumber</code> object.
* @param real the real part, Re(z), of the complex number
* @param imaginary the imaginary part, Im(z), of the complex number
*/
public ComplexNumber(double real, double imaginary)
{
this.real = real;
this.imaginary = imaginary;
}
/**
* Adds another <code>ComplexNumber</code> to the current complex number.
* @param z the complex number to be added to the current complex number
*/
public void add(ComplexNumber z)
{
set(add(this,z));
}
/**
* Subtracts another <code>ComplexNumber</code> from the current complex number.
* @param z the complex number to be subtracted from the current complex number
*/
public void subtract(ComplexNumber z)
{
set(subtract(this,z));
}
/**
* Multiplies another <code>ComplexNumber</code> to the current complex number.
* @param z the complex number to be multiplied to the current complex number
*/
public void multiply(ComplexNumber z)
{
set(multiply(this,z));
}
/**
* Divides the current <code>ComplexNumber</code> by another <code>ComplexNumber</code>.
* @param z the divisor
*/
public void divide(ComplexNumber z)
{
set(divide(this,z));
}
/**
* Sets the value of current complex number to the passed complex number.
* @param z the complex number
*/
public void set(ComplexNumber z)
{
this.real = z.real;
this.imaginary = z.imaginary;
}
/**
* Adds two <code>ComplexNumber</code>.
* @param z1 the first <code>ComplexNumber</code>.
* @param z2 the second <code>ComplexNumber</code>.
* @return the resultant <code>ComplexNumber</code> (z1 + z2).
*/
public static ComplexNumber add(ComplexNumber z1, ComplexNumber z2)
{
return new ComplexNumber(z1.real + z2.real, z1.imaginary + z2.imaginary);
}
/**
* Subtracts one <code>ComplexNumber</code> from another.
* @param z1 the first <code>ComplexNumber</code>.
* @param z2 the second <code>ComplexNumber</code>.
* @return the resultant <code>ComplexNumber</code> (z1 - z2).
*/
public static ComplexNumber subtract(ComplexNumber z1, ComplexNumber z2)
{
return new ComplexNumber(z1.real - z2.real, z1.imaginary - z2.imaginary);
}
/**
* Multiplies one <code>ComplexNumber</code> to another.
* @param z1 the first <code>ComplexNumber</code>.
* @param z2 the second <code>ComplexNumber</code>.
* @return the resultant <code>ComplexNumber</code> (z1 * z2).
*/
public static ComplexNumber multiply(ComplexNumber z1, ComplexNumber z2)
{
double _real = z1.real*z2.real - z1.imaginary*z2.imaginary;
double _imaginary = z1.real*z2.imaginary + z1.imaginary*z2.real;
return new ComplexNumber(_real,_imaginary);
}
/**
* Divides one <code>ComplexNumber</code> by another.
* @param z1 the first <code>ComplexNumber</code>.
* @param z2 the second <code>ComplexNumber</code>.
* @return the resultant <code>ComplexNumber</code> (z1 / z2).
*/
public static ComplexNumber divide(ComplexNumber z1, ComplexNumber z2)
{
ComplexNumber output = multiply(z1,z2.conjugate());
double div = Math.pow(z2.mod(),2);
return new ComplexNumber(output.real/div,output.imaginary/div);
}
/**
* The complex conjugate of the current complex number.
* @return a <code>ComplexNumber</code> object which is the conjugate of the current complex number
*/
public ComplexNumber conjugate()
{
return new ComplexNumber(this.real,-this.imaginary);
}
/**
* The modulus, magnitude or the absolute value of current complex number.
* @return the magnitude or modulus of current complex number
*/
public double mod()
{
return Math.sqrt(Math.pow(this.real,2) + Math.pow(this.imaginary,2));
}
/**
* The square of the current complex number.
* @return a <code>ComplexNumber</code> which is the square of the current complex number.
*/
public ComplexNumber square()
{
double _real = this.real*this.real - this.imaginary*this.imaginary;
double _imaginary = 2*this.real*this.imaginary;
return new ComplexNumber(_real,_imaginary);
}
/**
* @return the complex number in x + yi format
*/
@Override
public String toString()
{
String re = this.real+"";
String im = "";
if(this.imaginary < 0)
im = this.imaginary+"i";
else
im = "+"+this.imaginary+"i";
return re+im;
}
/**
* Calculates the exponential of the <code>ComplexNumber</code>
* @param z The input complex number
* @return a <code>ComplexNumber</code> which is e^(input z)
*/
public static ComplexNumber exp(ComplexNumber z)
{
double a = z.real;
double b = z.imaginary;
double r = Math.exp(a);
a = r*Math.cos(b);
b = r*Math.sin(b);
return new ComplexNumber(a,b);
}
/**
* Calculates the <code>ComplexNumber</code> to the passed integer power.
* @param z The input complex number
* @param power The power.
* @return a <code>ComplexNumber</code> which is (z)^power
*/
public static ComplexNumber pow(ComplexNumber z, int power)
{
ComplexNumber output = new ComplexNumber(z.getRe(),z.getIm());
for(int i = 1; i < power; i++)
{
double _real = output.real*z.real - output.imaginary*z.imaginary;
double _imaginary = output.real*z.imaginary + output.imaginary*z.real;
output = new ComplexNumber(_real,_imaginary);
}
return output;
}
/**
* Calculates the sine of the <code>ComplexNumber</code>
* @param z the input complex number
* @return a <code>ComplexNumber</code> which is the sine of z.
*/
public static ComplexNumber sin(ComplexNumber z)
{
double x = Math.exp(z.imaginary);
double x_inv = 1/x;
double r = Math.sin(z.real) * (x + x_inv)/2;
double i = Math.cos(z.real) * (x - x_inv)/2;
return new ComplexNumber(r,i);
}
/**
* Calculates the cosine of the <code>ComplexNumber</code>
* @param z the input complex number
* @return a <code>ComplexNumber</code> which is the cosine of z.
*/
public static ComplexNumber cos(ComplexNumber z)
{
double x = Math.exp(z.imaginary);
double x_inv = 1/x;
double r = Math.cos(z.real) * (x + x_inv)/2;
double i = -Math.sin(z.real) * (x - x_inv)/2;
return new ComplexNumber(r,i);
}
/**
* Calculates the tangent of the <code>ComplexNumber</code>
* @param z the input complex number
* @return a <code>ComplexNumber</code> which is the tangent of z.
*/
public static ComplexNumber tan(ComplexNumber z)
{
return divide(sin(z),cos(z));
}
/**
* Calculates the co-tangent of the <code>ComplexNumber</code>
* @param z the input complex number
* @return a <code>ComplexNumber</code> which is the co-tangent of z.
*/
public static ComplexNumber cot(ComplexNumber z)
{
return divide(new ComplexNumber(1,0),tan(z));
}
/**
* Calculates the secant of the <code>ComplexNumber</code>
* @param z the input complex number
* @return a <code>ComplexNumber</code> which is the secant of z.
*/
public static ComplexNumber sec(ComplexNumber z)
{
return divide(new ComplexNumber(1,0),cos(z));
}
/**
* Calculates the co-secant of the <code>ComplexNumber</code>
* @param z the input complex number
* @return a <code>ComplexNumber</code> which is the co-secant of z.
*/
public static ComplexNumber cosec(ComplexNumber z)
{
return divide(new ComplexNumber(1,0),sin(z));
}
/**
* The real part of <code>ComplexNumber</code>
* @return the real part of the complex number
*/
public double getRe()
{
return this.real;
}
/**
* The imaginary part of <code>ComplexNumber</code>
* @return the imaginary part of the complex number
*/
public double getIm()
{
return this.imaginary;
}
/**
* The argument/phase of the current complex number.
* @return arg(z) - the argument of current complex number
*/
public double getArg()
{
return Math.atan2(imaginary,real);
}
/**
* Parses the <code>String</code> as a <code>ComplexNumber</code> of type x+yi.
* @param s the input complex number as string
* @return a <code>ComplexNumber</code> which is represented by the string.
*/
public static ComplexNumber parseComplex(String s)
{
s = s.replaceAll(" ","");
ComplexNumber parsed = null;
if(s.contains(String.valueOf("+")) || (s.contains(String.valueOf("-")) && s.lastIndexOf('-') > 0))
{
String re = "";
String im = "";
s = s.replaceAll("i","");
s = s.replaceAll("I","");
if(s.indexOf('+') > 0)
{
re = s.substring(0,s.indexOf('+'));
im = s.substring(s.indexOf('+')+1,s.length());
parsed = new ComplexNumber(Double.parseDouble(re),Double.parseDouble(im));
}
else if(s.lastIndexOf('-') > 0)
{
re = s.substring(0,s.lastIndexOf('-'));
im = s.substring(s.lastIndexOf('-')+1,s.length());
parsed = new ComplexNumber(Double.parseDouble(re),-Double.parseDouble(im));
}
}
else
{
// Pure imaginary number
if(s.endsWith("i") || s.endsWith("I"))
{
s = s.replaceAll("i","");
s = s.replaceAll("I","");
parsed = new ComplexNumber(0, Double.parseDouble(s));
}
// Pure real number
else
{
parsed = new ComplexNumber(Double.parseDouble(s),0);
}
}
return parsed;
}
/**
* Checks if the passed <code>ComplexNumber</code> is equal to the current.
* @param z the complex number to be checked
* @return true if they are equal, false otherwise
*/
@Override
public final boolean equals(Object z)
{
if (!(z instanceof ComplexNumber))
return false;
ComplexNumber a = (ComplexNumber) z;
return (real == a.real) && (imaginary == a.imaginary);
}
/**
* The inverse/reciprocal of the complex number.
* @return the reciprocal of current complex number.
*/
public ComplexNumber inverse()
{
return divide(new ComplexNumber(1,0),this);
}
/**
* Formats the Complex number as x+yi or r.cis(theta)
* @param format_id the format ID <code>ComplexNumber.XY</code> or <code>ComplexNumber.RCIS</code>.
* @return a string representation of the complex number
* @throws IllegalArgumentException if the format_id does not match.
*/
public String format(int format_id) throws IllegalArgumentException
{
String out = "";
if(format_id == XY)
out = toString();
else if(format_id == RCIS)
{
out = mod()+" cis("+getArg()+")";
}
else
{
throw new IllegalArgumentException("Unknown Complex Number format.");
}
return out;
}
}
答案 6 :(得分：0)
或者.......你可以省去所有这些废话并且只使用Apache Commons库，它比这里的任何东西都更好，并且包括复杂取幂等基本操作。
https://commons.apache.org/proper/commons-math/userguide/complex.html
但只有你不想重新发明轮子。
答案 7 :(得分：-1)
这不正确！
public static ComplexNumber exp(ComplexNumber z)
{
double a = z.real;
double b = z.imaginary;
double r = Math.exp(a);
a = r*Math.cos(b);
b = r*Math.sin(b);
return new ComplexNumber(a,b);
}
应该是
public static ComplexNumber exp(ComplexNumber z)
{
double theta = Math.atan2(r.real/r.imag);
double r = mod();
double a = r*Math.cos(theta );
double b = r*Math.sin(theta );
return new ComplexNumber(a,b);
}