[이것이 자바다]CH13.제네릭(확인문제풀이)

1. 제네릭에 대한 설명으로 틀린 것은 무엇입니까?

① 컴파일 시 강한 타입 체크를 할 수 있다.

② 타입 변환(casting)을 제거한다.

③ 제네릭 타입은 타입 파라미터를 가지는 제네릭 클래스와 인터페이스를 말한다.

④ 제네릭 메소드는 리턴 타입으로 타입 파라미터를 가질 수 없다.

 

☞ ④ 제네릭 메소드는 리턴 타입으로 타입 파라미터를 가질 수 없다.

제네릭 메소드는 리턴 타입과 매개 변수 타입으로 타입 파라미터를 가질 수 있다.

ex) public static <T> T methodA (T t1, T t2){    return t1;}

 

2. ContainerExample 클래스의 main() 메소드는 Container 제네릭 타입을 사용하고 있습니다. main() 메소드에서 사용하는 방법을 참고해서 Container 제네릭 타입을 선언해보세요.

public class ContainerExample{
	public static void main(String[] args){
    	Container<String> container1 = new Container<String>();
        container1.set("홍길동");
        String str = container1.get();
        
        Container<Integer> container2 = new Container<Integer>();
        container2.set(6);
        int value = container2.get();
    }
}

public class Container <T> {
	private T t;
    public T get(){
    	return t;
    }
    public void set(T t){
    	this.t = t;
    }
}

 

3. ContainerExample 클래스의 main() 메소드는 Container 제네릭 타입을 사용하고 있습니다. main() 메소드에서 사용하는 방법을 참고해서 Container 제네릭 타입을 선언해보세요.

public class ContainerExample {
	public static void main(String[] args){
    	Container<String, String> container1 = new Container<String, String>();
        container1.set("홍길동", "도적");
        String name = container1.getKey();
        String job = container1.getValue();
        System.out.println(name + " , " + job);
        
        Container<String, Integer> container2 = new Container<String, Integer>();
        container2.set("홍길동", 35);
        String name2 = container2.getKey();
        String age = container2.getValue();
        System.out.println(name2 + " , " + age);
    }
}

public class Container <K, V> {
	private K k;
	private V v;
	public K getKey() {
		return k;
	}
	public void set(K k, V v) {
		this.k = k;
		this.v = v;
	}
	public V getValue() {
		return v;
	}	
}

4. Util.gatValue() 메소드는 첫 번째 매개값으로 Pair타입과 하위 타입만 받고, 두 번째 매개값으로 키값을 받습니다. 리턴값은 키값이 일치할 경우 Pair에 저장된 값을 리턴하고, 일치하지 않으면 null을 리턴하도록 getValue() 제네릭 메소드를 정의해보세요.

public class UtilExample {
	public static void main(String[] args) {
		Pair<String, Integer> pair = new Pair<>("홍길동", 35);
		Integer age = Util.getValue(pair, "홍길동");
		System.out.println(age);
		
		ChildPair<String, Integer> childPair = new ChildPair<>("홍삼원", 20);
		Integer childAge = Util.getValue(childPair, "홍삼순");
		System.out.println(childAge);
		
		/*
		OtherPair<String , Integer> otherPair = new OtherPair<>("홍삼원", 20);
		int otherAge = Util.getValue(otherPair, "홍삼원");
		System.out.println(otherAge);
		*/
	}
}

public class Pair <K,V> {
	private K key;
	private V value;

	public Pair(K key, V value) {
		this.key = key;
		this.value = value;				
	}
	public K getKey() {
		return key;
	}
	public V getValue() {
		return value;
	}
}

public class ChildPair <K, V> extends Pair<K,V>{
	public ChildPair(K k, V v) {
		super(k, v);
	}
}

public class OtherPair <K,V>{
	private K key;
	private V value;
	public OtherPair(K key, V value) {
		this.key = key;
		this.value = value;				
	}
	public K getKey() {
		return key;
	}
	public V getValue() {
		return value;
	}
}

public class Util {
	public static <K, V> V getValue(Pair<K,V> p, K k) {
		if(p.getKey().equals(k)) {
			return p.getValue();			
		}else {
			return null;
		} 
	}
}