小编jer*_*ija的帖子

假设我想声明Spring RowMapper,但不是创建动态类,而是实现一个实现RowMapper的抽象类.这是我的方法签名:

SqlProcedure#declareRowMapper(RowMapper<?> rowMapper);

CustomRowMapper.java:

public abstract class CustomRowMapper<T> implements RowMapper<T> {
    protected A a = new A();
}

旧的Java方式是写:

sqlProc.declareRowMapper(new CustomRowMapper<Object>() {
    @Override
    public Object mapRow(ResultSet rs, int rowNum) {
        a.doSomething(rs, rowNum);
        return new Object();
    }
});

是否有可能用lambda表达式实现相同的功能？我想做这样的事情:

sqlProc.declareRowMapper((rs, rowNum) -> {
    a.doSomething(rs, rowNum);
    return new Object();
});

但后来我会得到一个编译错误说a cannot be resolved.这是因为Java将此视为该RowMapper#mapRow方法的实现,而不是CustomRowMapper#mapRow.

如何通过lambda表达式告诉Java使用CustomRowMapper而不是RowMapper？这甚至可能吗？

在Rust Book中有一个调用filter()迭代器的例子:

for i in (1..100).filter(|&x| x % 2 == 0) {
    println!("{}", i);
}

下面有一个解释,但我无法理解它:

这将打印一到一百之间的所有偶数.(请注意,因为过滤器不使用正在迭代的元素,所以它会传递对每个元素的引用,因此过滤谓词使用&x模式来提取整数本身.)

然而,这不起作用:

for i in (1..100).filter(|&x| *x % 2 == 0) {
    println!("i={}", i);
}

为什么闭包的参数是参考|&x|,而不是|x|？使用|&x|和有|x|什么区别？

我知道使用引用|&x|更有效,但我很困惑的事实是我不必x通过使用取消引用指针*x.

我有Java背景,最近我一直在尝试JavaScript继承.我开始写一些对象,在阅读了一些例子后,我发现了最适合我的代码风格.

这是我有的:

var Class = function() {};
Class.extend = function(p_constructor) {
    var Superclass = this;
    // the following line confuses me
    p_constructor.prototype = Object.create(Superclass.prototype);
    p_constructor.prototype.constructor = p_constructor;
    p_constructor.extend = Superclass.extend;
    return p_constructor;
};

所以现在当我想定义一个扩展Class I的对象时,只需输入:

var Person = Class.extend(function(p_firstName, p_lastName) {
    this.firstName = p_firstName;
    this.lastName = p_lastName;
});

以下是真实的:

var p = new Person('john', 'smith');
p instanceof Person; // true
p instanceof Class; // true

我只是很难理解Class.extend函数中以下几行之间的有效区别:

/* 1) */ p_constructor.prototype = new Superclass();
/* 2) */ p_constructor.prototype = …