Hello world

자바에서 열거형이 무엇인지 알려드릴게요.

먼저 열거란 무엇인지 사전을 볼까요???

열거 : 여러 가지 예나 사실을 낱낱이 죽 늘어놓음.

죽~ 늘어놓음.

열거형도 마찬가지예요.

관련된 상수들을 죽 늘어놓은 거예요.

여기서 중요한 것은 모두 상수!!라는 점~

어쩔 때 쓰이냐면

달력을 만든다고 할 때

월요일 화요일 수요일 목요일 ...

이렇게 쓰는 것보다

월요일 = 1

화요일 = 2

수요일 = 3

...

​ 

이런 식으로 코드화해 놓는 게 효과적일 거예요.

이런 상수들을 모아놓아서 활용하기 쉽게 해주는 것이 열거형이에요.

열거형이라고 하니 자료형과 비슷한 것 같죠?

맞아요!!

자료형처럼 열거형 안에 있는 상수들은 열거형으로 선언돼요!

int a;와 같이

열거형명 데이터;로 표현돼요.

먼저 열거형을 살펴보기 전에

열거형이 없을 때 어떻게 상수들을 선언했을지 살펴볼게요.

우선 변수로 상수를 선언!!

private final static int MONDAY = 1;

private final static int TUESDAY = 2;

private final static int WEDNESDAY = 3;

private final static int THURSDAY = 4;

private final static int FRIDAY = 5;

private final static int SATURDAY = 6;

private final static int SUNDAY = 7;

이런 식으로 사용하기도 해요.

이때의 문제점은 한번 선언된 변수명을 중복 사용할 수 없다는 것과

상수를 추가해야 할 경우 내용이 많아지며 메모리 공간을 많이 차지한다는 점이에요.

그래서

public final static이 생략되어있는

인터페이스를 이용하거나 class를 이용해요.

interface Day{

    int MONDAY = 1;

    int TUESDAY = 2;

    int WEDNESDAY = 3;

    int THURSDAY = 4;

    int FRIDAY = 5;

    int SATURDAY = 6;

    int SUNDAY = 7;

}

여기서 interface를 이용할 경우에 문제가 있어요.

A1과 A2라는 인터페이스를 만들었을 때

두 인터페이스는 서로 다른 타입이기 때문에 비교가 불가능해야 해요.

그런데 if(A1 == A2) 를 했을 경우 경고 메시지를 볼 수 없다는 것이 문제에요.

그래서

Class를 정의해 사용합니다.

class Day{

   public final static Day MONDAY = new Day();

   public final static Day TUESDAY = new Day();

   public final static Day WEDNESDAY = new Day();

   public final static Day THURSDAY = new Day();

   public final static Day FRIDAY = new Day();

   public final static Day SATURDAY = new Day();

   public final static Day SUNDAY = new Day();

}

마찬가지로 class를 이용할 때도 문제가 있는데

switch 문에서 사용이 불가능하다는 것이에요.

switch(조건)

여기서 조건에 들어가는 데이터 타입이 제한적이라

class를 정의해서 사용할 경우 에러가 발생해요.

이런 문제점을 해결해 주는 것이 enum이에요.

enum Day{

           MONDAY,TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;

}

public class EnumStudy {

           public static void main(String[] args) {

                     // TODO Auto-generated method stub

                     System.out.println("월요일 : " + Day.MONDAY);

                     System.out.println("화요일 : " + Day.TUESDAY);

                     System.out.println("수요일 : " + Day.WEDNESDAY);

                     System.out.println("목요일 : " + Day.THURSDAY);

                     System.out.println("금요일 : " + Day.FRIDAY);

                     System.out.println("토요일 : " + Day.SATURDAY);

                     System.out.println("일요일 : " + Day.SUNDAY);

           }

}

또한 숫자를 사용하고 싶다면 아래처럼 해주면 됩니다.

enum Code{

           ONE(1), TWO(2), THREE(3);

          

           Code(int num){//생성자

                     CodeNum = num;

           }

           int CodeNum;

           public int getCodeNum(){

                     return CodeNum;

           }

}

public class EnumStudy {

           public static void main(String[] args) {

                     // TODO Auto-generated method stub

                     System.out.println(Code.ONE + " : " + Code.valueOf("ONE").getCodeNum());

                     System.out.println(Code.TWO + " : " + Code.valueOf("TWO").getCodeNum());

                     System.out.println(Code.THREE + " : " + Code.valueOf("THREE").getCodeNum());

           }

}

enum을 이용할 때 생성자는 자동으로 private로 선언돼요.

그래서 타입의 안정성이 보장돼요.

외부에서 접근이 불가능하며 new 키워드로 생성할 수도 없어요.

물론 clone(복사)도 하지 못한답니다~ 

2.1 열거형 이란?

 - 실제 값이 같아도 타입이 다르면 조건식의 결과가 false가 된다.

 

예)

class Card{

static final int CLOVER = 0;

static final int HEART = 1;

static final int DIAMOND = 2;

static final int SPADE = 3;

 

static final int TWO = 0;

static final int THREE = 1;

static final int FOUR = 2;

 

final int kind;

final int num;

}

