blocks|key|216609|text|这是通过使用最简单的方法来测试您的设计模式。我认为这可能是策略(或其他一些行为模式)。请参阅以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|216610|http://en.wikipedia.org/wiki/Strategy_pattern|offset|length|216611|http://en.wikipedia.org/wiki/Behavioral_pattern|216612|如果你要去参加Java面试，你应该能够识别出他们所暗示的设计模式，这应该可以防止你过于不安！|216613|要回答这个问题，请根据需要创建两个实现MathFunction的类，然后创建两个实例并将它们存储在functionList中。|style|CODE|216614|这里的重点不是“你能用这种奇怪的方式做计算吗”，而是“你能识别出设计模式吗”。|216615|entityMap|0|LINK|mutability|MUTABLE|url|1^0|0|0|19|0|0|0|1B|1|0|0|J|C|1D|C|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@$D|Z|E|10|1|11]]|A|$]]|$1|F|3|G|5|6|7|12|8|@]|9|@$D|13|E|14|1|15]]|A|$]]|$1|H|3|I|5|6|7|16|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|17|8|@$D|18|E|19|L|M]|$D|1A|E|1B|L|M]]|9|@]|A|$]]|$1|N|3|O|5|6|7|1C|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|C]]|W|$5|S|T|U|A|$V|G]]]]

This is testing your design patterns, by using the simplest possible method. I think this could be the Strategy (or some other behavioural pattern). See these:

<a href="http://en.wikipedia.org/wiki/Strategy_pattern" rel="noreferrer">http://en.wikipedia.org/wiki/Strategy_pattern</a>

<a href="http://en.wikipedia.org/wiki/Behavioral_pattern" rel="noreferrer">http://en.wikipedia.org/wiki/Behavioral_pattern</a>

If you are going for a Java interview, you should be able to identify the design pattern they are hinting at and that should prevent you from being too unsettled! 

To answer the question, create two classes that implement <code>MathFunction</code> as required, then create two instances and store them in <code>functionList</code>.

The point here is not 'can you do calculations in this strange way', it is 'can you identify design patterns'.

blocks|key|3076187|text|虽然我同意这可能不是最好的方法，或者大多数面向对象的方法，但我不得不假设这个练习的重点是看看你对继承、接口和匿名内部类的理解有多好。这是我唯一能想到的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3076188|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

While I agree that this probably isn't the best way, or most OO way to do this, I would have to assume that the point of this exercise is to see how well you understand Inheritance, Interfaces and maybe anonymous inner classes. That's the only thing I can figure.

blocks|key|3076215|text|IMHO，这确实是一种奇怪的方法。名称Solver是泛型的，默认情况下它不应该实现特定的操作。然而，也许这是面试的一部分？第一部分:简单地满足请求。第二部分:说这样做很奇怪。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3076216|我想说的是，一种更好的方法是使用addMathFunction(MathFunction+mf)方法。如果需要，还可以创建扩展Solver类的子类，并在它们的构造函数中添加MathFunctions。|3076217|entityMap^0|J|6|0|G|W|1R|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

IMHO, it is indeed a strange approach. The name <code>Solver</code> is generic, it shouldn't implement specific operations by default. However, maybe that was part of the interview? Part one: simply fulfill the request. Part two: say that it is strange to do so.

I would say that a much nicer approach would be to have an <code>addMathFunction(MathFunction mf)</code> method. And if wanted, to create subclasses that extend the <code>Solver</code> class and add MathFunctions in their constructor.

blocks|key|213768|text|我想他们想让你在函数列表中添加两个项目。每一个都将实现MathFunction接口，一个用于平方根，另一个用于倒数。问题在于细节：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|213769|1-你有一个函数返回2个值，因为它做了两件不同的事情，这是不好的|213770|2-如果你想拥有这个"+do+-+it+-all“类，接收MathFunctions作为参数会很有趣，这样你就可以做任何类型的函数，Mathfunctions将是可参数化的|213771|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I think they wanted you to add two items in the functionlist. Each one would implement the MathFunction interface, one for the square root and one for the inverse.
The prboblem lies in the details:

1- You have a function which returns 2 values because it does two different things, that is bad

