Question

我正在创建一个需要3个输入的程序 - 以克为单位的黄金数量，以克为单位的银币和金额并计算其总价值。在另一个计算所有3个总数的类中，如何调用字段？

我尝试创建一个对象但失败了，感谢您的帮助。这是我的代码。

import java.util.Scanner;

public class Calculator {

       public static void main(String[] args) {



            System.out.print("------------------:");
            System.out.print("Calculator : ");
            System.out.println("--------------------");


            System.out.println("Exchange rate of gold : 165.7 RM/g");
            System.out.println("Enter the amount of Gold:  ");
            Gold goldObject = new Gold();
            goldObject.Gold1();

            System.out.println("Exchange rate of silver: 2.12 RM/g");
            System.out.println("Enter the amount of Silver:  ");
            Silver silverObject = new Silver();       
            silverObject.Silver1();

            System.out.println("Enter the amount of cash: ");
            Money moneyObject = new Money();
            moneyObject.Money1();


   }
}

金级：

import java.util.Scanner;
public class Gold{
     public static void Gold1() {
         Scanner in = new Scanner(System.in);
         double goldgram = in.nextDouble();
         double grate = 165.7;
         double gvalue = goldgram*grate;
         System.out.println("Value of gold in cash :" + gvalue);         
     }
}

银级：

import java.util.Scanner;
public class Silver {
     public static void Silver1() {
         Scanner in = new Scanner(System.in);
         double silvergram = in.nextDouble();
         double srate = 2.12;
         double svalue = silvergram *srate;
         System.out.println("Value of silver in cash :" + svalue);
     }

}

金钱类

import java.util.Scanner;
public class Money {
    public static void Money1() {
         Scanner in = new Scanner(System.in);
         double mvalue = in.nextDouble();
         System.out.println("Amount of money :" + mvalue);
     }
}

总课程

    public class total{
    public static double total1(double total) {
        ;
        total = gvalue+svalue+mvalue;
    }

}

Answer 1

有许多方法可以解决您的问题：

方式1 ：

让静态函数返回double类型值并将它们分配给变量。在您的情况下，您的一个静态函数将是：

import java.util.Scanner;
public class Money {
    public static double Money1() {
         Scanner in = new Scanner(System.in);
         double mvalue = in.nextDouble();
         System.out.println("Amount of money :" + mvalue);
         return mvalue;
     }
}

在你的主要：

// lines of code
// ...
double mvalue = moneyObject.Money1();
// ...

当您对 gold 和 silver 类进行这些更改时，您应该拥有以下变量：

mvalue
g值
S值

然后您可以在修改其标题后将它们传递给 total 函数，以便接受参数，因此它将变为：

public static double total1(double gvalue, double svalue, double mvalue) {
        total = gvalue+svalue+mvalue;
        return total;
}

并从您的主电话中拨打：

total.total1(gvalue,svalue,mvalue);

但是，这并不是最好的方式。

方式2 ：

将属性附加到每个类并通过setters and getters访问它们。

Answer 2

定义模型：

public final class Purchase {
    private double gold;
    private double silver;
    private double money;
}

使用给定的Calculator定义带有所有计算逻辑的Purchase clas，并使用计算操作分别输入/输出操作：

public final class Calculator {
    private static final double GOLD_RATE = 165.7;
    private static final double SILVER_RATE = 165.7;

    public double goldValue(Purchase purchase) {
        return purchase.getGold() * GOLD_RATE;
    }

    public double silverValue(Purchase purchase) {
        return purchase.getSilver() * SILVER_RATE;
    }

    public double totalWorth(Purchase purchase) {
        return goldValue(purchase) + silverValue(purchase) + purchase.getGold();
    }

    private static Purchase createPurchase(Scanner scan) {
        Purchase purchase = new Purchase();

        System.out.print("------------------:");
        System.out.print("Calculator : ");
        System.out.println("--------------------");


        System.out.println("Exchange rate of gold : 165.7 RM/g");
        System.out.println("Enter the amount of Gold:  ");
        purchase.setGold(scan.nextDouble());

        System.out.println("Exchange rate of silver: 2.12 RM/g");
        System.out.println("Enter the amount of Silver:  ");
        purchase.setSilver(scan.nextDouble());

        System.out.println("Enter the amount of cash: ");
        purchase.setMoney(scan.nextDouble());

        return purchase;
    }

