小编aig*_*guy的帖子

假设有以下类型:

public interface Base {

    default void sayHi(){
        System.out.println("hi from base");
    }
}

public interface Foo extends Base {
    @Override
    default void sayHi(){
        System.out.println("hi from foo");
    }
}

public interface Bar extends Base {
}

public class MyClass implements Foo, Bar {
    public static void main(String[] args) {
        MyClass c = new MyClass();
        c.sayHi();
    }
}

在这种情况下,如果main执行,则打印"hi from foo".为什么Foo执行优先？不Bar继承sayHi()从Base,因为如果MyClass是仅实现Bar,则Base执行将被称为？因此,代码仍然无法编译是有意义的.另外,既然Bar应该Base实现sayHi() …

我一直在搞乱我的 logback 颜色，我想知道是否可以更改突出显示的颜色。现在我有这个

没关系，但我想将信息设置为蓝色，警告设置为黄色，错误设置为非粗体红色或类似的内容。那可能吗？另外，是否可以为记录器名称突出显示选择不同的颜色？例如，如果我希望 com.blah 为青色，org.apache logger 为洋红色或其他颜色？我目前的模式是

 <Pattern>%d{HH:mm:ss.SSS} %highlight(%-5level) [%thread] %cyan(%logger{36}) - %highlight(%msg%n)</Pattern>

这是一个使用 SBT 的 Scala 项目，如果有什么不同的话，我使用 logback 进行日志记录。

我的问题主要涉及这个列表<Dog> List <Animal>的子类？为什么Java的泛型不是隐式多态的？

所以,我们说动物是猫与狗的超级界面.我们还有一个抽象类垃圾

public abstract class Litter{

    public Litter(Collection<Animal> animals){}
}

然后我们自然会有一个具体的类KittyLitter

public class KittyLitter extends Litter{

    public KittyLitter(Collection<Cat> animals) {
        super(animals);
    }
}

......还有小狗垃圾.

当然,我们希望将KittyLitter中的所有Animal限制为Cat.为什么Java不允许我们这样做？然后,还可以说我们添加另一种方法 -

public abstract void addCub(Animal animal);

KittyLitter中的具体实现

@Override
public void addCub(Animal cat) {
    // TODO Auto-generated method stub
}

在这一点上,这打破了逻辑,并允许我们将Dog插入到没有意义的KittyLitter中.关于为什么Java会对我们做这些事情的任何想法？另外,如果可以将KittyLitter构造函数更改为接受List,为什么type参数的行为会有所不同？任何人都可以解释为什么会这样吗？

编辑:这不是关于构造函数,而是任何覆盖的方法.

人们普遍认为静态初始化是线程安全的.保证只发生一次.然而,我很好奇它在语言规范中确切地说会出现可见性问题吗？这来自http://www.ibm.com/developerworks/library/j-jtp03304/

此过程保证当一个线程在由给定监视器保护的同步块期间写入变量并在由同一监视器保护的同步块期间由另一个线程读取时,读取线程将可以看到该变量的写入.在没有同步的情况下,JMM不提供此保证

我从其他一些来源读过类似的东西.在静态初始化的情况下,我们不使用任何同步.假设初始化资源实际上是不可变的,并且我们从不写入它,那么就不会有用于访问它的同步,也不会使它变得不稳定.那么保证来自哪里读取线程不会看到空指针或部分初始化对象？显然,由于它在加载过程中发生,因此另一个线程不可能在之前读取该值并看到过时值,但是什么保证初始化结果不会停留在执行线程的本地内存中？我很好奇地阅读静态初始化是安全的原因.

编辑:我理解静态初始化是线程安全的.问题是为什么以及什么保证.

假设我有这个代码

val stream = Stream.continually(1)
val s = stream.take(10).map(i => {
  throw new RuntimeException
  i
})

据我了解，当访问流 s 中的相应元素时，会评估传递给 map 的函数。如果 s 从未迭代并且从未访问过任何元素，为什么会抛出异常？

假设有一个类:

public class Magic {

public static void main(String[] args){
    boolean[] val = new boolean[0];
    paradox(val);
}

private static boolean paradox(boolean[] arg) {
    Container container = null;
    try {
        container = Container.getContainer(arg[0]);
        return container.value;
    } catch (UnsupportedOperationException e) {
        e.printStackTrace();
        return false;
    } finally {
        try {
            container.sayHi();
        } catch (UnsupportedOperationException e) {
            e.printStackTrace();
        }
    }
}

private static class Container{
    private boolean value;

    private Container(boolean value){
        this.value = value;
    }

    private static Container getContainer(boolean value) throws UnsupportedOperationException{
        return new …