2- If you want to have this "do-it-all" class,m it would be interesting to receive the Mathfunctions as a parameter so you can do any sort of MathFunctions, the MathFunctions would be parameterizable

blocks|key|213773|text|这是我的解决方案。这是一个简单的factory+class示例。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|213774|public+Solver()+{+
++++functionList+=+new+ArrayList<MathFunction>();
++++MathFunction+sqrt+=+new+MathFunction()+{
++++++++@Override
++++++++public+double+calculate(double+x)+{
++++++++++++return+Math.sqrt(x);
++++++++}

++++};
++++functionList.add(sqrt);
++++MathFunction+inverse+=+new+MathFunction()+{
++++++++@Override
++++++++public+double+calculate(double+x)+{
++++++++++++return+1.0D+/+x;
++++++++}

++++};
++++functionList.add(inverse);
}|code-block|syntax|javascript|213775|这个问题说明了两件事：|213776|213777|程序员是否理解像inverse.|unordered-list-item|213778|Whether这样的数学术语程序员知道接口或类的实例可以存储在列表中，并在以后迭代。|213779|213780|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Factory_method_pattern^0|G|D|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|F|7|13|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|14|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|15|8|@]|9|@]|C|$]]|$1|L|3|M|5|N|7|16|8|@]|9|@]|C|$]]|$1|O|3|P|5|N|7|17|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|C|$]]|$1|R|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|S|$T|$5|U|V|W|C|$X|Y]]]]

Here's my solution. This is a simple illustration of a <a href="http://en.wikipedia.org/wiki/Factory_method_pattern" rel="nofollow">factory class</a>.

<pre><code>public Solver() { 
 functionList = new ArrayList&lt;MathFunction&gt;();
 MathFunction sqrt = new MathFunction() {
 @Override
 public double calculate(double x) {
 return Math.sqrt(x);
 }

 };
 functionList.add(sqrt);
 MathFunction inverse = new MathFunction() {
 @Override
 public double calculate(double x) {
 return 1.0D / x;
 }

 };
 functionList.add(inverse);
}
</code></pre>

This question shows two things:

<ul>
<li>Whether the programmer understands math terms like inverse.</li>
<li>Whether the programmer understands that instances of interfaces or classes can be stored in a list, and iterated over later. </li>
</ul>

blocks|key|2862817|text|我同意这是令人困惑和过度设计的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2862818|但我确实认为代码是合理的面向对象的。它是策略模式的一个实例。生成答案列表的代码并不关心如何计算答案-这两个关注点是分开的，并且可以应用不同的计算策略，而不必接触生成列表的代码。|2862819|为了使类更有用，这些函数应该从外部传入(即依赖注入)，而不是在构造函数中实例化。|2862820|你知道答案，我想，但值得一提的是...|2862821|public+Solver()+{
++++functionList+=+new+ArrayList<MathFunction>();

++++functionList.add(new+MathFunction()+{

++++++++@Override
++++++++public+double+calculate(double+x)+{
++++++++++++return+1d/x;
++++++++}
++++});

++++functionList.add(new+MathFunction()+{

++++++++@Override
++++++++public+double+calculate(double+x)+{
++++++++++++return+Math.sqrt(x);
++++++++}
++++});
}|code-block|syntax|javascript|2862822|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I agree that it's confusing and over-engineered.

But I do think the code is reasonably object-oriented. It's an instance of the strategy pattern. The code that generates a list of answers doesn't care how the answers are calculated - the two concerns are separated and a different calculation strategy could be applied without having to touch the code that generates the list.

To make the class more useful, these functions should be passed in from the outside (i.e. dependency injection) rather than being instantiated in the constructor. 

You know the answer, I assume, but for what it's worth...

<pre><code>public Solver() {
 functionList = new ArrayList&lt;MathFunction&gt;();

 functionList.add(new MathFunction() {

 @Override
 public double calculate(double x) {
 return 1d/x;
 }
 });

 functionList.add(new MathFunction() {

 @Override
 public double calculate(double x) {
 return Math.sqrt(x);
 }
 });
}
</code></pre>

