매 거 유형 (2): 계승, 무 작위 선택, 인터페이스 조직 매 거 가 아 닌 실현

계승 이 아니 라 실현
    우 리 는 모든 enum 이 자바. lang. Enum 류 에서 계승 되 었 다 는 것 을 이미 알 고 있다.자바 는 다 중 계승 을 지원 하지 않 기 때문에, 당신 의 enum 은 다른 종 류 를 계승 할 수 없습니다:

enum NotPossible extends Pet{ }

    그러나 우리 가 새로운 enum 을 만 들 때 하나 이상 의 인 터 페 이 스 를 동시에 실현 할 수 있 습 니 다.

package enumerated.cartoons;

import java.util.Random;

import com.buba.util.Generator;

enum CartoonCharacter implements Generator {
	SLAPPY, SPANKY, PUNCHY, SILLY, BOUNCY, NUTTY, BOB;

	Random r = new Random();

	@Override
	public CartoonCharacter next() {
		return values()[r.nextInt(values().length)];
	}

}

public class EnumImplementation {
	public static  void printNext(Generator rg) {
		System.out.print(rg.next() + ", ");
	}

	public static void main(String[] args) {
		CartoonCharacter cc = CartoonCharacter.BOB;
		for (int i = 0; i < 10; i++) {
			printNext(cc);
		}
	}
}

    이 결 과 는 좀 이상 하지만, 너 는 반드시 enum 실례 가 있어 야만 그 위의 방법 을 호출 할 수 있다.현재 Generator 인 자 를 받 아들 이 는 모든 방법 에서 printNext () 는 Cartoon Character 를 사용 할 수 있 습 니 다.
2. 무 작위 선택
    Cartoon Character. next () 에서 보 듯 이 이 장의 많은 예 는 enum 인 스 턴 스 에서 무 작위 로 선택해 야 합 니 다.우 리 는 범 형 을 이용 하여 이 일 을 더욱 일반화 시 키 고 이 를 우리 의 도구 창고 에 넣 을 수 있다.

package com.buba.util;

import java.util.Random;

public class Enums {
	private static Random r = new Random();

	public static > T random(Class ec) {
		return random(ec.getEnumConstants());
	}

	public static  T random(T[] values) {
		return values[r.nextInt(values.length)];
	}
}

    이상 한 문법 > T 는 enum 인 스 턴 스 임 을 나타 낸다.클 라 스 를 매개 변수 로 하면 클 라 스 대상 을 이용 하여 enum 인 스 턴 스 의 배열 을 얻 을 수 있 습 니 다.다시 불 러 오 면 random () 방법 은 T [] 를 매개 변수 로 사용 합 니 다. Enum 의 모든 동작 을 호출 하지 않 기 때문에 배열 에서 하나의 요 소 를 무 작위 로 선택 하면 됩 니 다.이렇게 해서 최종 반환 유형 은 바로 enum 의 유형 입 니 다.
    다음은 random () 방법의 간단 한 예 입 니 다.

package enumerated;

import com.buba.util.Enums;

enum Activity {
	SITTING, LYING, STANDING, HOPPING, RUNNING, DODGING, JUMPING, FALLING, FLYING
}

public class RandomTest {
	public static void main(String[] args) {
		for (int i = 0; i < 20; i++) {
			System.out.print(Enums.random(Activity.class) + " ");
		}
	}
}

    Enum 은 아주 짧 은 종류 이지 만 이 장 에서 중복 되 는 코드 를 많이 없 앨 수 있다 는 것 을 알 게 될 것 이다.반복 은 문 제 를 일 으 킬 수 있 기 때문에 중복 을 없 애 는 것 은 항상 유익 하 다.
3. 인터페이스 조직 매 거
    enum 에서 자 류 를 물 려 받 지 못 하 는 것 은 때때로 우울 하 다.이러한 수 요 는 때때로 우리 가 원 enum 의 요 소 를 확장 하 기 를 원 하 는 데 서 비롯 되 고, 때로는 하위 클래스 를 사용 하여 하나의 enum 중의 요 소 를 그룹 으로 나 누 기 를 원 하기 때문이다.
    인터페이스 내부 에서 이 인 터 페 이 스 를 실현 하 는 매 거 진 을 만 들 고 요 소 를 그룹 으로 나 누 면 매 거 진 요 소 를 조직 하 는 목적 을 달성 할 수 있 습 니 다.예 를 들 어 enum 으로 서로 다른 유형의 음식 을 표시 하고 싶다 고 가정 하 는 동시에 모든 enum 요소 가 Food 유형 을 유지 하 기 를 바란다.그러면 이렇게 실현 할 수 있다.

package enumerated.menu;

public interface Food {
	enum Appetizer implements Food {
		SALAD, SOUP, SPRING_ROLLS;
	}

	enum MainCourse implements Food {
		LASAGNE, BURRITO, PAD_THAI, LENTILS, HUMMOUS, VINDALOO;
	}

	enum Dessert implements Food {
		TIRAMISU, GELATO, BLACK_FOREST_CAKE, FRUIT, CREME_CARAMEL;
	}

	enum Coffee implements Food {
		BLACK_COFFEE, DECAF_COFFEE, ESPRESSO, LATTE, CAPPUCCINO, TEA, HERB_TEA;
	}
}

    enum 의 경우 인 터 페 이 스 를 실현 하 는 것 이 하위 클래스 화 하 는 유일한 방법 이기 때문에 Food 에 포 함 된 모든 enum 은 Food 인 터 페 이 스 를 실현 했다.현재 다음 프로그램 에서 우 리 는 '모든 것 이 특정한 유형의 Food' 라 고 말 할 수 있다.

