小编cor*_*iKa的帖子

抽象类具有具体和抽象的功能.接口只有抽象功能.

两者都可以覆盖.是吗

一个人比另一个人的实时优势是什么？

假设我有以下设置

class A {
    B foo();
}

class C extends B {

}

// later
A a = new A();
C theFoo = (C)a.foo();

我们知道a.foo()返回类型B.

当我这样做的时候(C)a.foo(),是吗？

1. 转换a为类型C然后尝试调用foo()它？
2. 调用foo()上a铸造的结果类型C？

我发现很难确定,并且总是只是在谨慎的情况下使用额外的括号(这对于可读性来说并不是一个坏主意,但现在我很好奇)

这是具体的参考,ObjectInputStream.readObject()虽然我没有看到这将如何改变行为.

当我在Eclipse中使用EL表达式时,我自然会先输入${.Eclipse想要提供一些帮助,}之后会有一个紧密的支撑.但是,他们之间有一个空间.因此,如果我想要${user.name}输入${,接着是user.name我的最终结果是${user.name }- 额外的空间让我疯狂.

我查看了所有菜单,但无法找到定义的位置.很明显,我没有足够好看,因为它必须在那里.我怎样才能消除......不,根除这个空间？

我的Eclipse信息:

Version: Juno Service Release 2
Build id: 20130225-0426

假设我有一个名为的主用户表UserProfile,并且在其上有一个显示名称.

我有各种各样的模块,你可以成为其中的一个,UserProfile并用ModuleId它来表示你的ModuleMembership.然后,您可以为每个不同的模块创建一个配置文件,以存储与该模块相关的数据,例如,如果您已注册,那么PokerModule您将获得一个PokerProfile.

我想把显示名称UserProfile放在上面PokerProfile,但我想以标准化的方式进行.我可以通过Hibernate或通过SQL来实现,无论哪种方式都可以.确切的关系是PokerProfile.membership.userProfile.displayName- 我怎么能把它变成课堂@Column上的PokerProfile？

我需要通过套接字发送消息(来自用户的请求到引擎,以及从引擎到用户的响应).所以流程本质上是

       +--------+ serialized  request +--------+      
       | Server | <==== network ====> | Client | 
       +--------+ serialized response +--------+      
           ^                              ^
           | request/response             | mouse/keyclicks
           |    object                    |
           v                              v
       +--------+                     +--------+
       | Engine |                     |  User  |
       +--------+                     +--------+

现在,在这里重新发明轮子才有意义.我正在处理双方的Java,所以我计划使用像这样的对象:

/**
 * A Client makes a Request.
 */
abstract class UserRequest implements Serializable {
    /**
     * The engine will call request.engineCallback(this);
     * This will tell the Engine what the request is, at which point
     * the Engine will determine its …

我正在研究一个遗留系统,它有一个自定义异常,它在任何地方都使用了gosh-frickity.它的灵感来自于这个ServletException类,它说:"只要你的Servlet中有异常,你就会想要抛出这个ServletException".

随着系统的发展(超过10年),已经发生了一个更强大的系统,可以在更高级别捕获异常,并且不再需要在此自定义异常中包装每个异常.(有人可能会说它从未如此,但这是另一个故事.它是一个稳定的应用程序,所以我不会抱怨太多!!)但我们不会立刻重构它们,只是慢慢地.

但是,如果自定义异常是运行时异常而不是已检查的异常,那么使事情变得更简单的一件事就是.这样我们就不需要在任何地方明确地捕获它,并且尚未重构的遗留代码将继续抛出它,就像它们抛出空指针异常一样.

我的问题是...... 采取一次检查的异常并使其成为运行时异常有什么副作用？

除了警告不必要的检查和抛出声明之外,我无法想到任何事情,但是从以前走过这条路的人那里得到输入会很好.

假设我有两个关键资源,foo和bar.我保护他们一些ReentrantReadWriteLocks

ReentrantReadWriteLock foo = new RRWL() ...
ReentrantReadWriteLock bar = new RRWL() ...

大多数操作只使用foo OR bar,但其中一些恰巧使用两者.现在使用单个锁时,您不能只这样做:

void foo() {
   foo.writeLock().lock();
   privateWorkOnFoo();
   foo.writeLock().unlock();
}

如果抛出异常,你的foo将永远被锁定.相反,你把它包起来,就像

void foo() {
    try {
        foo.writeLock().lock();
        privateWorkOnFoo();
    } finally { foo.writeLock().unlock(); }
}

但是,如果我需要同时工作呢？将它们放在一个块中是否安全？

选项1

try {
    foo.writeLock().lock();
    bar.writeLock().lock();
    magic();
} finally { 
    bar.writeLock().unlock();
    foo.writeLock().unlock();
}

或者是否有必要为每个锁提供自己的块:

选项2

try {
    foo.writeLock().lock();
    try {
        bar.writeLock().lock();
        magic();
    } finally { 
      bar.writeLock().unlock();
    }

} finally { 
    foo.writeLock().unlock();
}

我不可能是第一个很难对此进行调查的人...我知道选项2有"防弹",但它也是一个相当多的维护.选项1是否可以接受？

我的工作语言模糊不清,依赖管理不善.为了帮助提供14000个文件代码库,我编写了一些解析工具(用Java编写)并生成了一个依赖图.

我编写了自己的图形和BFS类,它们工作得很好.有了他们,我有这样的方法是getParents()和getChildren().

现在我想在这个图中找到"岛屿"; 也就是说,我试图找到我们的代码库的哪些部分不相互依赖,希望将它们收集到孤立的模块中.

后来,我还计划分析各个岛屿,看看它们中是否存在任何弱点,我们可以在这些弱点上建立模块障碍并定义该模块的界面,但这是在路上.

现在,我正在考虑这样做:

Map<DependencyEntry, Set<DependencyEntry>> allChildren = new ...;
for(DependencyEntry entry : allFiles) allChildren.put(entry,getAllChildren(entry));
Set<DependencyEntry> visited = new ...;
Set<DependencyEntry> largest = new HashSet<DependencyEntry>(); // size 0
// slightly more expensive but more readable
for(DependencyEntry entry : allChildren.keySet()) {
    Set<DependencyEntry> set = allChildren.get(key);
    if(set.size() > largest.size()) largest = set;
}
visited.addAll(largest);

这应该是我最大的岛屿.从那里,我可以通过并排除包含任何访问节点的任何集合,然后再次运行它以获得下一个最大的岛,依此类推.

这是一个准确的算法吗？有没有更好的方法来解决我没有看到的这个问题？

根据JLS:

15.9.5匿名类声明编译器自动从类实例创建表达式派生匿名类声明.

匿名类永远不是抽象的(第8.1.1.1节).匿名类始终是内部类(第8.1.3节); 它永远不会是静态的(§8.1.1,§8.5.2). 匿名类总是隐式最终的(§8.1.1.2).

这似乎是一个特定的设计决定,所以它有可能有一些历史.

如果我选择这样的课程:

SomeType foo = new SomeType() {
    @Override
    void foo() {
        super.foo();
        System.out.println("Hello, world!");
    }
};

如果我选择的话,为什么我不允许再次继承它？

SomeType foo = new SomeType() {
    @Override
    void foo() {
        super.foo();
        System.out.println("Hello, world!");
    }
} {
    @Override
    void foo() {
        System.out.println("Hahaha, no super foo for you!");
    }
};

我不是说我一定想要,或者甚至可以想到我会这样做的原因.但我很好奇为什么会这样.

我希望一次将结果作为"页面"获取; 我希望页码是一个参数(在JDBC预处理语句中).请考虑以下代码段

SELECT * FROM thread t ORDER BY t.id LIMIT ((? - 1) * 20), 20

理想情况下,这将导致第1页的结果LIMIT 0, 20.

当我测试

SELECT * FROM thread t ORDER BY t.id LIMIT ((1 - 1) * 20), 20

我被告知我有语法错误.我不知道它可能是什么 - 它只是一些简单的数学.它告诉我的全部是

错误1064(42000):您的SQL语法有错误; 查看与您的MySQL服务器版本对应的手册,以便在第1行'((1 - 1)*20),20'附近使用正确的语法

我的LIMIT条款我做错了什么,我该如何解决？