blocks|key|3076285|text|好的，我编写了我自己问题的解决方案。我的直觉认为构造器中不应该有任何东西，这似乎是正确的。functionList不是静态的，所以您需要一个实例来初始化它。它指定integer，所以我舍入为integer。逆函数在任何情况下都不是高等数学。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3076286|import+java.util.ArrayList;
import+java.util.List;
import+java.lang.Math;

public+class+Solver+{

++++private+List<MathFunction>+functionList+=+new+ArrayList<MathFunction>();;

++++public+Solver()+{+

//+Complete+here

++++}

++++public+void+initFunctionList()+{

++++++++MathFunction+functionSquareRoot+=+new+MathFunction(){

++++++++++++@Override
++++++++++++public+double+calculate(double+x)+{
++++++++++++++++return+(x<0+?+0:+Math.sqrt(x));++//+maybe+we+need+throw+an+exception+here+for+negative+numbers,+but+we'll+just+set+it+to+0
++++++++++++}};

++++++++MathFunction+functionInverse+=+new+MathFunction(){

++++++++++++@Override
++++++++++++public+double+calculate(double+x)+{
++++++++++++++++return+(x!=0.0+?+1/x+:+0);
++++++++++++}

++++++++};

++++++++functionList.add(functionSquareRoot);
++++++++functionList.add(functionInverse);

++++}

++++public+List<Double>+solveAll(double+x)+{
++++++++List<Double>+result+=+new+ArrayList<Double>();

++++++++for+(MathFunction+function+:+this.functionList)+{
++++++++++++result.add(new+Double(function.calculate(x)));
++++++++}

++++++++return+result;
++++}

}


public+interface+MathFunction+{
+++++double+calculate(double+x);
}


public+class+TestSolver+{

++++/**
+++++*+@param+args
+++++*/
++++public+static+void+main(String[]+args)+{
++++++++Solver+s+=+new+Solver();
++++++++s.initFunctionList();
++++++++System.out.println(s.solveAll(16.0));

++++}

}|code-block|syntax|javascript|3076287|我误导了自己，构造器可能是|3076288|public+Solver()+{+

//+Complete+here
++++++++MathFunction+functionSquareRoot+=+new+MathFunction(){

++++++++++++@Override
++++++++++++public+double+calculate(double+x)+{
++++++++++++++++return+(x<0+?+0:+Math.sqrt(x));++//+maybe+we+need+throw+an+exception+here+for+negative+numbers,+but+we'll+just+set+it+to+0
++++++++++++}};

++++++++MathFunction+functionInverse+=+new+MathFunction(){

++++++++++++@Override
++++++++++++public+double+calculate(double+x)+{
++++++++++++++++return+(x!=0.0+?+1/x+:+0);
++++++++++++}

++++++++};

++++++++functionList.add(functionSquareRoot);
++++++++functionList.add(functionInverse);

++++}|3076289|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Ok, I coded the solution to my own question. My instinct that nothing should be in the constructor seems to be correct. The functionList is not static so you need an instance to initialize it. It specifies integer so I round to integer. The inverse function is not advanced math in any way.

<pre><code>import java.util.ArrayList;
import java.util.List;
import java.lang.Math;

public class Solver {

 private List&lt;MathFunction&gt; functionList = new ArrayList&lt;MathFunction&gt;();;

 public Solver() { 

// Complete here

 }

 public void initFunctionList() {

 MathFunction functionSquareRoot = new MathFunction(){

 @Override
 public double calculate(double x) {
 return (x&lt;0 ? 0: Math.sqrt(x)); // maybe we need throw an exception here for negative numbers, but we'll just set it to 0
 }};

 MathFunction functionInverse = new MathFunction(){

 @Override
 public double calculate(double x) {
 return (x!=0.0 ? 1/x : 0);
 }

 };

 functionList.add(functionSquareRoot);
 functionList.add(functionInverse);

 }

 public List&lt;Double&gt; solveAll(double x) {
 List&lt;Double&gt; result = new ArrayList&lt;Double&gt;();

 for (MathFunction function : this.functionList) {
 result.add(new Double(function.calculate(x)));
 }

 return result;
 }

}


public interface MathFunction {
 double calculate(double x);
}


public class TestSolver {

