标签: final

class Temp
{
private:
    ~Temp() {}
    friend class Final;
};

class Final : virtual public Temp
{
public:
     void fun()
     {
         cout<<"In base";
     }
};

class Derived : public Final
{
};

void main()
{
    Derived obj;
    obj.fun();
}

上面的代码试图实现不可继承的类(final).但是使用上面的代码仍然可以创建派生的对象,为什么呢？

只有当ctor私有化时才能实现所需的功能,我的问题是为什么在dtor私有的情况下无法实现？

可能重复:
在C#中Java的最终结果是什么？

在Java中,final不仅适用于一个类.

所以,我想知道:两个关键字之间是否有任何功能差异？

谢谢你,对不起相对noob问题感到抱歉.

快速的Google搜索无法满足我的需求.

考虑这两个类:

public abstract class Bar {
    protected Bar() {
        System.out.println(getValue());
    }

    protected abstract int getValue();
}

public class Foo extends Bar {
    private final int i = 20;

    public Foo() {
    }

    @Override
    protected int getValue() {
        return i;
    }

    public static void main(String[] args) {
        new Foo();
    }
}

如果我执行Foo,则输出为20.

如果我使字段非final,或者我在Foo构造函数中初始化它,则输出为0.

我的问题是:在最终字段的情况下,初始化顺序是什么？JLS中描述了这种行为？

我希望找到最终的领域一些特殊的规则在这里,但除非我错过了什么,没有.

请注意,我知道我永远不应该从构造函数中调用可覆盖的方法.这不是问题的关键.

我有以下静态工厂方法,从int数组创建列表视图:

public static List<Integer> newInstance(final int[] numbers) {
    return new AbstractList<Integer>() {

        @Override
        public Integer get(int index) {
            return numbers[index];
        }

        @Override
        public int size() {
            return numbers.length;
        }
    };
}


public static void main(String[] args) {
    int[] sequence = {10, 20, 30};
    List<Integer> list = ListFactory.newInstance(sequence);
    System.out.println("List is "+list);

}

在"Effective Java"中,Joshua Bloch提到了这一点

作为适配器,允许将int数组视为Integer实例列表.

但是,我记得Adapter使用组合,匿名列表实现的实例应该使用int []作为成员字段.

如果int []输入参数不是匿名列表实现的成员字段,那么它究竟存储在哪里？

如果有人能提供一些见解或一些链接来寻找更多信息,我将不胜感激.

如何在Java 8 lambda中使用非final变量.它抛出编译错误,说'在封闭范围中定义的局部变量日期必须是最终的或有效的最终'

我其实想要实现以下目标

public Integer getTotal(Date date1, Date date2) {
    if(date2 == null || a few more conditions) {
        date2 = someOtherDate;
    }
    return someList.stream().filter(filter based on date1 and date2).map(Mapping Function).reduce(Addition);
}

我该如何实现这一目标？它会引发date2的编译错误.谢谢,

我想使对象的结构不可变,防止其属性随后被替换.但是,属性需要是可读的.这可能吗？

我确信没有语言功能(final在Java和readonlyC#中都有)来支持这一点,但是想知道是否可能有另一种机制来实现相同的结果？

我正在寻找这些方面的东西:

var o = {
    a: "a",
    f: function () {
        return "b";
    }
};

var p = o.a;        // OK
o.a = "b";          // Error
var q = o.f();      // OK
o.f = function () { // Error
    return "c"; 
};

我们的应用程序使用初始化代码,这取决于执行静态代码的顺序,我想知道这个顺序是否在所有JVM中都是一致的.

这是我的意思的样本:

public class Main {

    static String staticVar = "init_value";

    public static void main(String[] args) {

        System.out.println(A.staticVar);
        staticVar = "mainValue";
        System.out.println(A.staticVar);
    }
}

public class A {
    static String staticVar = Main.staticVar;
}

会给:

init_value
init_value

和

public class Main {

    static String staticVar = "init_value";

    public static void main(String[] args) {

        // System.out.println(A.staticVar);
        staticVar = "mainValue";
        System.out.println(A.staticVar);
    }
}

public class A {
    static String staticVar = Main.staticVar;
}

会给(在我的环境):

mainValue

总而言之,在所有JVM中,当我们第一次使用类时,是否总是执行静态代码？

在调试(eclipse)中,我无法在变量视图中看到变量内容,也无法在Expressions视图中或在Display视图中看到 - 如果变量是在匿名类之外定义但调试在匿名类中.

当我尝试在调试中看到内容时,我得到错误:x无法解析为变量.

在以下示例中,无法解析x:

private void someMethod(final Object x) {
  new Runnable() {
    public void run() {
      Log.i(x); // x is printed correctly but cannot be resolved when in Debug
    }
  }.run();
}

这个问题关于eclipse开发环境 - 关于调试Android.这不是关于final,也不是编译的讨论 - 只是调试.

我试图通过执行程序和runnable并行执行100个任务,任务需要使用循环变量:

for (int i = 0; i < 100; i++) {
   executor.execute(() -> {
     doSomething(String.format("Need task number %d done", i));
   }
  });
}

在'我'说的时候,我得到一个波浪形的 - Variable used in lambda expression should be effectively final.

据我所知,循环变量不能是最终的或有效的最终变量,因为它随着每次迭代而被更改.我发现了一个简单的解决方法,

for (int i = 0; i < 100; i++) {
   int index = i;
   executor.execute(() -> {
     doSomething(String.format("Need task number %d done", index));
   }
 });
}

这对我来说似乎不是最有效的解决方案,在每次迭代时声明一个新变量.有没有更好的方法呢？

考虑这个类层次结构:

struct Animal { virtual ~Animal(); };
struct Cat : virtual Animal {};
struct Dog final : virtual Animal {};

我的理解是,将final在class Dog确保没有人能够创建一个类继承Dog,其中,推论,意味着没有人能够创建IS-A类Dog和IS-A Cat同时进行.

考虑这两个dynamic_cast:

Dog *to_final(Cat *c) {
    return dynamic_cast<Dog*>(c);
}

Cat *from_final(Dog *d) {
    return dynamic_cast<Cat*>(d);
}

GCC,ICC和MSVC忽略final限定符并生成调用__dynamic_cast; 这是不幸的,但并不令人惊讶.

让我感到惊讶的是,Clang和Zapcc都为("总是返回nullptr")生成了最佳代码from_final,但是生成了对__dynamic_castfor 的调用to_final.

这真的是一个错过的优化机会(在一个编译器中显然有人投入一些努力来尊重final演员阵容中的限定符),或者在这种情况下,由于某些微妙的原因,我仍然没有看到优化是不可能的？