我有以下几点：
class Foo implements Inter {
void doSomething();
}
Optional<Inter> getPossible() {
Optional<Foo> possible = ...;
possible.ifPresent(Foo::doSomething);
return possible.map(f -> f);
}
getPossible需要返回 anOptional<Inter>因为它覆盖了超类的实现。
方法末尾的映射纯粹是为了转换类型。有没有更优雅的选择？
我正在使用具有多个叶节点类的复合模式,这些类具有专家操作和访问者模式以允许执行这些操作.在这个例子中,accept为了清楚起见,我省略了所有明显的方法.
interface Command {
public int getCost();
}
class SimpleCommand implements Command {
private int cost;
public int getCost() {
return cost;
}
}
class MultiCommand implements Command {
private Command subcommand;
private int repeated;
public int getCost() {
return repeated * subcommand.getCost();
}
public void decrement() {
if (repeated > 0)
repeated--;
}
}
class CommandList implements Command {
private List<Command> commands;
public int getCost() {
return commands.stream().mapToInt(Command::getCost).sum();
}
public void add(Command command) {
commands.add(command);
}
} …我有一个枚举，每个元素都有一个相反的元素。我想要一种优雅的方式将其封装在枚举的每个元素中。我的首选选项不合法，因为它使用前向引用。
enum Direction {
NORTH(SOUTH), SOUTH(NORTH), EAST(WEST), WEST(EAST);
private final Direction opposite;
Direction(Direction opposite) {
this.opposite = opposite;
}
public Direction getOpposite() {
return opposite;
}
}
使用供应商也是非法的。
enum Direction {
NORTH(() -> SOUTH), SOUTH(() -> NORTH), EAST(() -> WEST), WEST(() -> EAST);
private final Supplier<Direction> opposite;
Direction(Supplier<Direction> opposite) {
this.opposite = opposite;
}
public Direction getOpposite() {
return opposite.get();
}
}
这让我不得不重写该方法：
enum Direction {
NORTH{
public Direction getOpposite() {
return SOUTH;
}
},
SOUTH{
public Direction getOpposite() { …我的应用程序使用遗传算法来进化神经网络.在开发(随机)突变算法的单元测试时,我希望确保对于给定的随机值,发生正确的突变.
在这里的问题的问题中,涉及随机性的单元测试算法的最流行的答案是使用模拟.这对我来说似乎很明智,但我的问题是,是否有人对如何做到这一点有坚实的建议.
以下是我目前如何实现这一目标.我interface为我的随机生成器定义了一个(这里为了说明目的而高度简化):
public interface Mutator {
float randomSynapseWeightChange();
float randomSynapseThresholdChange();
}
In the main application this interface has an implementation that wraps `Random`. In my unit testing framework I use:
public class TestMutator implements Mutator {
List<Float> synapseWeightChanges = new ArrayList<>();
public void addTestSynapseWeightChange(float weightChange) {
synapseWeightChanges.add(weightChange);
}
public float randomSynapseWeightChange() {
return synapseWeightChanges.remove();
}
}
我的单元测试然后看起来像:
@Test
public void testDecreaseSynapseWeightMutation() {
TestMutator mutator = new TestMutator();
mutator.addTestSynapseWeightChange(-0.5);
world.setMutator(mutator);
Synapse synapse = new Synapse(new …考虑以下(完全做作的)示例:
public class Length {
private static final int MAX_LENGTH = 10;
private final int length;
public Length(int length) {
if (length > MAX_LENGTH)
throw new IllegalArgumentException("Length too long");
this.length = length;
}
}
我想测试一下,当调用长度大于时,抛出异常MAX_LENGTH.有许多方法可以测试,都有缺点:
@Test(expected = IllegalArgumentException.class)
public void testMaxLength() {
new Length(11);
}
这复制了测试用例中的常量.如果MAX_LENGTH变小,这将无声地不再是边缘情况(尽管显然它应该与单独的情况配对以测试边缘的另一侧).如果它变大,这将失败并需要手动更改(这可能不是一件坏事).
通过添加getter MAX_LENGTH然后将测试更改为以下内容,可以避免这些缺点:
new Length(Length.getMaxLength());
这似乎好得多,因为如果常数变化则不需要更改测试.另一方面,它暴露了一个常量,否则它将是私有的,并且它具有同时测试两种方法的重大缺陷 - 如果两种方法都被破坏,测试可能会给出误报.
另一种方法是根本不使用常量,而是注入依赖:
interface MaxLength {
int getMaxLength();
}
public class Length {
public static void setMaxLength(MaxLength maxLength);
}
那么'常数'可以作为测试的一部分进行模拟(这里使用Mockito示例):
MaxLength mockedLength = mock(MaxLength.class); …有人可以对这个类进行junit测试吗？
public class MyApplication {
private EmailService email = new EmailService();
public boolean processMessages (String msg , String recipient ) {
if (msg.length ==0 | | recipient.length ==0 ) {
return false ;
}
return this.email.sendEmail (msg , recipient ) ;
}
}