Java初学者:类和方法

时间:2012-12-27 18:18:24

标签: java

我是菜鸟,Java是我的第一个编程语言。 我有这个问题,我正在努力解决:

  

定义一个类来表示以三个为特征的糖碗糖   东西:总容量(克),可用数量和数量   勺子(多少克糖与勺子相关   它)。在这个课程中设置:

     
      
  1. 创建糖碗的构造方法。
  2.   
  3. 一种可以知道糖碗中糖含量的方法。
  4.   
  5. 一种方法,可以知道一勺糖需要多少。
  6.   
  7. 一种方法,给定一些勺子,去掉相应数量的糖,然后返回这个值。
  8.   
  9. 添加糖的方法。如果提供的值超出可用空间,则糖碗应该已满,剩余量   回。在其他情况下,应该返回零。
  10.         

    将班级RunSugarBowl设为主要游戏。   

public class SugarBowl {

    private int totalCapacity;
    private int availableSpace;
    private int spoonSize;
    private int occupiedSpace = totalCapacity-availableSpace;//is the same as amount of sugar in the bowl.

    SugarBowl (int totalCapacity){
        availableSpace=totalCapacity;
        spoonSize = totalCapacity/20;//arbitrary size
    }

    public int spoon(){
        return spoonSize;
    }

    public int occupied(){
        return occupiedSpace;
    }

    public void scoops (int numberOfScoops){
        int amountTaken = numberOfScoops * spoonSize;
        if (amountTaken<=occupiedSpace){
            occupiedSpace=occupiedSpace-amountTaken;
            System.out.println(amountTaken);}
        else{
            System.out.println("There's not that amount of sugar in the sugar bowl. Try less.");}       
    }
    public int addSugar (int addedAmount){
        if (addedAmount>availableSpace){
            int remainingAmount=addedAmount-availableSpace;
            availableSpace=0;
            occupiedSpace = totalCapacity-availableSpace;
            return remainingAmount;}
        else{
             availableSpace = availableSpace - addedAmount;
             occupiedSpace = totalCapacity-availableSpace;
                return 0;}
    }
}

我的问题现在是我的one.occupied方法返回0而不是200

public class RunSugarBowl {
    public static void main(String[] args) {
        SugarBowl one = new SugarBowl(200);
        one.addSugar(300);
        System.out.println("Occupied size is : "+ one.occupied());
    }
}

6 个答案:

答案 0 :(得分:3)

遗憾的是,您的代码错误。你应该改变这个功能

    public void addSugar (int addedAmount){
    if (addedAmount>availableSpace){
        int remainingAmount=addedAmount-availableSpace;
        System.out.println("Sugar bowl completely full. You got left: "+ remainingAmount);}
    else{
        System.out.println("0");}
}

public void addSugar (int addedAmount){
    if (addedAmount>availableSpace){           
        System.out.println("Sugar bowl completely full. You got left: "+ remainingAmount);}
    else{
        availableSpace = availableSpace - addedAmount; //this ensures available space changes after you add sugar
        occupiedSpace = totalCapacity-availableSpace; // you must also write this to change the ocuuppied space too
        System.out.println(availableSpace);
    }
}

因为你构造了200容量的糖碗,并在以后添加100。所以

if (addedAmount>availableSpace) 

100&gt; 200返回false并直接进入else块,该块只打印出'0'。这是您犯的逻辑错误。但不要担心我们都去过那里;)

其实这一行     occupiedSpace = totalCapacity-availableSpace;  是必不可少的     availableSpace = availableSpace - addedAmount; 因为您使用 occupiedSpace 作为属性。你在类的开头写的公式只执行一次,当你调用构造函数时(最初两个值都是0,因为它们是原始的int)而 occupiedSpace 保持为 0 除非你用其他函数调用更改它。

但是如果你想在每次需要时计算 occupSpace availableSpace ,你应该删除其中一个,因此你只需要另一个和<强> totalCapacity 即可。可以通过从 totalCapacity 中减去一个来计算其他一个。如果我是你,我会用

public int getOccupiedSpace(){
return totalCapacity-availableSpace;
}

而不是使用(在你的情况下使用的方式)