=>

class Card {

enum Kind { CLOVER, HEART, DIAMOND, SPADE }

enum Value { TWO, THREE, FOUT }

 

final Kind kind;

final Value value;

}

 

if (Card.CLOVER == Card.TWO) // true 지만 false이어야 의미상 맞음

if (Card.kind.CLOVER == Card.Value.TWO) // false. 값은 같지만 타입이 다름

 

2.2 열거형의 정의와 사용

 - enum 열거형 이름 { 상수명1, 상수명2, ...}

 

enum Direction {EAST , SOUTH, WEST, NORTH}

 

class Unit{

int x,y; // 유닛의 위치

Direction dir; // 열거형을 인스턴스 변수로 선언

 

void init(){

dir = Direction.EAST; // 유닛의 방향을 EAST로 초기화

}

}

 

- 상수간 비교에는 '=='를 사용할 수 있다.

'<','>' 처럼비교연산자는 사용할 수 없고 compareTo()는 사용가능 하다. compareTo()는 두 비교대상이 같으면 0, 왼쪽이 크면 양수, 오른쪽이 크면 음수를 반환한다.

 

if (dir ==Direction.EAST){

x++;

}

else if (dir>Direction.WEST){ // 비교연산자 사용불가.

}

 

else if (dir.compareTo(Direction.WEST) >0){

}

 

- switch문의 조건식에도 열거형을 사용할 수 있다.

void move(){

switch(dir){

case EAST: x++; // Direction.EAST라고 쓰면안됨.

break;

case WEST: x--;

break;

case SOUTH: y++;

break;

case NORTH: y--;

break;

}

}

 

 // case문에 열거형의 이름은 적지 않고 상수의 이름만 적어야 한다는 제약이 있다.

 

- 열거형의 조상 java.lang.Enum

열거형 Direction에 정의된 모든 상수를 출력하려면?

 

Direction[] dArr = Direction.Values();

 

for (Direction d : dArr)

System.out.printf("%s = %d%n", d.name(), d.ordinal());

 

- Values() 는 열거형의 모든 상수를 배열에 담아 반환한다. 이 메서드는 모든 열거형이 가지고 있는것으로 컴파일러가 자동으로 추가해 준다.

- ordinal()은 모든 열거형의 조상인 java.lang.Enum클래스에 정의된 것으로 열거형 상수가 정의된 순서를 정수로 반환한다.

 

이외 Enum클래스 메서드 정의

- Calss <E> getDeclaringCalss() : 열거형의 calss객체를 반환한다.

- String name() : 열거형의 상수의 이름을 문자열로 반환한다.

- int ordinal() : 열거형 상수가 정의된 순서를 반환한다.(0부터시작)

- T valueOf(Calss<T> enumType, Sting name) : 지정된 열거형에서 name과 일치하는 열거형 상수를 반환한다.

 

 

 

 

예제.

 

 

package enumeration;

enum Direction { EAST, SOUTH, WEST, NORTH}

 

public class enums{

        public static void main(String[] args) {

               Direction d1 = Direction.EAST;

               Direction d2 = Direction.valueOf("WEST");

               Direction d3 = Enum.valueOf(Direction.class, "EAST");

              

               System.out.println("d1="+d1);

               System.out.println("d2="+d2);

               System.out.println("d3="+d3);

              

               System.out.println("d1 ==d2 ?" +(d1==d2));

               System.out.println("d1 ==d3 ?" +(d1==d3));

               System.out.println("d1.equals(d3) ?" +d1.equals(d3));

               //System.out.println("d2>d3?" +(d1>d3)); // 에러

               System.out.println("d1.compareTo(d3)?" +(d1.compareTo(d3)));

               System.out.println("d1.compareTo(d2)?" +(d1.compareTo(d2)));

              

               switch(d1) {

               case EAST:

                       System.out.println("The direction is EAST.");

                       break;

               case SOUTH:

                       System.out.println("The direction is SOUTH");

                       break;

               case WEST:

                       System.out.println("The direction is WEST");

                       break;

               case NORTH:

                       System.out.println("The direction is NORTH");

                       break;

               default:

                       System.out.println("Invalid direction.");

                       break;

               }

              

               Direction[] dArr = Direction.values();

              

               for(Direction d: dArr)

                       System.out.printf("%s=%d%n", d.name(),d.ordinal());

        }

}

 

 

출력 결과 :

d1=EAST
d2=WEST
d3=EAST
d1 ==d2 ?false
d1 ==d3 ?true
d1.equals(d3) ?true
d1.compareTo(d3)?0
d1.compareTo(d2)?-2
The direction is EAST.
EAST=0
SOUTH=1
WEST=2
NORTH=3

 

2.3 열거형에 멤버 추가하기.

 

열거형 상수의 값이 불규칙적인 경우 이때는 다음과 같이 열거형 상수의 이름 옆에 원하는 값을 괄호()와 함께 적어주면 된다.

 

enum Direction { EAST(1), SOUTH(5), West(-1), NORTH(10)}

 

