小编Mun*_*lam的帖子

我在我的重载方法书中找到了两个例子,但它没有清楚地解释为什么它有用:

package keepo;
public class Main{
    public static void main(String [] args)
    {
        int newScore = calculateScore("Tim", 500);
        System.out.println("New Score is" + newScore);
        calculateScore(75);

    }
    public static int calculateScore(String playerName, int score){
        System.out.println("Player" + playerName +"Has score" + score);
        return score * 1000;
    }
    public static int calculateScore(int score){
        System.out.println("Unnamed player scored" + score + "points");
        return score * 1000;
    }
}

这非常简单,但老实说,这里的方法重载似乎没用,而且它似乎只是为了做到这一点.

本书中的下一个示例实现了方法重载,这似乎更有用,因为该程序计算英尺到厘米,有一种方法可以放入英尺和英寸,还有一种方法可以放英寸.但是,为此制作两个单独的方法似乎同样容易.

话虽如此,这样做有什么好处吗？(我读过这篇文章,但我并不满意.制作新方法似乎同样容易.)

目前我正在关注一本书并且非常困惑,并且多次尝试了解以下代码.我的第一个困惑实际上是接近比较两个对象a和b的问题.

 function deepEqual(a, b) {
  if (a === b) return true;

  if (a == null || typeof a != "object" ||
      b == null || typeof b != "object")
    return false;

  var propsInA = 0, propsInB = 0;

  for (var prop in a)
    propsInA += 1;

  for (var prop in b) {
    propsInB += 1;
    if (!(prop in a) || !deepEqual(a[prop], b[prop]))
      return false;
  }

  return propsInA == propsInB;
}

