小编use*_*011的帖子

类Boolean的hashCode()方法实现如下:

public int hashCode() {
    return value ? 1231 : 1237;
}

为什么使用1231和1237？为什么不是别的？

假设我们有以下代码:

class Test {
    private Test() {
        System.out.println("test");
    }

}

public class One extends Test {

    One() {
        System.out.println("One");
    }

    public static void main(String args[]) {

        new One();
    }
}

当我们创建一个对象时One,它最初被称为父类构造函数Test().但Test()私有 - 我们得到一个错误.一个很好的例子和摆脱这种情况的方法多少钱？

现在我正在尝试找到最好的java反编译器,我发现了这些:

• http://java.decompiler.free.fr/
• http://www.reversed-java.com/fernflower/
• http://dj.navexpress.com/
• http://cavaj-java-decompiler.en.softonic.com/

使用这些反编译器,我处理此类的字节代码:

public class ss
{
public static void main(String args[])
{
  try{
   System.out.println("try");

  }
  catch(Exception e)
  {
   System.out.println("catch");
  }
  finally
  {System.out.println("finally");}
}
}

我得到了以下结果:

fernflower:

public class ss {

   public static void main(String[] var0) {
      try {
         System.out.println("try");
      } catch (Exception var5) {
         System.out.println("catch");
      } finally {
         System.out.println("finally");
      }

   }
}

DJ Java Decompiler:

import java.io.PrintStream;

public class ss
{

    public ss()
    {
    }

    public static void main(String args[])
    {
        System.out.println("try");
        System.out.println("finally");
        break MISSING_BLOCK_LABEL_50;
        Exception …

例如:

public class Test {

    public static void main(String[] args) throws Exception {
        Car c= (Car) Class.forName("Car").newInstance();
        System.out.println(c.getName());
    }
}

class Car {
    String name = "Default Car";
    String getName(){return this.name;}
}

明确的代码.

但是,如果我用params添加构造函数,有些像这样:

public Car(String name)
{this.name = name;}

我知道了: java.lang.InstantiationException

所以,不,我不知道,如何通过params传递构造函数.

请帮忙.

在Collection Framework中,我们有接口List和类AbstractList:

AbstractList implements List

并ArrayList扩展AbstractList和

implements List

我的问题:为什么ArrayList有implements List条款？

如果,ArrayList extends AbstractList而且AbstractList implements List,我们不能说,那ArrayList implement List？

我知道Javassist是一个Java库,它提供了一种操作应用程序Java字节码的方法.

好的,但为什么我们需要操作字节码？

任何真实的例子？任何真正的应用程序,javassist使用？

例如,我输入了字符串:" qwerty1qwerty2 ";

作为输出我想[1,2].

我目前的实施如下:

import java.util.ArrayList;
import java.util.List;

public class Test1 {

    public static void main(String[] args) {
        String inputString = args[0];
        String digitStr = "";
        List<Integer> digits = new ArrayList<Integer>();

        for (int i = 0; i < inputString.length(); i++) {
            if (Character.isDigit(inputString.charAt(i))) {
                digitStr += inputString.charAt(i);
            } else {
                if (!digitStr.isEmpty()) {
                    digits.add(Integer.parseInt(digitStr));
                    digitStr = "";
                }
            }
        }
        if (!digitStr.isEmpty()) {
            digits.add(Integer.parseInt(digitStr));
            digitStr = "";
        }

        for (Integer i : digits) {
            System.out.println(i);
        }
    } …

我有下一个java类:

public class Test {

    public static void main(String args[]) {

        for (int i = 0; i < 1448; i++) {
            System.out.print(i);
        }

    }
}

当我在Eclipse IDE中运行tis代码时 - 我在Eclipse控制台中看不到任何输出.

但是,如果我更改值1448并设置为例如1447或更少,我在控制台中看到输出(12345678 ...)

那么,也许Eclipse IDE在控制台中对字符串长度有限制？

你怎么看待这件事？

谢谢.

目前,我正在阅读"JUnit in action"一书.在本书中,我发现了以下文字:

在调用每个@Test方法之前,JUnit会创建测试类的新实例.这有助于提供测试方法之间的独立性,并避免测试代码中的无意的副作用.因为每个测试方法都在一个新的测试类实例上运行,所以我们不能在测试方法中重用实例变量值.

现在我认为这种方法没有多大意义:

例如:

public class CalculatorTest {
    @Test
    public void testAdd_1() {
        Calculator calculator = new Calculator();
        double result = calculator.add(1, 1);
        assertEquals(2, result, 0);
    }

    @Test
    public void testAdd_2() {
        Calculator calculator = new Calculator();
        double result = calculator.add(2, 2);
        assertEquals(4, result, 0);
    }
}

对于测试类CalculatorTest,没有任何好处.

好吧,让我们去关注另一个例子:

public class OneTest {

    static byte count;

    public OneTest() {
        count++;
    }

    @Test
    public void test1() {
        System.out.println(count);
    }

    @Test
    public void test2() {
        System.out.println(count);
    }
}

对于测试类OneTest,我找到了一种方法来为许多测试方法使用相同的变量计数...

那么,如何看待书中描述的方法的真正好处呢？

对于使用数据库,我的类扩展了HibernateDaoSupport类,并在我使用Spring的方法内部HibernateTemplate.

因此,为了删除数据库中的一行,我使用以下方法:

public void delete(MyObject obj) {
    getHibernateTemplate().delete(obj);
}

一切都好!

但是,此时我正在尝试实现一个可以删除基于id的行的方法:

public void delete(final long id) {
    // some code here
}

我找不到HibernateTemplate像这样的方法:
getHibernateTemplate().remove(id)

在这种情况下,对我来说什么是好的解决方案？