 /**
 * @param args
 */
 public static void main(String[] args) {
 Solver s = new Solver();
 s.initFunctionList();
 System.out.println(s.solveAll(16.0));

 }

}
</code></pre>

I mislead myself the constructor can be 

<pre><code>public Solver() { 

// Complete here
 MathFunction functionSquareRoot = new MathFunction(){

 @Override
 public double calculate(double x) {
 return (x&lt;0 ? 0: Math.sqrt(x)); // maybe we need throw an exception here for negative numbers, but we'll just set it to 0
 }};

 MathFunction functionInverse = new MathFunction(){

 @Override
 public double calculate(double x) {
 return (x!=0.0 ? 1/x : 0);
 }

 };

 functionList.add(functionSquareRoot);
 functionList.add(functionInverse);

 }
</code></pre>

blocks|key|3076320|text|有点做作，在我看来更接近装饰者的模式。不知道在面试时我会说什么，但下面是我如何编码的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3076321|package+math;

import+java.util.ArrayList;
import+java.util.List;

public+class+DecoratorMath+
{

++++interface+MathFunction+
++++{
++++++++double+calculate(double+x);
++++}

++++public+static+void+main(String[]+args)+
++++{
++++++++DecoratorMath+decoratorMath+=++new+DecoratorMath();
++++++++decoratorMath.go();
++++}

++++public+void+go()+
++++{
++++++++Solver+solver+=+new+Solver();
++++++++decorate(solver);
++++++++List<Double>+results+=+solver.solveAll(02);
++++++++for+(Double+d+:results)+
++++++++{
++++++++++++System.out.println(d);
++++++++}
++++}

++++public+void+decorate(Solver+solver)
++++{
++++++++solver.addFunction(new+MathFunction()+
++++++++{
++++++++++++@Override
++++++++++++public+double+calculate(double+x)+
++++++++++++{
++++++++++++++++return+Math.sqrt(x);
++++++++++++}
++++++++});

++++++++solver.addFunction(new+MathFunction()+
++++++++{
++++++++++++@Override
++++++++++++public+double+calculate(double+x)+
++++++++++++{
++++++++++++++++return+1d/x;
++++++++++++}
++++++++});
++++}

++++class+Solver
++++{
++++++++private+List<MathFunction>+mathFunctions+=+new+ArrayList<MathFunction>();

++++++++public+void+addFunction(MathFunction+mathFunction)
++++++++{
++++++++++++mathFunctions.add(mathFunction);
++++++++}

++++++++public+List<Double>+solveAll(double+x)+
++++++++{
++++++++++++List<Double>+result+=+new+ArrayList<Double>();
++++++++++++for+(MathFunction+function+:+mathFunctions)+
++++++++++++{
++++++++++++++++result.add(new+Double(function.calculate(x)));
++++++++++++}
++++++++++++return+result;
++++++++}
++++}
}|code-block|syntax|javascript|3076322|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Somewhat contrived, seems closer to the decorator pattern to me.
Not sure what I would say during an interview but here is how I would code it:

<pre><code>package math;

import java.util.ArrayList;
import java.util.List;

public class DecoratorMath 
{

 interface MathFunction 
 {
 double calculate(double x);
 }

 public static void main(String[] args) 
 {
 DecoratorMath decoratorMath = new DecoratorMath();
 decoratorMath.go();
 }

 public void go() 
 {
 Solver solver = new Solver();
 decorate(solver);
 List&lt;Double&gt; results = solver.solveAll(02);
 for (Double d :results) 
 {
 System.out.println(d);
 }
 }

 public void decorate(Solver solver)
 {
 solver.addFunction(new MathFunction() 
 {
 @Override
 public double calculate(double x) 
 {
 return Math.sqrt(x);
 }
 });

 solver.addFunction(new MathFunction() 
 {
 @Override
 public double calculate(double x) 
 {
 return 1d/x;
 }
 });
 }

 class Solver
 {
 private List&lt;MathFunction&gt; mathFunctions = new ArrayList&lt;MathFunction&gt;();

 public void addFunction(MathFunction mathFunction)
 {
 mathFunctions.add(mathFunction);
 }

