在Java中使用復雜的類聲明泛型變量

Question

我有一個用復數計算的類，一個實部和一個虛部為double型。 在另一部分中，我有一個有理類來計算有理數。 現在，我希望我的復數類可以在實部和虛部是有理數時運行。 我已經閱讀了一些有關泛型的文檔，但是我不知道如何將實部和虛部聲明為泛型，並且當實部和虛部為雙精度或有理數時，如何使用方法將2個復數相加。 這是我的測試代碼：

import java.util.regex.Pattern;

public class Complex {
    private double real;
    private double imaginary;
    private Rational qreal;
    private Rational qimaginary;

    public Complex(double real, double imaginary) {
        super();
        this.real = real;
        this.imaginary = imaginary;
    }
    public Complex(Rational real, Rational imaginary) {
        this.qreal = real;
        this.qimaginary = imaginary;
    }
    public Complex(String z) {
        z = z.replaceAll(" ","");
        if(z.contains("i") || z.contains("j")){
            if(z.contains("+")) {
                String[] z1 = z.split(Pattern.quote("+"));
                this.real = Double.parseDouble(z1[0]);
                this.imaginary = Double.parseDouble(z1[1].substring(0, z1.length-1));
            }
            else if(z.contains("-")) {
                String[] z1 = z.split(Pattern.quote("-"));
                this.real = Double.parseDouble(z1[0]);
                this.imaginary = -Double.parseDouble(z1[1].substring(0, z1.length-1));
            }
            else System.out.println("Syntax Error");
        }
        else System.out.println("The complex must only contains i or j as imaginary unit");
    }
    public double getReal() {
        return real;
    }
    public void setReal(double real) {
        this.real = real;
    }
    public double getImaginary() {
        return imaginary;
    }
    public Rational getQreal() {
        return qreal;
    }
    public void setQreal(Rational qreal) {
        this.qreal = qreal;
    }
    public Rational getQimaginary() {
        return qimaginary;
    }
    public void setQimaginary(Rational qimaginary) {
        this.qimaginary = qimaginary;
    }
    public void setImaginary(double imaginary) {
        this.imaginary = imaginary;
    }

    Complex opposite(Complex z) {return new Complex(-z.real, -z.imaginary);}
    double abs() {return Math.hypot(this.real, this.imaginary);}
    Complex conjugate() {return new Complex(real, -imaginary);}
    Complex inverse() {
        if(this.real == 0 && this.imaginary == 0) return new Complex(Double.NaN, Double.NaN);
        else {
            Complex c = this.conjugate();
            double abs_square = Math.pow(this.abs(), 2.);
            return new Complex(c.real / abs_square, c.imaginary / abs_square);
        }
    }

    Complex add2(Complex z) {
        System.out.println("Suma " + this.qreal.add(z.qreal) + " " + this.qimaginary.add(z.qimaginary) + "i");
        return new Complex(this.qreal.add(z.qreal), this.qimaginary.add(z.qimaginary));
    }
    Complex add(Complex z) {return new Complex(this.real + z.real, this.imaginary + z.imaginary);}
    Complex subtract(Complex z) {return add(z.opposite(z));}
    Complex product(Complex z) {
        double r, i;
        r = this.real * z.real - this.imaginary * z.imaginary;
        i = this.real * z.imaginary + this.imaginary * z.real;
        return new Complex(r, i);
    }
    Complex div(Complex z) {
        Complex num = this.product(z.conjugate());
        double den = Math.pow(Math.hypot(z.real, z.imaginary), 2.);
        return new Complex(num.real / den, num.imaginary / den);
    }
    /* (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "Complex [real=" + real + ", imaginary=" + imaginary + ", qreal=" + qreal + ", qimaginary=" + qimaginary
                + "]";
    }


    /*@Override
    public String toString() {
        if(imaginary > 0.) {
            if (imaginary == 1.)
                return real + " + " + "i";
            return real + " + " + imaginary + "i";
        }
        else if(imaginary < 0.) {
            if (imaginary == -1.)
                return real + " - " + "i";
            return real + " " + imaginary + "i";
        }
        else if(imaginary == 0.)
            return "" +  real;
        else if(real == 0.)
            return  imaginary + "i";
        else
            return "0";
    }*/



}

如果您看到的代碼，我已經實現了2個add方法，但是我只想要一個，因此對於其他方法，toString（）也是如此。

Answer 1

當您要保留類型信息時，泛型很有用。 但是泛型類型仍然需要具有一些已知的接口才能使用它。 由於double和Rational不共享公共接口，因此無法直接創建適用於兩種類型的通用實現。

您可以做的是使用DoubleComplex和RationalComplex兩個實現創建一個Complex接口：

public interface Complex<T> {

    T getReal();
    T getImaginary();

    Complex<T> opposite(Complex<T> z);
    double abs();
    Complex<T> conjugate();
    Complex<T> inverse();

    Complex<T> add(Complex<T> z);
    Complex<T> subtract(Complex<T> z);
    Complex<T> product(Complex<T> z);
    Complex<T> div(Complex<T> z);

}

public class DoubleComplex implements Complex<Double> {

    private final double real;
    private final double imaginary;

    ...

    @Override
    public Complex<Double> add(Complex<Double> z) {
        return new DoubleComplex(this.real + z.getReal(), this.imaginary + z.getImaginary());
    }

    ...
}

public class RationalComplex implements Complex<Rational> {

    private final Rational real;
    private final Rational imaginary;

    ...

    @Override
    public Complex<Rational> add(Complex<Rational> z) {
        return new RationalComplex(this.real.add(z.getReal()), this.imaginary.add(z.getImaginary()));
    }

    ...
}