private int occupiedSpace = totalCapacity-availableSpace;

这是相同的

private int occupiedSpace = 0;

private int occupiedSpace ;

答案 1 :(得分:2)

首先,就像提示一样,添加方法标题非常有用,这样您就可以知道您的方法正在尝试做什么。 Aka,如果你看一下你的规格,你的许多方法都要求你“知道多少......”所以这些方法应该返回一个数字,而不是立即打印出来的东西(当我开始编码时我犯了同样的错误)。

您正在方法中打印出这些数字(这对调试很有用,但不是您的成品应该做的事情)。您可以返回一个int,然后在RunSugarBowl中打印出该整数(见下文)。

我已经为您提供了一个通用框架,并提供了一些可能对您有所帮助的评论。你开始做得很好。如果您有更多问题,请在评论中提问。

public class SugarBowl {
    private int totalCapacity;
    private int availableSpace;
    private int spoonSize;
    private int occupiedSpace;//starts at 0, because there's nothing in the bowl.

    /**
     * Constructor for the sugar bowl.
     * @param totalCapacity     The total capacity of the bowl.
     */
    public SugarBowl (int totalCapacity){
        this.totalCapacity = totalCapacity; //set the totalCapacity for the bowl
        availableSpace=totalCapacity;
        spoonSize = totalCapacity/20;//arbitrary size
        occupiedSpace = 0;
    }
    /**
     * Shows how much sugar can fit in a spoon.
     * @return  The size of the spoon
     */
    public int spoon(){
        return spoonSize;
    }
    /**
     * Returns amount of sugar in the bowl.
     * @return  The amount of occupied space
     */
    public int occupied(){
        return occupiedSpace;
    }
    /**
     * Removes the amount of sugar based on the
     * number of scoops passed into it.
     * @param numberOfScoops    The number of scoops
     * @return          The amount of sugar removed
     */
    public int scoops (int numberOfScoops){

        int possibleAmountTaken = numberOfScoops * spoonSize;
        int actualAmountTaken = 0;
        //Think about sugar, even if there is less sugar than the spoon size, 
        //can a spoon still remove that amount?
        //aka the only time 0 sugar should be taken is when there is 0 sugar in the bowl
        if (possibleAmountTaken<=occupiedSpace){
            actualAmountTaken = possibleAmountTaken;
        }
        else{
            //there may still be sugar, just not enough for every scoop, you still have to remove it
            //actualAmountTaken = ???
        }
        occupiedSpace = occupiedSpace - actualAmountTaken;
        //what about availableSpace?
        //availableSpace = ???
        return actualAmountTaken;       
    }
    /**
     * Adds the specified amount of sugar to the bowl.
     * 
     * @param addedAmount   The amount of sugar added to the bowl
     * @return  The overflow amount of sugar or 0 if there was no overflow
     */
    public int addSugar (int addedAmount){
        int overflow = 0;
        if (addedAmount>availableSpace){
            overflow = addedAmount-availableSpace;
            //your bowl is going to be full, what happens to occupiedSpace and availableSpace?
            //availableSpace = ???
            //occupiedSpace = ???
        }
        else{
            //overflow is already 0 so you don't have to do anything with it
            //update availableSpace and occupiedSpace
            //availableSpace = ???
            //occupiedSpace = ???
        }
        return overflow;
    }
}

使用上面的主要示例:

public class RunSugarBowl {
    public static void main(String[] args) {
        SugarBowl one = new SugarBowl(200);
        System.out.println("Sugar overflow: " + Integer.toString(one.addSugar(300))); //once working correctly should print out 100 for the overflow
        System.out.println("Occupied size is : "+ one.occupied());
    }
}

<强>更新

您使用this.totalCapacity的原因是由于以下代码行:

public class SugarBowl {
    private int totalCapacity; //totalCapacity for this object; aka this.totalCapacity refers to this variable
    //..

