我理解在这段代码中:
class Foo {
public static void method() {
System.out.println("in Foo");
}
}
class Bar extends Foo {
public static void method() {
System.out.println("in Bar");
}
}
..静态方法Bar'隐藏'声明的静态方法Foo,而不是在多态意义上覆盖它.
class Test {
public static void main(String[] args) {
Foo.method();
Bar.method();
}
}
...将输出:
在Foo
in Bar
重新定义method()为final在Foo将禁用的能力Bar,以隐藏它,并重新运行main()将输出:
在Foo
的Foo
(编辑:将方法标记为时编译失败final,并且仅在删除时再次运行Bar.method())
将静态方法声明为final有意或无意地重新定义方法的子类是否被认为是不好的做法？
(这是对使用行为的一个很好的解释final..)
Java语言文档说:
如果将基本类型或字符串定义为常量并且在编译时已知该值,则编译器会将代码中的常量名称替换为其值.这称为编译时常量.
我的理解是,如果我们有一段代码:
private final int x = 10;
然后,编译器将x用文字替换代码中的每个匹配项10.
但假设常量在运行时初始化:
private final int x = getX(); // here getX() returns an integer value at run-time.
与编译时常量相比,是否会出现性能下降(无论可能忽略不计)？
另一个问题是以下代码行:
private int y = 10; // here y is not final
编译器以与编译时常量相同的方式处理？
最后,我从答案中理解的是:
final static 表示编译时常量final意味着它是一个常量但在运行时被初始化static意味着在运行时初始化final变量,不会被视为常量.我的理解是否正确？
我想要一个类,我可以使用一个变量unset(the id)创建实例,然后稍后初始化此变量,并在初始化后使其不可变.实际上,我想要一个final我可以在构造函数之外初始化的变量.
目前,我正在通过一个Exception如下所示的setter来即兴创作:
public class Example {
private long id = 0;
// Constructors and other variables and methods deleted for clarity
public long getId() {
return id;
}
public void setId(long id) throws Exception {
if ( this.id == 0 ) {
this.id = id;
} else {
throw new Exception("Can't change id once set");
}
}
}
这是一个很好的方式来实现我想要做的事情吗？我觉得我应该能够在初始化后设置一些不可变的东西,或者我可以使用一种模式来使它更优雅.
可能重复:
私有最终静态属性vs私有最终属性
声明变量之间有什么区别
static final int x = 5;
要么
final int x = 5;
如果我只希望变量是本地的,并且是常量(以后不能更改)？
谢谢
我有一个座位数组,数组有两个字符串(选中和空).在鼠标单击时,我想遍历数组并找到所选的座位.当我按下按钮时,它说:
无法分配最终的局部变量seatno,因为它是在封闭类型中定义的.
JButton btnContinue = new JButton("Next");
btnContinue.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent arg0) {
for(int x=0;x<17;x++){
if(anArray[x]=="selected"){
seatno = anArray[x];
}
}
data page=new data(newfrom,newto,newtime,date2,seatno);
page.setVisible(true);
setVisible(false);
}
});
btnContinue.setBounds(358, 227, 62, 23);
contentPane.add(btnContinue);
我正在尝试检测一个类是否具有特定的功能(具体来说shared_from_this(),是继承自哪个std::enable_shared_from_this<Some Unknown Class>).为了使事情变得更复杂,我需要知道它是否具有此功能,即使它已从远程基类继承或使用受保护访问继承.
我已经查看了其他问题,例如这个问题,但提供的方法不适用于检测受保护的成员函数.
我目前使用的方法如下:
template <class T>
struct shared_from_this_wrapper : public T
{
template <class U>
static auto check( U const & t ) -> decltype( t.shared_from_this(), std::true_type() );
static auto check( ... ) -> decltype( std::false_type() );
};
template<class T>
struct has_shared_from_this : decltype(shared_from_this_wrapper<T>::check(std::declval<shared_from_this_wrapper<T>>()))
{ };
我当前解决方案的缺陷是它不适用于声明的类final.所以我正在寻找一个满足以下成员函数的测试解决方案:
final编辑:我有一个可行的解决方案,但需要与帮助类成为朋友,这也不是一个理想的解决方案,但现在可能是一种解决方法(因为它满足所有要求):
struct access
{
template <class T>
static auto shared_from_this( T const & t ) -> …我被告知static方法是隐含的final,因此不能被覆盖.真的吗？
有人可以提供一个更好的覆盖静态方法的例子吗？
如果静态方法只是类方法,那么拥有它们的真正用途是什么？
好吧,所以说我有一个看起来像这样的课程:
public class SignupServlet extends HttpServlet {
private static final Logger SERVLET_LOGGER=COMPANYLog.open(SignupServlet.class);
private static final ExceptionMessageHandler handler = new ExceptionMessageHandler();
private static final SignupServletObservableAgent signupObservableAgent =
new SignupServletObservableAgent(null, SERVLET_LOGGER);
}
我可以指望类加载器按顺序初始化这些字段,这样我可以依赖SERVLET_LOGGER在signupObservableAgent之前实例化吗？
vals(？)在单例对象中自动最终的原因是什么？例如
object NonFinal {
val a = 0
val b = 1
def test(i: Int) = (i: @annotation.switch) match {
case `a` => true
case `b` => false
}
}
结果是:
<console>:12: error: could not emit switch for @switch annotated match
def test(i: Int) = (i: @annotation.switch) match {
^
而
object Final {
final val a = 0
final val b = 1
def test(i: Int) = (i: @annotation.switch) match {
case `a` => true
case `b` => …