 public List&lt;Double&gt; solveAll(double x) 
 {
 List&lt;Double&gt; result = new ArrayList&lt;Double&gt;();
 for (MathFunction function : mathFunctions) 
 {
 result.add(new Double(function.calculate(x)));
 }
 return result;
 }
 }
}
</code></pre>

blocks|key|3076346|text|在构造器中做这一切都是很糟糕的做法。无论如何，我的一体化解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3076347|import+java.util.*;
import+java.math.*;

//sqrt+/+inverse

public+class+Solver{

++private+List<MathFunction>+functionList;

++public+interface+MathFunction{
+++++double+calculate(double+x);
++}

++class+X+implements+MathFunction+{
++++public+double+calculate(double+x)+{
++++++return+Math.sqrt(x);+
++}+
++}

++++class+Y+implements+MathFunction+{
++++public+double+calculate(double+y)+{
++++++return+1/y;+
++}+
++}



++public+Solver(){
++//here
++++functionList+=+new+ArrayList<MathFunction>();

++++MathFunction+f+=++(MathFunction)+new+X();
++++functionList.add(f);++

++++MathFunction+f2+=++(MathFunction)+new+Y();
++++functionList.add(f2);

++}


++public+List<Double>+solveAll(double+x){+

++List<Double>+result=new+ArrayList<Double>();

++++for+(MathFunction+function+:+this.functionList){

++++++result.add(new+Double(function.calculate(x)));

++++}

++++return+result;

++}

public+static+void+main(String...+args)+{

++++System.out.println("result="%2Bnew+Solver().solveAll(123));

}

}|code-block|syntax|javascript|3076348|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Doing this all within the Constructor is just poor practice. Anyway my all-in-one solution.

<pre><code>import java.util.*;
import java.math.*;

//sqrt / inverse

public class Solver{

 private List&lt;MathFunction&gt; functionList;

 public interface MathFunction{
 double calculate(double x);
 }

 class X implements MathFunction {
 public double calculate(double x) {
 return Math.sqrt(x); 
 } 
 }

 class Y implements MathFunction {
 public double calculate(double y) {
 return 1/y; 
 } 
 }



 public Solver(){
 //here
 functionList = new ArrayList&lt;MathFunction&gt;();

 MathFunction f = (MathFunction) new X();
 functionList.add(f); 

 MathFunction f2 = (MathFunction) new Y();
 functionList.add(f2);

 }


 public List&lt;Double&gt; solveAll(double x){ 

 List&lt;Double&gt; result=new ArrayList&lt;Double&gt;();

 for (MathFunction function : this.functionList){

 result.add(new Double(function.calculate(x)));

 }

 return result;

 }

public static void main(String... args) {

 System.out.println("result="+new Solver().solveAll(123));

}

}
</code></pre>

Here is a programming test used in a job interview. I find it has a very strange non-OO perspective and wonder why anyone would approach a constructor from this perspective. As a very experienced Java programmer, I immediately question the ability of the individual who wrote this code and the strange perspective of the question.

I find these strange out of context questions on interviews disturbing. I would love feedback from other experienced OO Java programmers.

<blockquote>
 Complete the Solver constructor so that a call to solveAll return a list with 2 values
 including the square root and the inverse of the integer passed as parameter.
</blockquote>

<pre><code>public interface MathFunction {
 double calculate(double x);
}

public class Solver {

 private List&lt;MathFunction&gt; functionList;

 public Solver() { 

 //Complete here

 }

 public List&lt;Double&gt; solveAll(double x) {
 List&lt;Double&gt; result = new ArrayList&lt;Double&gt;();
 for (MathFunction function : this.functionList) {
 result.add(new Double(function.calculate(x)));
 }

 return result;
 }
} 
</code></pre>

Java programming test for interview

Java

这是一个在求职面试中使用的编程测试。我发现它有一个非常奇怪的非面向对象的观点，我想知道为什么有人会从这个角度来处理构造器。作为一名非常有经验的Java程序员，我马上就会质疑编写这段代码的人的能力以及这个问题的奇怪视角。在面试中，我发现这些奇怪的断章取义的问题令人不安。我希望得到其他有经验的OO Java程序员的反馈。完...

问Java编程面试考试
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java编程面试考试EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java编程面试考试
EN