    public static void main(String... args) {
        Purchase purchase = createPurchase(new Scanner(System.in));
        Calculator calc = new Calculator();
        double totalWorth = calc.totalWorth(purchase);
        System.out.println("Total worth is " + totalWorth);
        // PS: using double is not correct for money!!!
    }
}

注意!!! 在财务中使用double值严格禁止 !!!!

Answer 3

我猜你在这一行得到了错误

Money moneyObject = new Money();

这是因为没有名为Money的类，您只定义了类money，区分大小写

这是一回事，第二个是所有变量都在各个方法中声明，因此它们的范围在方法之后死亡，因此在方法执行后这些变量将无法使用。

因此goldgram，grate，gvalue等变量在Calculator和Total等类中无法使用编译时错误。

根据您获得个人总金额的金/银的金额和金额，我想知道您为什么需要这个Total课程。

以下是有关如何通过OOP实现的示例

首先我们将一个类定义为Ornament，它可以代表Gold，Silver，Platinum，Diamond等。这仅用于定义实体，不需要在此处保留任何计算，以便当某些读取具有清晰时关于Ornament的想法，它有什么和所有属性如何被访问。

class Ornament {
    private double amount;
    public double getAmount() {
        return amount;
    }
    public void setAmount(double amount) {
        this.amount = amount;
    }
}

在Ornament中看到我们有一个属于类的属性amount，无法直接访问。这就是我们保留公共方法来设置和获取amount（设置者和获取者）的原因，通过这种方法我们可以访问该属性。就像你有很多衬衫你的财产（类属性如金额），但外面没有人知道有多少（私人给你），但你每天穿的衬衣越多。您的行为是在您的私有属性上定义的（行为只是Java中的方法）。

所以这样你就可以在类本身内部保存类的数据，这个数据被称为Encapsulation（访问它们的私有属性和公共方法）。

现在我们将类Gold和Silver定义为Ornament的子类，以便它们继承Ornament的属性。

class Gold extends Ornament {
    static double currentRate = 165.7;
}

class Silver extends Ornament {
    static double currentRate = 2.12;
}

Ornament中的方法将继承到Gold和Silver。现在关于currentRate，为类定义的静态对于该类的每个对象都是通用的。它们没有被封装在一个对象中。就像大学的每个学生对象都有相同的大学名称一样，因此可以保留为static。加载类时，static变量加载其默认值，并且只加载一次类。每次创建对象时都会加载非静态（实例）变量。

现在我们定义一个类来定义计算的业务逻辑

class AmountCalculator {
    public double finalAmount(Gold gold, Silver silver) {
        double total = 0.0;
        if(gold != null) {
            total += gold.getAmount() * Gold.currentRate;
        }
        if(silver != null) {
            total += silver.getAmount() * Silver.currentRate;
        }
        return total;
    }
}

有一个方法，它将Gold和Silver的对象（实例）作为参数。如果存在Gold，则根据费率和金额计算黄金价格，Silver也一样。

然后我们定义一个执行类

public class GoldSilverRates {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter amount of Gold purchased in grams : ");
        double goldInGrams = sc.nextDouble();
        Gold gold = new Gold();
        gold.setAmount(goldInGrams);

        System.out.print("Enter amount of Silver purchased in grams : ");
        double silverInGrams = sc.nextDouble();
        Silver silver = new Silver();
        silver.setAmount(silverInGrams);

        AmountCalculator calculator = new AmountCalculator();
        System.out.print("Total bill : " + calculator.finalAmount(gold, silver));
    }
}

Answer 4

最简单的方法是在类中使用gvalue，svalue，mvalue作为静态成员。然后使用“类名”访问成员。“成员名称”。

public class Money {
     public static double  mvalue;
     public static void Money1() {
     Scanner in = new Scanner(System.in);
     mvalue = in.nextDouble();
     System.out.println("Amount of money :" + mvalue);
 }

}

总课程：

Gold.gvalue + Silver.svalue + ...

从Java中的其他类调用变量

4 个答案: