[한글화 시리즈-14] Migration Rules

Migration Rules

이 룰셋은 JDK 버젼별 이전에 관한 룰들을 포함하며, 이 룰셋은 바로 사용하지 말고, 각 버젼별로 포장된 룰셋을 사용하자.

---

ReplaceVectorWithList

만약 list 객체가 필요할 경우, 실행 비용이 비싼 threadsafe(멀티스레드에서 안전한 접근을 제공하는 기능)기능이 필요 없을 경우 Vector보다 조금 더 최근에 나온 java.util.ArrayList 사용을 고려하자. 하지만 threadsafe가 필요하면  Vector를 사용해야한다.

public class Foo {
  void bar() {
    //threadsafe가 필요하면 Vector를
    //JDK 1.5 이하 
    List v = new Vector();
    //JDK 1.6 이상은 Generics 형을 정해야한다.
    List v<String> = new Vector<String>();
    //그냥 list가 필요하면
    //JDK 1.5 이하 
    List list = new ArrayList();를 사용하자
    //JDK 1.6 이상은 Generics 형을 정해야한다.
    List<String> list = new ArrayList<String>();를 사용하자
  }
}

ReplaceHashtableWithMap

기존의 HashTable은 더욱 최근의 java.util.Map으로 변경을 고려하자. 하지만 HashTable은 threadsafe 기능이 있으므로, 변경을 잘 고려해야 한다.

public class Foo {
  void bar() {
    //threadsafe가 필요하면 Hashtable
    Map<String, Object> table = new Hashtable<String, Object>(); 
    //일반 map이 필요하면 HashMap
    Map<String, Object> map = new HashMap<String, Object>();
  }
}

ReplaceEnumerationWithIterator

이전 기능인 Enumeration보다 java.util.Iterator를 사용하고 1.6이상은 foreach[for(String v : list) {}] 기능을 사용하자.

//JDK 1.4
public void jdk14() {
  Vector v=new Vector();
  v.add("Amit");
  v.add("Raj");
  v.add("Pathak");
  v.add("Sumit");
  v.add("Aron");
  v.add("Trek");

  Enumeration<String> en=v.elements();

  while(en.hasMoreElements()) {
    String value=(String) en.nextElement();
    System.out.println(value);
    v.remove(value);
  }
}

//JDK1.5
public void jdk15() {
  Vector v=new Vector();
  v.add("Amit");
  v.add("Raj");
  v.add("Pathak");
  v.add("Sumit");
  v.add("Aron");
  v.add("Trek");

  Iterator<String> it=v.iterator();
  while(it.hasNext()) {
    String value=(String) it.next();
    System.out.println(value);
    v.remove(value);
  }
}
//1.6 이상
public void jdk16() {
  List<String> list=new ArrayList<String>();
  list.add("Amit");
  list.add("Raj");
  list.add("Pathak");
  list.add("Sumit");
  list.add("Aron");
  list.add("Trek");
  for(String value : list) {
    System.out.println(value);
  }
}

AvoidEnumAsIdentifier

eunm을 변수명으로 사용하지 말자.

public  class foo {
  //enum으로 변수명을 만들지 말자.
  String enum = "foo";
}

AvoidAssertAsIdentifier

assert를 변수명으로 사용하지 말자.

public class foo {
  //변수명으로 assert를 사용하지 말자.
  String assert = "foo";
}

IntegerInstantiation

JDK1.5에서 new Integer()를 호출할 때 메모리를 할당한다. Integer.valueOf()가 메모리 사용에 더욱 효율적이다.

public class Foo {
  private Integer i = new Integer(0);
  //아래의 방법이 메모리 사용에 효율적이다.
  Integer i = Integer.valueOf(0);
}

ByteInstantiation

JDK1.5에서 new Byte()를 호출할 때 메모리를 할당한다. Byte.valueOf()가 메모리 사용에 더욱 효율적이다.

public class Foo {
  private Byte i = new Byte(0); 
  // 다음이 메모리 사용에 효율적이다
  Byte i = Byte.valueOf(0);
}

ShortInstantiation

JDK1.5에서 new Short()를 호출할 때 메모리를 할당한다. Short.valueOf()가 메모리 사용에 더욱 효율적이다.

public class Foo {
  private Short i = new Short(0);
  // 다음이 메모리 사용에 효율적이다
  Short i = Short.valueOf(0);
}

LongInstantiation

JDK1.5에서 new Long()를 호출할 때 메모리를 할당한다. Long.valueOf()가 메모리 사용에 더욱 효율적이다.

public class Foo {
  private Long i = new Long(0);
  // 다음이 메모리 사용에 효율적이다
  Long i = Long.valueOf(0);
}

JUnit4TestShouldUseBeforeAnnotation

JUnit 3에서는 setUp 메소드가 실행 테스트(running test)에서 요구되는 모든 데이터 엔티티(entity들을 설정하는데 이용되었다. 하지만 JUnit 4에서는 setUp 메소드는 무시되고 @Before annotation이 붙은 모든 메소드들이 테스트 메소드들이 실행되기 전에 실행된다.

//JUnit 3
public class MyTest {
  public void setUp() {
    bad();
  }
}

//JUnit 4
public class MyTest2 {
  @Before
  public void setUp() {
    good();
  }
}

JUnit4TestShouldUseAfterAnnotation

JUnit 3에서는 tearDown 메소드를 사용해서 실행 테스트(running test)들에서 사용된 데이터 엔티티(entity)들이 정리된다. 하지만 JUnit 4에서는 tearDown 메소드는 무시되고, @After annotation가 붙은 모든 메소드들이 각 테스트 실행 후 실행되어 정리한다.

//JUnit 3
public class MyTest {
  public void tearDown() {
    bad();
  }
}

//JUnit 4
public class MyTest2 {
  @After
  public void tearDown() {
    good();
  }
}

JUnit4TestShouldUseTestAnnotation

JUnit 3에서는 test를 접두사로 붙은 메소드들을 유닛 테스트로 실행한다. 하지만 JUnit 4에서는 @Test annotation이 붙은 메소드들이 유닛 테스트 메소드로 실행된다.

public class MyTest {
  //JUnit 3
  public void testBad() {
    doSomething();
  }

  //JUnit 4
  @Test
  public void testGood() {
    doSomething();
  }
}

JUnit4SuitesShouldUseSuiteAnnotation

JUnit 3에서는 test suites는 suite() 메소드로 구분되었다, 하지만 JUnit 4에서는 @RunWith(Suite.class) annotation으로 결정된다.

//JUnit 3
public class BadExample extends TestCase{
  public static Test suite(){
    return new Suite();
  }
}

//JUnit 4
@RunWith(Suite.class)
@SuiteClasses( { TestOne.class, TestTwo.class })
public class GoodTest {
}

JUnitUseExpected

JUnit 4에서는 try catch 대신 @Test(expected=Exception.class)를 사용하자.

public class MyTest {
  @Test
  public void testBad() {
    try {
      doSomething();
      fail("should have thrown an exception");
    } catch (Exception e) {
    }
  }

  @Test(expected=Exception.class)
  public void testGood() {
    doSomething();
  }
}

해당 URL: http://pmd.sourceforge.net/pmd-4.2.6/rules/migrating.html