小编Nat*_*hes的帖子

我是Java的新手,并试图弄清楚如何解决以下错误:

错误读取

CalculatorWithMemory.java:1: class Calculator is public, should be declared 
  in a file named Calculator.java
public class Calculator

所以我的想法是,这意味着我必须保存2个不同的.java文件.但是,这是一个类,我只有一个提供的文本块来键入我的解决方案,所以我不能将它们保存为.java文件.对解决方案的任何想法都会很棒.

提前致谢!

提供所有信息.我正在尝试解决以下问题.

题

超类计算器包含:

• 一个(受保护的)双实例变量accumulator,它包含计算器的当前值.

写一个子类,CalculatorWithMemory,其中包含:

• 一个双实例变量memory,初始化为0
• 一个方法save,它将累加器的值赋给内存
• 回想一下,将内存值分配给累加器的方法
• 一个方法,clearMemory,它为内存分配零
• 一个方法getMemory,它返回存储在内存中的值

嘿StackOverflow社区,

关于抛出异常.一般来说,我什么时候抛出异常,什么时候抓住它？

让我们说,由于发生了一些问题而无法从中恢复,我遇到了这种情况.我扔了还是抓住了？

我现在这样做:

    try {
       // some code
    }
    catch (IOException e) {
       logger.info("Failed to do something, and cannot continue" + e.getMessage(), e);
       e.printStackTrace();
       throw e;
    }

这是正确的做法吗？如果我抛出异常会更合适吗？对不起,我是异常的新手:)

有没有办法在Clojure中将符号标记为过时？

我可以使用Lein这样的东西,效果很好.

https://github.com/technomancy/leiningen/blob/1.x/src/leiningen/core.clj#L13

但它只在调用函数时发出警告.我真的很喜欢编译器在编译代码时选择它,而不是在调用它时.

当然,我可能无法定义编码器随后会选择的符号,但这使我无法提供任何信息,例如为什么或者何时弃用符号.

所有这些都适用于DSL,其中条款的弃用和过时将以合理的速率发生.

我也是Mockito和PowerMockito的新手.我发现我无法使用纯Mockito测试静态方法,因此我需要使用PowerMockito(对吗？).

我有一个非常简单的类,叫做Validate,这个方法非常简单

public class Validate {
        public final static void stateNotNull(
            final Object object,
            final String message) {
    if (message == null) {
        throw new IllegalArgumentException("Exception message is a null object!");
    }
    if (object == null) {
        throw new IllegalStateException(message);
    }
}

所以我需要验证:

1)当我在null消息参数上调用静态方法时,调用IllegalArgumentException
2)当我在null对象参数上调用静态方法时,调用IllegalStateException

从我到目前为止,我写了这个测试:

import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.isNull;

import org.junit.Before;
import org.junit.runner.RunWith;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.testng.annotations.Test;

@RunWith(PowerMockRunner.class)
@PrepareForTest(Validate.class)
public class ValidateTestCase {

