相关疑难解决方法(0)

我正在研究用于SCJP测试的java语言.

理解"多态方法"有点难.

你能帮我解释一下吗？或者给我一些链接？

我正在处理Kattis 问题，在这里我应该以前缀表示法接受输入，将其简化并以前缀表示法返回它。这些是输入和输出的示例：

Sample Input 1                    Sample Output 1
+ 3 4                             Case 1: 7
- x x                             Case 2: - x x
* - 6 + x -6 - - 9 6 * 0 c        Case 3: * - 6 + x -6 - 3 * 0 c

我已经编写了这段代码，并且如果使用这种输入数据运行它，我将获得与上述完全相同的输出。但是，我从Kattis那里得到了错误的答案。

我在这里做错了什么？由于没有任何调试提示，这令人沮丧。

const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

const operators = ['+', '-', '*', '/'];
const operatorsFunctions = {
    '+': (a, b) => a …

班级:

type NotAbstract () = 
    member this.WithOptionalParameters (x, ?y) = 
        let y = defaultArg y 10
        x + y

具有以下类型签名:

type NotAbstract =
  class
    new : unit -> NotAbstract
    member WithOptionalParameters : x:int * ?y:int -> int
  end

但是,这不起作用:

[<AbstractClass>]
type AbstractExample () = 
    abstract WithOptionalParameters: int * ?int -> int /// Ouch...

type NotAbstract () = 
    inherit AbstractExample ()
    override this.WithOptionalParameters (x, ?y) = 
        let y = defaultArg y 10
        x + y

如何在带有可选参数的函数的抽象定义中编写正确的类型签名？我没有在这里找到任何暗示.

PS:我知道(类似的)结果可以通过多态实现

是否有一种设计模式、方法或语言可以让您编写超越嵌套 If 的复杂条件逻辑？

至少，这种问题有名字吗？我无法在这里或通过 Google 找到任何描述我试图解决的问题，而不仅仅是用 Switch 语句替换 IF 。

我正在使用脚本来生成一堆数据。作为其中的一部分，我想添加大量分支条件逻辑，这些逻辑应该提供多样性并阻止某些组合。

例如，如果用户是 A 组的一部分，那么他们就不能是 B 组的一部分，如果他们具有属性 C，那么这会将他们限制为特征 5 或 6，但不能低于或高于该特征。

我今天参加 Java 考试，考官问我是否可以提供在 Spring Boot 项目中使用多态性的示例。

由于我一开始想不出任何东西，他指出我在模型中重写了toString() ，这是动态/运行时多态性。

但是，我不确定我是否理解他的观点，因为根据我的理解，当我们有一个指向子类对象的父类引用变量（关注动态多态性）时，行为被认为是多态的。

然后在运行时，获取父类变量指向的实际对象并调用其方法，如此处很好地解释了。

但是，我在项目中没有使用向上转换（即使用 Object 类变量初始化 POJO 类）。

因此，我的问题是 -尽管父类（Object）从未用作引用变量，但重写 toString() 是否被视为多态？

我在 Stackoverflow 上找到的所有运行时多态性示例（包括此处的示例和带有toString 的示例）都说明了一种情况，即我们有一个父类变量指向子类对象，例如：

    Object object = new User("petar");
    String name = object.toString(); // assign to variable for clarity`s sake
    System.out.println(name);
    // prints petar

我的用户类别是：

public class User {

    String name;

    public User(String name) {
        this.name = name;
    }

    public String toString() {
        return name;
    }
}

然而，在我的项目中，我只是使用自己的引用变量创建用户和其他 POJO 类，例如：

    User user = …

我正在努力理解这个Koan:

@Koan
public void equalsMethodCanBeChangedBySubclassesToTestsIfTwoObjectsAreEqual() {
    Object object = new Integer(1);
    assertEquals(object.equals(object), true);
    assertEquals(object.equals(new Integer(1)), __);
    // Note: This means that for the class 'Object' there is no difference between 'equal' and 'same'
    // but for the class 'Integer' there is difference - see below
}

据我所知,因为object是Object类的一个实例,该.equals()方法尚未被覆盖,因此检查对象是否相等.

如果new Integer(1)创建一个新实例,那么它应该是一个单独的对象object.按照我的思路,正确的答案应该是false,但只有true通过.我逻辑中的缺陷在哪里？

编辑:我知道-128和127之间的整数是缓存的.如果我对该object对象的理解是正确的(如上所述),那么这是无关紧要的.

我知道这个问题已经在StackOverflow中完成,并且已经有很多问题已经发布.我可能已经阅读了它们中的每一个但是,有这个令人唠叨的疑问:我认为我理解重载很好,并且覆盖.让我变形的是多态性.

例如,这个问题的接受答案解释了这一点shape.Draw().我很困惑这与Overriding有什么不同(其他时候我对它与Overloading的不同之处感到困惑).

此外 - 多态性本质上是指从抽象类派生出来的吗？(我想我几乎所有关于这个主题的答案都使用了一个抽象的动物类,让一只猫和一只狗喵喵叫/吠:)

总之,我的问题是:

1. 什么是多态性wrt重载和覆盖？

2. 有人可以在没有抽象类的情况下解释多态性 - 谢谢!

3. 重载/覆盖不是多态的子类型,是吗？

编辑添加第3个问题并修改第2个问题.

这是我的示例代码:

String str = "hello";
Object obj = (Object)str;
System.out.println(obj.toString());

我找到了Object的源代码,toString()方法是:

public String toString() {   
   return getClass().getName() + "@" + Integer.toHexString(hashCode());
} 

我认为这个例子的结果是这个Object的地址,比如[B @ 15db9742,在我将str转换为Object之后,但它仍然打印你好.为什么？Shound not obj使用Object的方法？任何人都可以向我解释它的原理吗？

我有X类，它们具有不同的信息和计算方法，应该共享但可以覆盖，所以：

class Rule1 {
    int type = 1;
    string name = "Rule";
    public float Calc()
    {
        return 1 + 2 + type; // SAME
    }
}

class Rule2 {
    int type = 2;
    string name = "Rule2";
    public float Calc()
    {
        return 1 + 2 + type; // SAME
    }
}

class Rule3 {
    int type = 3;
    string name = "Rule3";
    public float Calc()
    {
        return 3 + 4 + type; // DIFFERENT
    }
}

我要在调用方法中编写的内容如下：

class Calculator
{ …

我对继承的理解非常基本。

我想创建一个基类，它实现IDisposable然后让其他具有功能的类从该基类继承，以便它们共享一个基类型。

它将允许我将每个对象放入一个列表中，以便我可以在需要清理时一次性处理所有内容。问题是，C# 中的类只能继承一次，否则只能使用接口。

现在，像Thread, 之类的类如何从我的基类继承而无需我重新编写Thread该类的基本代码？

这听起来可能很愚蠢，但简而言之：我想让已经存在的类继承我选择的基类，而不会失去其功能。（这样一个项目中使用的所有类都有一个共同的基础，总结为一种对象类型，例如List）

这甚至可能吗？

我想调用 FamilyCar 方法 Move()。如果 FamilyCar 是 LandVehicle，我想同时调用 LandVehicle Move() 方法。我正在寻找非常基本的方法来做到这一点。

基类

class LandVehicle : Vehicle
    {
        public override string Move()
        {
            return "Move on the wheels";
        }
    }

子类

class FamilyCar : LandVehicle
{
        public override string Move()
        {
            return "Pip pip!";
        }
}

我想知道为什么这是合法的:

Object mystring = "hello";
System.out.println(mystring);

这打印hello.但为什么Object会像字符串一样对待？