그리고 지정된 값을 저장할 수 있는 인스턴스 변수와 생성자를 새로 추가해 주어야 한다.

 주의할 점은 열거형 상수를 정의한 다음에 다른 멤버들을 추가해야 한다.

 

enum Direction {

EAST(1), SOUTH(5), West(-1), NORTH(10);

 

private final int value; // 정수를 저장할 필드(인스턴스 변수)

Direction(int value){this.value = value;}

 

public int getValue(){ return value;}

}

 

// Direction d = new Direction(1); 에러. 열거형의 생성자는 외부에서 호출 불가.

 

열거형의 생성자는 제어가자 묵시적으로 private이다.

 

필요에 따라 열거형 상수에 여러 값을 지정할 수도 있다. 다만 그에 맞게 인스턴스 변수와 생성자 등을 새로 추가해 주어야 한다.

 

enum Direction {

EAST (1,">"), SOUTH(2,"V"), WEST(3,"<"), NORTH(4,"^");

 

private final int value;

private final String symbol;

 

Direction(int value, Sting symbol){

this.value = value;

this.symbol = symbol;

}

 

public int getValue(){ return value;}

public String getSymbol() { return symbol;}

}

 

예제 2.

package enumeration;

enum Direction {

        EAST (1,">"), SOUTH(2,"V"), WEST(3,"<"), NORTH(4,"^");

       

        private static final Direction[] DIR_ARR = Direction.values();

        private final int value;

        private final String symbol;

       

        Direction(int value, String symbol){

               this.value = value;

               this.symbol = symbol;

        }

 

 

        public int getValue() {return value;}

        public String getSymbol() {return symbol;}

       

        public static Direction of(int dir) {

               if (dir <1||dir >4) {

                       throw new IllegalArgumentException("Invalid value :"+dir);

               }

               return DIR_ARR[dir-1];

        }

        public Direction rotate(int num) {

               num = num%4;

               if(num <0)num+=4;

               return DIR_ARR[(value-1+num)%4];

        }

        public String otString() {

               return name()+getSymbol();

        }

}

public class enums1 {

 

        public static void main(String[] args) {

               for(Direction d: Direction.values())

                       System.out.printf("%s=%d%n", d.name(),d.getValue());

       

        Direction d1 = Direction.EAST;

        Direction d2 = Direction.of(1);

       

        System.out.printf("d1=%s, %d%n", d1.name(),d1.getValue());

        System.out.printf("d2=%s, %d%n", d2.name(),d2.getValue());

       

        System.out.println(Direction.EAST.rotate(1));

        System.out.println(Direction.EAST.rotate(2));

        System.out.println(Direction.EAST.rotate(-1));

        System.out.println(Direction.EAST.rotate(-2));

        }

 

}

 

 

출력 결과:

 EAST=1

SOUTH=2

WEST=3

NORTH=4

d1=EAST, 1

d2=EAST, 1

SOUTH

WEST

NORTH

WEST

}

모든 열거형은 추상 클래스 Enum의 자손이므로, Enum을 흉내 내서 MyEnum을 작성하면 다음과 같다.

abstract class MyEnum<T extends MyEnum<T>> implements Comparable<T> {

static int id =0; // 객체에 붙일 일련번호

int ordinal;

String name ="";

public int ordinal(){ return ordinal;}

MyEnum(String name){

this.name =name;

ordinal =id++;

}

public int compareTo(T t){

return ordinal - t.ordinal();

}

}

/*

객체가 생성될 때마다 번호를 붙여서 인스턴스 변수 ordinal 에 저장, 그리고 comparable 인터페이스를 구현해서 열거형 상수간의 비교가 가능하도록 되어있다.

두 열거형 상수의 ordinal값을 서로 빼주기만 하면 된다. 만일 클래스를 MyEnum<T>와 같이 선언하였다면, compareTo()를 위와 같이 간단히 작성할 수 없었을 것이다. 타입 T에 ordinal()이 정의되어 있는지 확인할 수 없기 때문이다.

*/ 이해가 잘안가는 부분...

abstract class MyEnum<T> implements Comparable<T> {

public int compareTo(T t) {

return ordinal - t.ordinal(); // 에러 타입 T에 ordinal()이 있나?

}

}

그래서 MyEnum<T extends MyEnum<T>>와 같이 선언 한 것이며, 이것은 타입 T가 MyEnum<T>의 자손이어야 한다는 의미이다. 타입 T가 MyEnum의 자손이므로 ordinal()이 정의되어 있는 것은 분명하므로 형변환 없이도 에러가 나지 않는다.

추상 메서드를 새로 추가하면, 클래스 앞에도 abstract를 붙여줘야 하고, 각 static 상수들도 추상 메서드를 구현해 주어야 한다. 아래의 코드에서 익명의 클래스의 형대로 추상메서드를 구현한 예이다.

abstract class Direction extends MyEnum {

static final Direction EAST = new Direction("EAST"){

point move(Point p) {}

};

static final Direction SOUTH = new Direction("SOUTH"){

point move(Point p) {}

};