    @Test(expectedExceptions = { IllegalStateException.class })
    public void stateNotNullTest() throws Exception …

我有很多抽象类的子类,每个子类声明一个具有相同名称的公共静态final字段.我想在抽象超类中使用这个字段而不初始化它,并希望每个子类都被强制初始化它.

我正在考虑这个问题,因为抽象类的所有子类都声明了一个名为UNIQUE_ID的公共静态最终字符串字段,并且每个子类都必须声明具有该名称的字段.

我希望我的问题很清楚,如果不是,请告诉我.

可以或多或少地与此相提并论吗？

编辑:代码添加:

我的抽象类看起来像:

public abstract class ExperimentPanelModel extends Panelizable {
protected String nextButtonText;
protected String backButtonText;
protected String skipButtonText;
protected Properties currentFile;
protected List<Properties> pastFiles = new ArrayList<Properties>();

public ExperimentPanelModel(Properties argcurrentfile, List<Properties> argpastfiles) {
    currentFile = argcurrentfile;
    pastFiles = argpastfiles;
    nextButtonText = "Next";
    backButtonText = "Back";
    skipButtonText = "Skip";
}
...
}

该抽象类的一些非抽象子类看起来像(注意所有这些子类都声明public static final String UNIQUE_ID):

public class ConfigurationGUI extends ExperimentPanelModel {

public static final String UNIQUE_ID = "ConfigurationGUI";
public static final String DATA_MODIFIED …

我有一个Java线程做这样的事情:

while (running) {
    synchronized (lock) {
        if (nextVal == null) {
            try {
                lock.wait();
            } catch (InterruptedException ie) {
                continue;
            }
        }

        val = nextVal;
        nextVal = null;
    }
    ...do stuff with 'val'...
}

在其他地方我设置这样的值:

if (val == null) {
    LOG.error("null value");
} else {
    synchronized (lock) {
        nextVal = newVal;
        lock.notify();
    }
}

偶尔(实际上每两千万次)nextVal将被设置为null.我已经抛出了记录消息,我可以看到执行顺序如下:

1. thread1将nextVal设置为newVal
2. thread1调用lock.notify()
3. thread2从lock.wait()中醒来
4. thread2将val设置为nextVal
5. thread2将nextVal设置为null
6. thread2用val做的东西
7. thread2调用lock.wait()
8. thread2从lock.wait()中醒来
   • 没有其他线程调用lock.notify()和thread2没有被中断
9. thread2将val设置为nextVal(为null)
10. 等等

我已经明确检查过锁定第二次醒来,它没有被打断.

我在这里做错了吗？

我有这个程序:

create or replace procedure changePermissionsToRead(
datasource  in varchar2
) 
IS

begin

update 
(
select * from 
WEB_USERROLE ur ,
WEB_USERDATASOURCE ds 
where 
    ur.username = ds.username 
    and 
    ds.datasource = datasource
    and 
    ur.READ_ONLY <> 'Y'  
)
r set r.role = replace(r.role, 'FULL', 'READ');
end;

我收到以下错误:

 ORA-01779

但如果我拿出更新,我写道:

  update 
(
select * from 
WEB_USERROLE ur ,
WEB_USERDATASOURCE ds 
where 
    ur.username = ds.username 
    and 
    ds.datasource = 'PIPPO'
    and 
    ur.READ_ONLY <> 'Y'  
)
r set r.role = replace(r.role, 'FULL', 'READ');

然后这很好用.你能告诉我发生了什么吗？

我最近安装了Delphi XE7.当我第一次编译一个旧应用程序时,当我看到EXE的大小增加10MB时我的下巴掉了!

在'项目选项'中玩,我发现将'调试信息'设置为'有限调试信息'会将EXE大小减小到非常接近Delphi XE生成的EXE.也许在Delphi下,XE7'有限调试信息'相当于Delphi XE的'Debug Information',因为它产生相同的EXE大小？

那么,为什么完整的"调试信息"使得EXE如此之大(与XE相比)？我无法用有限的信息编译EXE(我猜)因为我想完全访问调试好东西(EurekaLog也需要它).
Embarcadero的文档没有说明"有限"和完整调试信息之间的区别.

EurekaLog文档适用于旧版本的Delphi,因此它没有明确说明我是否可以使用新选项(merciful)'有限调试信息'或完整的调试信息.我将不得不进行实验.

是否存在在Java中使用内部类而不是子类更有利的情况(反之亦然)？根据我目前的理解,内部类可以访问外部类的字段和方法.这与使用继承有什么不同？

子类通常可以访问标记为public和protected的所有字段/方法.可以使用getter方法在子类中访问父类中标记为private的字段.基于我迄今为止看到的内容,当方法被标记为私有时,它们通常在类的其他方法中被调用,这些方法被标记为public或protected.当然,我不是一个经验丰富的Java程序员,但这似乎是大势所趋.

根据我目前的理解,选择一个在另一个之间似乎没有任何好处.有人可以让我深入了解为什么以及何时应该使用内部类而不是继承(或反之亦然)？

假设我有一个对象如下：

Map<String, String> m = new HashMap<>();

然后我按如下方式同步该对象并更改其引用：

synchronize(m){
    m = new HashMap<>();
}

有了这段代码，m 上的锁会发生什么情况？更新 m 代表的新对象是否仍然安全？或者锁本质上是在旧对象上？