var obj = {here: {is: "an"}, …

(http://eloquentjavascript.net/07_elife.html)

我很难理解我们添加的网格方法.get和.set甚至可以.首先,让我们来看一个示例案例. var grid = new Grid(5,5); 现在,space是一个25元素数组.当然width还有height are5.

现在的问题是"获取"的方法是什么.

现在我们说 console.log(grid.get(new Vector(1, 1)));.

所以x成为1,y成为1在我们创建新的对象.当然我们需要做grid.get因此我们返回,this.space[1+ 1 * 5]即空间数组中第6个点是25元素long.那为什么这个打印未定义？是因为空间数组中没有任何东西吗？

TLDR

原型.get和.set原型如何在这里工作(他们做了什么)？为什么我们设置 return this.space[vector.x + this.width*vector.y];,是否有一些数值意义vector.x+this.width*vector.y？

    function Vector(x,y){
        this.x = x;
        this.y = y;
    }

    Vector.prototype.plus = function(other){

        return new Vector(this.x + other.x, this.y + other.y);
    }


    var grid = ["top left",    "top middle", …

我正在读我的红宝石书.看下面的代码,

module Destroy
  def destroy(anyObject)
    @anyObject = anyObject
    puts "I will destroy the object: #{anyObject}"
  end
end

class User
  include Destroy
  attr_accessor :name, :email
  def initialize(name,email)
    @name  = name
    @email = email
  end
end

my_info = User.new("Bob","Bob@example.com")
puts "So your name is: #{my_info.name} and you have email #{my_info.email}"

user = User.new("john","john@example.com")
user.destroy("blah")

我可以在我的课堂上创建另一种方法.我为什么要这样做？我为什么要使用模块？将其嵌入到其他类中并不比仅使用普通继承更容易.

嗨,目前我在本书的第5章,我们研究了if陈述,以及.equals其他一些基本的东西.我注意到在我的所有问题和本书的例子中,我们通常倾向于将if语句放在类中的那些方法中.这是我做的一个练习,虽然没有完全完成,但图片很清晰.我只是要求用户在某些单位之间进行转换.但是当我在思考如何处理这个问题时,我不想在我的方法中使用if语句,因为我希望if语句是关于用户输入的,而且根据我的知识,我们应该总是把它Scanner放在主要的(井)这是我们迄今为止一直在做的事情).而且因为我无法从主要使用if的主要语句中访问那些扫描仪.

这是不好的做法,还是一般情况下做任何事情都会更好？如果我们在那里放太多东西,我可以在大型程序中看到主要变得丑陋.我只在下面编写了一个测试用例,但你可以看到如果我做了其他组合会有多难看.

继承我的代码

import java.util.Scanner;
class Conversion{
    public double mmToCm(double value){
        value = value / 10.0;
        return value;
    }
    public double cmToMm(double value){
        value = value * 10.0;
        return value;
    }
    public double cmToMeter(double value){
        value = value / 100.0;
        return value;
    }
    public double meterToCm(double value){
        value = value * 100.0;
        return value;
    }
    public double mmToMeter(double value){
        value = value / 1000.0;
        return value;
    }
    public double meterToMM(double …

昨天我刚开始学习接口，一直在做一些简单的例子，我注意到我在理解类和接口之间的转换时遇到了很多麻烦，所以我阅读了Java Cast Interface to Class以及Interfaces Oracle Java Tutorials

但是当我的书在底部给出了一个小小的评论问题时，我发现我仍然没有完全理解，而且我买的书没有解决方案。以下是问题（我给出了我的尝试和推理，这对某些人来说可能是错误的，所以任何帮助都是好的！）

假设 Sandwich 类实现了 Edible 接口，并且你得到了变量声明

Sandwich sub = new Sandwich();

Rectangle cerealBox = new Rectangle(5, 10, 20, 30); 

Edible e = null;

以下哪些赋值语句是合法的？

1. e = sub;

   由于 Sandwich 类实现了 interface Edible，所以这没有问题。我们可以说e = sub没有问题。有用

2. sub = e;

   由于我们试图sub将Sandwitch类中的对象更改为interface类型，因此不进行强制转换就无法做到这一点。它不会工作

3. sub = (Sandwich) e

   有效！这解决了我们的老问题

4. sub = (Sandwich) cerealBox;

   我不知道..但它应该工作吗？ cerealBox是Rectangle这样，(Sandwich)我们将其转换为sub，这是 …

假设我们有

b = {"b"=>"c"}

通过这样做b.invert我们可以很容易地获得结果

{"c"=>"b"}

那是我想要尝试一些非常酷的东西的时候.假设我们有

a = {"a"=>{"b"=>"c"}}

什么是一种相当有效的方法来实现这一目标{{"c"=>"b"}=>"a"}(在这里,我们扭转最内在hash并努力实现这一目标)

当然,最好将其扩展到n彼此之间的哈希量.我一直在寻找其他类似的问题,但没有找到任何问题.

谢谢.

我的书说局部变量和实例变量之间的关键区别之一是我们必须初始化局部变量,0如果你没有初始化它们,实例变量会得到一个默认值.在此之前不久我做了一个例子介绍构造函数,什么public void和public double和 return做的.

请考虑以下我在本书中所做的示例.这里的平衡是一个实例variable.我们下面有两个构造函数.如果实例变量的默认值为零,为什么我需要第一个构造函数

public Account(){
        balance = 0;    
    }

说如果我打电话的话Account acc = new Account(); balance = 0.它不会自动变为零吗？至少这是我对本书的理解

下面是我正在处理的完整代码

public class Account {
    private double balance;
    public Account(){
        balance = 0;    
    }
    public Account(double initialBalance){

        balance = initialBalance;
    }
    public void deposit(double amount){
        balance = balance+amount;
    }

    public void withdraw(double amount){
        balance = balance-amount;
    }

    public double getBalance(){
        return balance;
    }   
}



public class Test {
public static …

刚刚开始学习java,在我的教科书中我遇到的一this开始很混乱,但现在开始有意义了.现在,在我的书中,我们开始构造函数的基本应用程序,并在它所说的页面上作为旁注this,也可以用来调用其他构造函数.我有点困惑,然后看看关于SO的其他问题this.我想我现在已经达到了一定程度,但为什么我会想要这样做呢？考虑一下我刚刚编写的以下内容.

private double balance;
private double interest;
public Account(double initialBalance){
    balance = initialBalance;

}
public Account(double balance, double interest){
    this(0);
    balance = initialBalance;
    this.interest = interest;
}

在这里this(0);,据我所知,寻找另一个带有一个参数,找到Account(double initialBalance)并设置initialBalance为零的构造函数.大.嗯,但为什么我不直接这样做呢？只需将余额设为零即可!我相信它非常有用,但我想不出任何例子.谢谢!