小编ama*_*ara的帖子

所以,我可以做得很好:

java mypackage.MyClass

如果./mypackage/MyClass.class存在.我也很乐意这样做:

java -cp myjar.jar mypackage.MyClass

如果类文件存在于jar的适当部分.简单的东西.但我不能为我的生活设法做这样的事情:

java -cp utilities.jar mypackage.MyClass

其中./mypackage/MyClass.class存在,并且其中./utilities.jar存在的(不含有当然MyClass的).

我差点感到愚蠢吗？

所以我一直在阅读很多关于openGL和gpus以及图形的内容,并且经常提到三重缓冲可以提供免费的性能提升.我知道它为什么有帮助; 实际上,你可以进行v-sync而不限于60或30或20或15等的帧率选择,所以你实际上可以达到55fps.但这实际上有成本吗？直觉上,我希望三重缓冲能够将输出延迟一帧,为所有内容增加一个非常小的延迟.

所以我们大多数人都知道如何从内部类访问外部类.使用这些词语进行搜索可以提供有关该主题的大量回答问题.但我想知道的是为什么语法是这样的.

例:

public class A
{
    private class B
    {
        public void c()
            {A.this.d();}

        public void d()
            {System.out.println("You called the d() in the B class! Oh noes!");}
    }

    public void d()
        {System.out.println("You've called d()! Go, you!");}
}

为什么A.this.d()？它看起来像是thisA类的静态字段,但是......*很困惑*

如果这是重复,请原谅我; 就像我说的那样,用这些词搜索会给出答案.

这个问题共收到了几段答案.这是唯一能够告诉我我在找什么的句子:

您的示例几乎没有什么区别,因为中间计算需要临时存储在堆栈上,以便以后可以使用它们.

事实上,它完美地回答了我的问题=)

不像所有的告诉我"不要问这个问题".> _ <

就像你有一个方法,并且你通过增加局部变量的数量但不做其他更改来改变它,它是否会使方法变慢？这是一个例子:

void makeWindow() {
    Display
        .getContext()
        .windowBuilder()
        .setSize(800, 600)
        .setBalloonAnimal(BalloonAnimal.ELDER_GOD.withColor(PUCE))
        .build();
}

要么

void makeWindow() {
    DisplayContext dc = Display.getContext();
    WindowBuilder wb = db.windowBuilder();
    BalloonAnimal god = BalloonAnimal.ELDER_GOD;
    BalloonAnimal puceGod = god.withColor(PUCE);
    wb.setSize(800, 600).setBalloonAnimal(puceGod).build();
}

另一个例子:

int beAnExample(int quiche) {
    return areGlobalsEvil?
        quiche * TAU/5:
        highway(quiche, Globals.frenchFrenchRevolution);
}

要么

int beAnExample(int quiche) {
    if (areGlobalsEvil) {
        int to5 = TAU/5;
        int result = quiche * to5;
        return result;
    } else {
        Game french = …

我有一个编程语言,其中的一个模糊的记忆1..10意味着"范围1以上至10排他性",类似python的range(1, 10),但我一点都不知道这,这并不特别借给自己的搜索.有帮助吗？

如果答案是"蟒蛇",请原谅我.我知道很少的蟒蛇.

从这篇文章.这是代码:

float InvSqrt(float x){ // line 0
   float xhalf = 0.5f * x;
   int i = *(int*)&x; // store floating-point bits in integer
   i = 0x5f3759d5 - (i >> 1); // initial guess for Newton's method
   x = *(float*)&i; // convert new bits into float
   x = x*(1.5f - xhalf*x*x); // One round of Newton's method
   return x;
}

......我甚至不知道那是C还是C++.[好吧显然它是C,谢谢]有人可以为我翻译成Java吗？它(只是,我希望)第2和第4行令我感到困惑.

至少在java中,代理模式有很多开销 - 我不记得确切的数字,但是当包装微小方法时,代理需要花费50倍于包装方法的时间.这是,例如,为什么java.awt.image.BufferedImage.setRGB&getRGB是真的慢; 有大约三个代理包装实际byte[].

为什么50次？!为什么代理不会加倍？

正如SO似乎常见的那样,我得到了一堆答案,告诉我我的问题是错的.不是.查看BufferedImage或其他一些真正的代理模式,而不是那些微基准测试.事实上,如果你必须对BufferedImage进行大量像素操作并且你知道它的结构,你可以通过手动撤消代理来实现所谓的巨大加速; 看到这个答案.

哦,这是我50倍的来源.正如文章详细说明的那样,代理在包装需要很长时间时没有明显的损失,但是如果你用一个小方法包装它们确实会产生很大的痛苦.