나의 코딩 룰...
개발을 오래 하다 보니 몇 가지 규칙이 생겼다.
남들은 잘 안쓰는 규칙일 지 모르겠다. 뭐 개발 할 때, 컴파일 돼 동작할 때 1도 영향주지 않는 뻘짓 규칙이라... ㅋㅋㅋ
현재 Java가 주력 언어니까 Java를 예를 든다.
1. this를 사용한다.
뭐 자신을 나타내는 this를 쓰는 것이 어떠냐 라고 반문 할지 모르겠지만
클래스 내부 변수/함수를 사용할 때 늘 앞에 this를 사용한다.
this.configVo = ActpConfigVO.getInstance();
this.logHeader = this.configVo.getLogHeader();
this.actpClassObject = ActpWorkFactory.getClassObject( this.configVo );
if( this.actpClassObject == null ) {
this.logger.info( this.logHeader + "데이터 분석 Object를 얻지 못함" );
return new ReturnBasic( "E099989", "지원하지 않는 업체." );
}
this.logger.info( this.logHeader + "Service 시작" );
if( this.workExe != null ) {
this.logger.info( this.logHeader + "서비스가 종료되지 않은 상태임" );
return new ReturnBasic( "E099990", "이미 실행 중임." );
}
this는 클래스 내부 변수/함수를 사용할 때 생략 해도 되는 녀석이다. 하지만 this를 사용할 때 확실히 지역 변수인지 멤버 변수인지 구분이 쉽게 되어 소스 가독이 좋은 것 같다.
2. final 을 사용한다.
final은 클래스에 사용할 때 더이상 상속 금지, 함수에 사용할 때는 더이상 Override 금지, 변수에 선언할 때는 변경 불가의 의미를 가진다.
대부분 난 변수 앞에 final을 사용한다.
final byte[] byteMsg = this.actpWork.getData4Byte( reqVo );
this.logger.info( this.logHeader + "발신 데이터 [" + new String(byteMsg) + "]" );
final ByteBuffer writeBuffer = ByteBuffer.wrap( byteMsg );
final Future<Integer> writeResult = client.write( writeBuffer );
writeResult.get( this.readTimeOut, TimeUnit.MILLISECONDS );
final 키워드에 대한 것을 찾아 봤지만 컴파일할 때 딱히 더 좋은 성능을 내는 것 같지는 않다. 다만 소스 작성 할 때 변수의 가변 여부를 확실히 정하고 가는 것이 좋아 보여서 사용한다.
그리고 컴파일 된 바이트 코드를 살펴 보면 final 선언한 변수에 대한 타입이 그렇지 않은 것과 다르긴 하다.
3. result 변수.
함수에서 리턴 할 값이 있을 경우 그 변수 명은 result로 명명한다.
이것은 Delphi(Pascal 언어)할 때 생긴 습관이다. Pascal언어의 경우 function이라는 리턴 가능한 method를 작성하게 되면 자동으로 리턴할 변수가 result라는 명으로 생성된다.
Java 개발할 때도 역시 result라는 변수를 습관적으로 쓰다 보니 이렇게 고정된 습관이 돼 버렸다.
public PacketPart removePart(final String name){
fnial PacketPart result = this.partMap.get( name );
if( result != null ){
this.partMap.remove( name );
this.partes.remove( result );
}
return result;
}
나중에 코드를 보더라도 method의 리턴 값은 result에 담기는 규칙 때문에 소스 가독은 조금 더 편해졌다.
4. 변수 선언
변수 선언은 조금 생각하고 만든다. 특히 함수를 통해 값을 얻어오는 경우엔 특히나. 두 번 이상 함수를 통해 값을 얻어 오게 될 경우 변수 선언을 해 Object의 Instance를 얻어 처리 한다. 그게 함수 호출 횟수를 줄여 주는 것 같아서다.
그런데 함수 호출 비용과 변수 선언 비용 중 어떤 것이 더 비쌀지 모르겠다.
private static class MyList extends ArrayList<String>{
@Override
public String get(int index) {
System.out.print("get call ");
return super.get(index);
}
@Override
public int size() {
System.out.println("size call");
return super.size();
}
}
public static void main(String[] args) {
final MyList lst = new MyList();
lst.add("A");
lst.add("B");
lst.add("C");
for( int i=0 ; i<lst.size() ; i++ ) {
System.out.print(lst.get(i));
System.out.print("==");
System.out.println(lst.get(i));
}
}
--------------------------
run 결과
size call
get call A==get call A
size call
get call B==get call B
size call
get call C==get call C
size call보통 많이 사용하는 for문 예제다.
이것을 사용할 때 size() 함수를 i의 값을 비교할 때 매번 호출 하게 된다. lst의 갯수는 고정된 값인데 for문 반복 할 때마다 [i<lst.size()] 를 통해 size() 함수를 계속 호출 하는 것이다.
이 것은 상당히 불필요한 행위이므로 별도 size() 결과를 갖고 있는 변수를 선언해 사용하는 것이 좋다.
그리고 list의 내부 값을 꺼내오는 get method. 이 것 역시 별 생각 없이 막 남발 하는 사람들 코드 많이 봤다. 뭐 이것 역시 동작 하는데 1도 지장 없지만 내부 List에서 값을 꺼내 오는 get method를 계속 해서 호출 하는 작업을 하게 된다.
비효율 적인 작업이다. 별도로 변수를 선언해 get 작업은 한 번만 하는 것이 좋다고 생각한다.
public static void main(String[] args) {
final MyList lst = new MyList();
lst.add("A");
lst.add("B");
lst.add("C");
final int listSize = lst.size();
for( int i=0 ; i<listSize ; i++ ) {
final String item = lst.get(i);
System.out.print(item);
System.out.print("==");
System.out.println(item);
}
}--------------------------
run 결과
size call
get call A==A
get call B==B
get call C==C그 외 규칙이 더 있겠지만 당장 생각나는 규칙은 이상 4가지. 음. 별거 없네?
