Question

我有这样的课

class Calculate {
    int operation(int a, int b){
         return Math.max(a,b);
    }
    int calc(int a, int b){
        int x=100+a*b;
        int y=a+a*b;
        retun operation(x,y);
    }
    int calc1(int a, int b){
        int x=100+a*b;
        int y=b+a*b;
        return operation(x,y);
    }
}

现在我将这个类的两个对象作为
Calculate obj1=new Calculate();
Calculate obj2=new Calculate();
我希望类计算的函数操作像obj1返回两个值的最大值，并返回obj2的两个值的最小值。可以这样做吗？
我只能想到创建两个不同的类Calculate1和Calculate2，并在Calculate1中将操作定义为最大值，在Calculate2中定义最小值，并将其定义为与其相同。我希望在没有定义两个类的情况下也可以使用一些更简单的方法。

Answer 1

您可以将操作作为an IntBinaryOperator传递给构造函数，例如：

<link href="https://cdn.jsdelivr.net/foundation/6.2.0/foundation.min.css" rel="stylesheet"/>
<div class="wrap">
  <div class="row">
<div class="small-6 medium-3 large-3 columns left-column">
  <ul>
    <li>One</li>
    <li>Two</li>
    <li>Three</li>
    <li>Four</li>
  </ul>
</div>
<div class="small-6 right-column medium-3 large-3 medium-push-6  columns">
  <p>RIGHT COLUMN - Aenean leo ligula, porttitor eu, consequat vitae, eleifend ac, enim. Aliquam lorem ante, dapibus in, viverra quis, feugiat a, tellus.</p>
  <p>Phasellus viverra nulla ut metus varius laoreet. Quisque rutrum.</p>
</div>
<div class="content medium-6 large-6 medium-pull-3 columns">
  <h2>Nam quam nunc blandit vel</h2>
  <p>Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim.</p>
  <p>Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis vitae, justo. Nullam dictum felis eu pede mollis pretium. Integer tincidunt. Cras dapibus. Vivamus elementum semper nisi. Aenean vulputate eleifend tellus.</p>
</div>
<div class="small-6 right-column large-3 columns">
  <p>RIGHT COLUMN - Aenean leo ligula, porttitor eu, consequat vitae, eleifend ac, enim. Aliquam lorem ante, dapibus in, viverra quis, feugiat a, tellus.</p>
  <p>Phasellus viverra nulla ut metus varius laoreet. Quisque rutrum.</p>
</div>
</div>

现在你可以写：

class Calculate {

  private final IntBinaryOperator op;

  public Calculate(IntBinaryOperator operator) {
    this.op = operator;
  }

  int operation(int a, int b) {
    return op.applyAsInt(a, b);
  }
}

添加操作很简单 - 比方说你想要总和而不是最小或最大：

Calculate c1 = new Calculate(Math::max);
Calculate c2 = new Calculate(Math::min);

Answer 2

您可以覆盖operation方法。

如果您不想创建显式子类，可以使用匿名类执行此操作：

Calculate obj1=new Calculate();
Calculate obj2=new Calculate() {
    int operation(int a, int b){
        return Math.min(a,b);
    }
};

obj1.operation(a,b) // calculates maximum
obj2.operation(a,b) // calculates minimum

Answer 3

您可以使用名为继承

的OOP概念

public abstract class Calculate {

    public abstract int operation(int a, int b);

    int calc(int a, int b){
        int x=100+a*b;
        int y=a+a*b;
        return operation(x,y);
    }

    int calc1(int a, int b){
        int x=100+a*b;
        int y=b+a*b;
        return operation(x,y);
    }

}

class Obj1 extends Calculate{

    @Override
    public int operation(int a, int b) {
        return Math.min(a, b);
    }

}

class Obj2 extends Calculate{

    @Override
    public int operation(int a, int b) {
        return Math.max(a, b);
    }

}

每个新类都实现自己的操作方法。

Answer 4

你可以这样：

interface Operation
{
    int operation(int a,int b);
}
class Calculate
{
    Operation operation;
    //rest of class
}

你使用这样的类：

Calculate obj1=new Calculate();
obj1.operation=(a,b)->Math.max(a,b);
Calculate obj2=new Calculate();
obj2.operation=(a,b)->Math.max(a,b);

几个笔记：

您可以添加一个构建器，该Operation初始化operation变量。
您应该在call课程中使用Calculate方法并将operation设为私有，以便更好地进行封装
operation可能最好成为最终
这个解决方案可能不如其他语言那么直接，但它是我能做到的最好的从一开始就支持函数作为一等公民的语言会使这更容易，因为你可以拥有一个函数变量，你可以像任何变量一样分配，传递，返回。

在java中我们必须使用接口和匿名类来支持它，上面的lambda表达式被添加到java 8中，所以对于java 7，我们会像这样编写上面的内容：

Calculate obj1=new Calculate();
obj1.operation=new Operation{
                   @Override
                   int operation(int a,int b)
                   {
                       return Math.max(a,b);
                   }
               }
//code for obj2

修改

您可以将Operation替换为java 8中引入的functional interfaces（具体为IntBinaryOperator）。

Answer 5

您可以使用strategy pattern来实现目标。

基本上，您希望将operation外部化到接口，并在Calculate的构造函数中指定实现接口（使用min或max）的对象。

这种方法为您提供了最灵活的解决方案，可以证明需求的变化。

Answer 6

您可以按如下方式修改课程：

class Calculate {
    private boolean calcMax;

    public Calculate(boolean calcMax){
        this.calcMax = calcMax;
    }

    int operation(int a, int b){
         return calcMax ? Math.max(a,b) : Math.min(a,b);
    }
}

Answer 7

public class Calculate {

public int a=0;
public int b=0;

public int maxVal = 0;
public int minVal = 0; 

public Calculate(int a, int b){
    this.a=a;
    this.b=b;

    this.maxVal=Math.max(a,b);


    this.minVal = Math.min(a, b);

}
}

假设您正在找到相同变量的分钟和最大值......

以不同方式重用相同的功能

7 个答案:

几个笔记：

修改