package enumerated.menu;

import enumerated.menu.Food.Appetizer;
import enumerated.menu.Food.Coffee;
import enumerated.menu.Food.Dessert;
import enumerated.menu.Food.MainCourse;

public class TypeOfFood {
	public static void main(String[] args) {
		Food food = Appetizer.SALAD;
		food = MainCourse.LASAGNE;
		food = Dessert.GELATO;
		food = Coffee.CAPPUCCINO;
	}
}

    만약 에 enum 유형 이 Food 인 터 페 이 스 를 실현 한다 면 우 리 는 그 실례 를 Food 로 전환 할 수 있 기 때문에 상례 의 모든 것 이 Food 이다.
    그러나 많은 유형 과 접촉 해 야 할 때 인 터 페 이 스 는 enum 보다 좋 지 않다.예 를 들 어 '매 거 진 매 거 진' 을 만 들 려 면 새로운 enum 을 만 든 다음 에 Food 의 모든 enum 류 를 인 스 턴 스 로 포장 할 수 있 습 니 다.

package enumerated.menu;

import com.buba.util.Enums;

public enum Course {
	APPETIZER(Food.Appetizer.class), MAINCOURSE(Food.MainCourse.class), DESSERT(Food.Dessert.class),
	COFFEE(Food.Coffee.class);

	private Food[] values;

	private Course(Class extends Food> kind) {
		values = kind.getEnumConstants();
	}

	public Food randomSelection() {
		return Enums.random(values);
	}
}

    위의 프로그램 에서 모든 Course 의 인 스 턴 스 는 해당 하 는 Class 대상 을 구조 기의 매개 변수 로 합 니 다.getEnumConstants () 방법 을 통 해 이 Class 대상 에서 어떤 Food 하위 클래스 의 모든 enum 인 스 턴 스 를 얻 을 수 있 습 니 다.이 인 스 턴 스 는 random Selection () 에서 사 용 됩 니 다.따라서 모든 Course 인 스 턴 스 에서 푸드 를 무 작위 로 선택 하면 메뉴 를 만 들 수 있 습 니 다.

package enumerated.menu;

public class Meal {
	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			for (Course course : Course.values()) {
				Food food = course.randomSelection();
				System.out.println(food);
			}
			System.out.println("-----------");
		}
	}
}

    이 예 에서 우 리 는 모든 Course 인 스 턴 스 를 옮 겨 다 니 며 '매 거 진 매 거 진' 값 을 얻 을 수 있 습 니 다.잠시 후, VendingMachine. 자바 에서 우 리 는 다른 조직 이 인 스 턴 스 를 매 거 하 는 방식 을 보 았 으 나, 그것 도 다른 제한 이 있 습 니 다.
    또 하나의 enum 을 다른 enum 에 끼 워 넣 는 보다 간결 한 관리 방법 도 있다.이렇게:

package enumerated;

import com.buba.util.Enums;

public enum SecurityCategory {
	STOCK(Security.Stock.class), BOND(Security.Bond.class);

	Security[] values;

	SecurityCategory(Class extends Security> kind) {
		values = kind.getEnumConstants();
	}

	interface Security {
		enum Stock implements Security {
			SHORT, LONG, MARGIN
		}

		enum Bond implements Security {
			MUNICIPAL, JUNK
		}
	}

	public Security randomSelection() {
		return Enums.random(values);
	}

	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			SecurityCategory category = Enums.random(SecurityCategory.class);
			System.out.println(category + ": " + category.randomSelection());
		}
	}
}

    Security 인터페이스의 역할 은 포 함 된 enum 을 하나의 공공 유형 으로 조합 하 는 것 이 필요 하 다.그 다음 에 Security Category 는 Security 의 enum 을 구조 기의 매개 변수 로 사용 하여 조직 적 인 효 과 를 낼 수 있 습 니 다.
    만약 우리 가 이런 방식 을 Food 의 예 에 응용 한다 면 결 과 는 이렇게 해 야 한다.

package enumerated.menu;

import com.buba.util.Enums;

public enum Meal2 {
	APPETIZER(Food.Appetizer.class), MAINCOURSE(Food.MainCourse.class), DESSERT(Food.Dessert.class),
	COFFEE(Food.Coffee.class);

	private Food[] values;

	private Meal2(Class extends Food> kind) {
		values = kind.getEnumConstants();
	}

	public interface Food {
		enum Appetizer implements Food {
			SALAD, SOUP, SPRING_ROLLS;
		}

		enum MainCourse implements Food {
			LASAGNE, BURRITO, PAD_THAI, LENTILS, HUMMOUS, VINDALOO;
		}

		enum Dessert implements Food {
			TIRAMISU, GELATO, BLACK_FOREST_CAKE, FRUIT, CREME_CARAMEL;
		}

		enum Coffee implements Food {
			BLACK_COFFEE, DECAF_COFFEE, ESPRESSO, LATTE, CAPPUCCINO, TEA, HERB_TEA;
		}
	}

	public Food randomSelection() {
		return Enums.random(values);
	}

	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			for (Meal2 meal : Meal2.values()) {
				Food food = meal.randomSelection();
				System.out.println(food);
			}
			System.out.println("-------------");
		}
	}
}

    사실은 이것 은 코드 를 재 구성 한 것 일 뿐 이지 만 대부분 상황 에서 이런 방식 은 당신 의 코드 를 더욱 뚜렷 한 구 조 를 가지 게 합 니 다.
만약 본문 이 당신 에 게 큰 도움 이 된다 면, 좋아요 도 눌 러 주시 기 바 랍 니 다.