    public SugarBowl (int totalCapacity){ // <-- totalCapacity passed in
        this.totalCapacity = totalCapacity; //this.totalCapacity is setting the totalCapacity for this instance of the object to the value passed in
        //..

注意你的构造函数是如何在一个名为“totalCapacity”的变量中传递的,但该类也有自己的内部变量,名为totalCapacity。没有“this”关键字的可比代码如下:

public class SugarBowl {
    private int bowlTotalCapacity; //totalCapacity for this object
   //..

    public SugarBowl (int totalCapacity){ 
        bowlTotalCapacity = totalCapacity;
        //..

您必须确保在初始化之后,无论您以前使用过totalCapacity,都要将其更改为bowlTotalCapacity。使用this.totalCapacity可以更容易地引用此类中的totalCapacity。请查看此处了解更多信息:http://docs.oracle.com/javase/tutorial/java/javaOO/thiskey.html

从技术上讲,在最初构造对象后,你实际上并没有再次使用totalCapacity,但是如果你想看到如果你不包含这个部分会发生的怪异,试着去理解下面代码中会发生什么: / p>

public class ThisExample {
    private int wrongExample = 0;
    private int thisExample = 0;

    public ThisExample (int wrongExample, int thisExample){
        wrongExample = wrongExample;
        this.thisExample = thisExample; 
    }

    public int getThisExample(){
        return thisExample;
    }
    public int getWrongExample(){
        return wrongExample;
    }
}

运行以下内容可以帮助您更好地理解:

public class ThisExampleMain {
    public static void main(String[] args) {
        ThisExample ts = new ThisExample(50, 50);
        //you want this to be 50 but it ends up being 0:
        System.out.println("Wrong: " + ts.getWrongExample());
        //this returns the correct answer:
        System.out.println("Right: " + ts.getThisExample());
    }
}

答案 2 :(得分:2)

规范要求的addSugar方法应该返回一个int: addSugar方法还应该同时更新availableSpace和occupiedSpace。

在main中你正在调用one.occupied()方法,但你没有对该值做任何事情,也许你想打印它来看它。

以下是您的addSugar方法和主要方法。

public int addSugar (int addedAmount){
    if (addedAmount>availableSpace){
        int remainingAmount=addedAmount-availableSpace;
        return remainingAmount;
        }
    else
        {
            availableSpace = availableSpace - addedAmount;
            occupiedSpace = occupiedSpace + addedAmount;
        return 0;
        }
}

public class RunSugarBowl {
public static void main(String[] args) {
    SugarBowl one = new SugarBowl(200);
    System.out.println("The occupied Space is: " + one.occupied());
    System.out.println("The addSugar() method is returning " + one.addSugar(300));
    System.out.println("The occupied Space now is: " + one.occupied());
}

}

答案 3 :(得分:1)

您的main方法调用方法但不使用从这些方法返回的值。 您应该按如下方式更改main方法。

public class RunSugarBowl {
    public static void main(String[] args) {
        SugarBowl one = new SugarBowl(200);
        System.out.println("Occupied size is : "+ one.occupied());
    }
}

按如下方式更改addSugar()方法。

    public void addSugar (int addedAmount){
        if (addedAmount>availableSpace){
            int remainingAmount=addedAmount-availableSpace;
            availableSpace=0;
//Update occupiedSpace here.

            System.out.println("Sugar bowl completely full. You got left: "+ remainingAmount);}
        else{
             availableSpace = availableSpace - addedAmount; //this ensures available space changes after you add sugar
                System.out.println("I added "+addedAmount + "to the bowl");
// Update occupiedSpace here.


    }
    }

当您添加糖时,您没有更新您的occupSpace字段。这就是它始终保持相同的原因。

答案 4 :(得分:0)

你应该替换

sugarBowl (int totalCapacity){
    availableSpace=totalCapacity;
    spoonSize = totalCapacity/20;//arbitrary size
}

通过

public SugarBowl (int totalCapacity){
    availableSpace=totalCapacity;
    spoonSize = totalCapacity/20;//arbitrary size
}

答案 5 :(得分:0)

您可以将main()方法添加到sugarBowl课程中。您不需要单独的类来运行它。

我会修改你的主要内容:

public class RunSugarBowl {
    public static void main(String[] args) {
        sugarBowl one = new sugarBowl(200);
        one.occupied();
        one.addSugar(100);
        }
}

或者您可以将您的类及其构造函数重命名为SugarBowl。我建议使用第二个,因为它与Sun Java编码标准一致。