关于Java中的多个构造函数

我有一个关于Java中构造函数的多个实例的问题

我的任务是接收两个分数，然后乘和除这些分数

我不确定如何为类对象本身的实例创建单独的值

以下是我遇到问题的地方的示例代码：

import java.util.Scanner;

public class TextLab05
{
    static int num1, den1;   // numerator and denominator of the 1st rational number
    static int num2, den2;   // numerator and denominator of the 2nd rational number

    public static void main (String args[])
    {
        enterData();

        Rational r1 = new Rational(num1,den1);
        Rational r2 = new Rational(num2,den2);
    }
}

class Rational
{

    private int firstNum;   // entered numerator
    private int firstDen;   // entered denominator
    private int num;        // reduced numerator
    private int den;        // reduced denominator

    public Rational()
    {

    }

    public Rational(int n, int d)
    {
        n = TextLab05.num1;
        d = TextLab05.den1;
        //Here specifically is where I am having comprehension issues. How can I include num2 and den2 if I only have int n and int d?
    }
}

如果很难断章取义地理解这一点，那么下面是我得到的全部起始代码：

import java.util.Scanner;

public class TextLab05
{
    static int num1, den1;   // numerator and denominator of the 1st rational number
    static int num2, den2;   // numerator and denominator of the 2nd rational number

    public static void main (String args[])
    {
        enterData();

        Rational r1 = new Rational(num1,den1);
        Rational r2 = new Rational(num2,den2);
        Rational r3 = new Rational();

        r3.multiply(r1,r2);
        System.out.println("\n\n" + r1.getOriginal() + " * " + r2.getOriginal() + "  =  " + r3.getRational());
        r3.divide(r1,r2);
        System.out.println("\n" + r1.getOriginal() + " / " + r2.getOriginal() + "  =  " + r3.getRational());

        //      100 Point Version Only
        //      r3.add(r1,r2);
        //      System.out.println("\n" + r1.getOriginal() + " + " + r2.getOriginal() + "  =  " + r3.getRational());
        //      r3.subtract(r1,r2);
        //      System.out.println("\n" + r1.getOriginal() + " - " + r2.getOriginal() + "  =  " + r3.getRational());
        System.out.println();
    }

    public static void enterData()
    {
        Scanner input = new Scanner(System.in);
        System.out.print("\nEnter the 1st numerator ----> ");
        num1 = input.nextInt();
        System.out.print("\nEnter the 1st denominator --> ");
        den1 = input.nextInt();
        System.out.print("\nEnter the 2nd numerator ----> ");
        num2 = input.nextInt();
        System.out.print("\nEnter the 2nd denominator --> ");
        den2 = input.nextInt();
    }
}

class Rational
{

    private int firstNum;   // entered numerator
    private int firstDen;   // entered denominator
    private int num;        // reduced numerator
    private int den;        // reduced denominator

    public Rational()
    {

    }

    public Rational(int n, int d)
    {
        n = TextLab05.num1;
        d = TextLab05.den1;
    }

    private int getGCF(int n1,int n2)
    {
        int rem = 0;
        int gcf = 0;
        do
        {
            rem = n1 % n2;
            if (rem == 0)
                gcf = n2;
            else
            {
                n1 = n2;
            n2 = rem;
            }
        }
        while (rem != 0);
        return gcf;
     }

    public int getNum()
    {
        return TextLab05.num1;
    }

    public int getDen()
    {
        return TextLab05.den1;
    }

    public double getDecimal()
    {
        return (double)TextLab05.num1 / TextLab05.den1;
    }

    public String getRational()
    {
        String rational = "" + TextLab05.num1 + "/" + TextLab05.den1;
        return rational;
    }

    public String getOriginal()
    {
        String original = "" + TextLab05.num1 + "/" + TextLab05.den1;
        return original;
    }

    public void reduce()
    {

    }
    public void multiply(Rational r1, Rational r2)
    {

    }
    public void divide(Rational r1, Rational r2)
    {

    }
    public void add(Rational r1, Rational r2)
    {

    }
    public void subtract(Rational r1, Rational r2)
    {

    }
}

---

我假设

Rational

类应该表示一个有理数。你说：

//Here specifically is where I am having comprehension issues. How can I include num2 and den2 if I only have int n and int d?

不需要在

Rational

类中存储两个分子和两个分母。您只需要创建两个

Rational

对象。一个用于存储

num1

和

den1

，另一个用于存储

num2

和

den2

。您已经在这样做了：

Rational r1 = new Rational(num1,den1);
Rational r2 = new Rational(num2,den2);

在

Rational

中存储两个分子和两个分母是没有意义的。一个有理数每一个都只有一个

---

总之：

r1

存储

num1

和

den1

，而

r2

存储其他两个。当您创建一个新的

Rational

，

n

和

d

引用您正在创建的特定实例的分子和分母。

我假设

Rational

类应该表示一个有理数。你说：

//Here specifically is where I am having comprehension issues. How can I include num2 and den2 if I only have int n and int d?

不需要在

Rational

类中存储两个分子和两个分母。您只需要创建两个

Rational

对象。一个用于存储

num1

和

den1

，另一个用于存储

num2

和

den2

。您已经在这样做了：

Rational r1 = new Rational(num1,den1);
Rational r2 = new Rational(num2,den2);

在

Rational

中存储两个分子和两个分母是没有意义的。一个有理数每一个都只有一个

---

总之：

r1

存储

num1

和

den1

，而

r2

存储其他两个。当您创建一个新的

Rational

，

n

和

d

引用您正在创建的特定实例的分子和分母。

我不确定您的Rational实现是否是您想要的，但构造函数并不限于局部变量，它可以从它可以访问的其他类中访问任何静态变量

public Rational(int n, int d)
{
    n = TextLab05.num1;
    d = TextLab05.den1;
}

n

和

d

是局部变量，

num1

和

den1

是类

TextLab05

中的静态变量

因此，您将使用来自另一个类的静态值来分配局部变量

---

代码没有任何意义，因为在将值分配给局部变量（在方法结束时释放）后，您不会对这些值执行任何操作。

我不确定您对Rational的实现是否是您想要的，但构造函数不限于局部变量，它可以从它可以访问的其他类中访问任何静态变量

public Rational(int n, int d)
{
    n = TextLab05.num1;
    d = TextLab05.den1;
}

n

和

d

是局部变量，

num1

和

den1

是类

TextLab05

中的静态变量

因此，您将使用来自另一个类的静态值来分配局部变量

代码没有任何意义，因为在将值分配给局部变量（在方法结束时释放）后，您不会对这些值执行任何操作。

当您调用：

Rational r1 = new Rational(num1, den1);
Rational r2 = new Rational(num2, den2);

在程序的主方法中，您正在创建Rational类的两个实例，一个名为r1，一个名为r2。因为您将int值传递给Rational构造函数，所以将调用的构造函数是需要两个整数参数的构造函数：

public Rational(int n, int d)
{
    ...
} 

编译器知道这一点，因为它匹配构造函数的名称以及传递的参数类型（称为匹配构造函数的“签名”）

在您提供的代码中，Rational构造函数代码没有真正意义-以下代码：

public Rational(int n, int d)
{
   n = TextLab05.num1;
   d = TextLab05.den1;    
}

应该看起来像这样：

public Rational(int n, int d)
{
   this.firstNum = n;
   this.firstDen = d;    
}

this.num = num1;
this.den = den1;

this.num = this.num * anotherRational.num;
this.den = this.den * anotherRational.den;

值n和d被传递给构造函数，然后在构造函数的主体中，实例变量firstNum和firstDen（在Rational类的私有部分声明，实际上“属于”正在创建的实例）将被初始化为值n和d

在Rational类主体内的任何地方，您都应该引用成员变量

firstNum

和

firstDen

，而不是不“属于”类实例的变量。

当您调用：

Rational r1 = new Rational(num1, den1);
Rational r2 = new Rational(num2, den2);

在程序的主方法中，您正在创建Rational类的两个实例，一个名为r1，一个名为r2。因为您将int值传递给Rational构造函数，所以将调用的构造函数是需要两个整数参数的构造函数：

public Rational(int n, int d)
{
    ...
} 

编译器知道这一点，因为它匹配构造函数的名称以及传递的参数类型（称为匹配构造函数的“签名”）

在您提供的代码中，Rational构造函数代码没有真正意义-以下代码：

public Rational(int n, int d)
{
   n = TextLab05.num1;
   d = TextLab05.den1;    
}

应该看起来像这样：

public Rational(int n, int d)
{
   this.firstNum = n;
   this.firstDen = d;    
}

this.num = num1;
this.den = den1;

this.num = this.num * anotherRational.num;
this.den = this.den * anotherRational.den;

值n和d被传递给构造函数，然后在构造函数的主体中，实例变量firstNum和firstDen（在Rational类的私有部分声明，实际上“属于”正在创建的实例）将被初始化为值n和d

---

在Rational类主体内的任何地方，您都应该引用成员变量

firstNum

和

firstDen

，而不是不“属于”类实例的变量。

最重要的事情是理解这个概念。您将在

rational

类中存储一个有理数。执行此操作时：

Rational r1 = new Rational(num1,den1);

您正在创建一个

Rational

的单个实例，并将其命名为r1<代码>r1现在应该