[Java 고급] 5장 가변형 인수, Generics 클래스&메소드

 

가변형 인수

 

: 매개변수로 들어오는 값의 개수와 상관 없이 인수를 받아 기능하도록 해주는 문법

한가지 자료형만 사용할 수 있으며, 메서드 안에서는 배열로 처리된다.

 

+

파라미터 : 정보를 제공할 때 사용하는 값

인수 : 들어오는 시점의 값

 

 

package kr.or.ddit.basic;

public class T01ArgsTest {
	/*
	 * 가변형 인수 => 메서드의 매개변수의 개수가 실행될 때마다 다를때 사용한다.
	 * 
	 * 	- 가변형 인수는 메서드 안에서는 배열로 처리된다.
	 *  - 가변형 인수는 한가지 자료형만 사용할 수 있다.
	 */
	
	// 배열을 이용한 메서드
	// 매게변수로 받은 정수들의 합계를 구하는 메서드
	public int sumArr(int[] data) {
		int sum = 0;
		for (int i = 0; i < data.length; i++) {
			sum += data[i];
		}
		return sum;
	}
	
	// 가변형 인수를 이용한 메서드
	public int sumArg(int...data) {
		int sum = 0;
		for (int i = 0; i < data.length; i++) {
			sum += data[i];
		}
		return sum;
	}
	
	// 가변형 인수와 일반적인 인수를 같이 사용할 경우에는  가변형 인수를 제일 뒤쪽에 배치해야 한다.
	public String sumArg2(String name, int...data) {
		int sum = 0;
		for (int i = 0; i < data.length; i++) {
			sum += data[i];
		}
		return name + "씨  점수 : " + sum;
	}
	
	public static void main(String[] args) {
		T01ArgsTest at = new T01ArgsTest();
		
		int[] nums = {100, 200, 300};
		System.out.println(at.sumArg(nums));
		System.out.println(at.sumArr(new int[] {1,2,3,4,5}));
		System.out.println();
		
		System.out.println(at.sumArg(100, 200, 300));
		System.out.println(at.sumArg(1,2,3,4,5));
		System.out.println();
		
		System.out.println(at.sumArg2("홍길동", 1,2,3,4,5,6,7,8,9));
	}
}

 

결과 화면1

 

 

 

제너릭 (Generics) 클래스

 

: 클래스를 사용할 때 타입을 지정한 후 사용하는 기술

 

 

- 장점

1. 컴파일시 잘못된 타입 사용 체크

2. 불필요한 타입변환을 하지 않아도 됨 (=> 프로그램 성능 향상)

 

 

• 사용 방법

package kr.or.ddit.basic;

public class T02GenericClassTest {
	/*
	 * 제너릭 클래스 만드는 방법
	 * 
	 * 형식 )
	 *  class 클래스명<제너릭타입글자, 제너릭타입글자> {
	 *    제너릭타입글자 변수명;	// 변수선언에 제너릭을 사용하는 경우
	 *    ...
	 *    
	 *    제너릭타입글자 메서드명() { // 반환값이 있는 메서드에 제너릭을 사용하는 경우
	 *    
	 *      ...
	 *    
	 *      return 값;
	 *    }
	 *  }
	 * -- 제너릭타입글자 --
	 * T => Type
	 * K => Key
	 * V => Value
	 * E => Element
	 * 
	 */
}

class NonGenericClass {
	private Object val;

	public Object getVal() {
		return val;
	}

	public void setVal(Object val) {
		this.val = val;
	}
}

class MyGeneric<T> {
	private T val;

	public T getVal() {
		return val;
	}

	public void setVal(T val) {
		this.val = val;
	}
}

 

 

제너릭을 사용할시 불필요한 캐스팅을 하지 않아도 됨

package kr.or.ddit.basic;

import java.util.Map;

public class T02GenericClassTest {
	/*
	 * 제너릭 클래스 만드는 방법
	 * 
	 * 형식 )
	 *  class 클래스명<제너릭타입글자, 제너릭타입글자> {
	 *    제너릭타입글자 변수명;	// 변수선언에 제너릭을 사용하는 경우
	 *    ...
	 *    
	 *    제너릭타입글자 메서드명() { // 반환값이 있는 메서드에 제너릭을 사용하는 경우
	 *    
	 *      ...
	 *    
	 *      return 값;
	 *    }
	 *  }
	 * -- 제너릭타입글자 --
	 * T => Type
	 * K => Key
	 * V => Value
	 * E => Element
	 * 
	 */
	
	public static void main(String[] args) {
		NonGenericClass ng1 = new NonGenericClass();
		ng1.setVal("가나다라");
		
		NonGenericClass ng2 = new NonGenericClass();
		ng2.setVal(100);
		
		String rtnVal1 = (String) ng1.getVal();
		System.out.println("문자열 반환값 rtnVal1 => " + rtnVal1);
		
		Integer rtnVal2 = (Integer) ng2.getVal();
		System.out.println("정수형 반환값 rtnVal2 => " + rtnVal2);
		
		System.out.println();
		
		
		// 제너릭 클래스이기에 타입을 알려줘야함
		MyGeneric<String> mg1 = new MyGeneric<String>();
		mg1.setVal("우리나라");
		
		MyGeneric<Integer> mg2 = new MyGeneric<Integer>();
		mg2.setVal(200);
		
		rtnVal1 = mg1.getVal();
		rtnVal2 = mg2.getVal();
		
		System.out.println("제너릭 문자열 반환값 : " + rtnVal1);
		System.out.println("제너릭 정수형 반환값 : " + rtnVal2);
	}
}

class NonGenericClass {
	private Object val;

	public Object getVal() {
		return val;
	}

	public void setVal(Object val) {
		this.val = val;
	}
}

class MyGeneric<T> {
	private T val;

	public T getVal() {
		return val;
	}

	public void setVal(T val) {
		this.val = val;
	}
}

 

결과 화면2

 

 

 

제너릭 (Generics) 메소드

 

: 파라미터 타입과 리턴타입으로 타입글자를 가지는 메서드

리턴 타입 앞에 꺽쇠(<>)와 메소드 내에서 사용하는 타입글자가 적혀 있는 메소드를 이야기한다.

 

ex) 

public static <타입글자> 리턴타입 메소드 이름(클래스<타입글자> 파라미터명)

 

 

package kr.or.ddit.basic;

class Util {
	/*
	 * 제너릭 메서드 <T, R> R 메서드이름(T t)
	 * 
	 * 파라미터 타입과 리턴타입으로 타입글자를 가지는 메서드
	 * 
	 * 선언방법 : 리턴타입 앞에 <> 기호를 추가하고 타입글자를 기술한 후 사용함
	 */
	public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
		boolean keyCompare = p1.getKey().equals(p2.getKey());
		boolean valueCompare = p1.getValue().equals(p2.getValue());
		
		return keyCompare && valueCompare;
	}
}

/**
 * 멀티타입<K, V>을 가지는 제너릭 클래스
 * @param <K>
 * @param <V>
 */
class Pair<K, V> {
	private K key;
	private V value;
	
	public Pair(K key, V value) {
		super();
		this.key = key;
		this.value = value;
	}
	
	public K getKey() {
		return key;
	}
	public void setKey(K key) {
		this.key = key;
	}
	public V getValue() {
		return value;
	}
	public void setValue(V value) {
		this.value = value;
	}
}


public class T03GenericMethodTest {
	public static void main(String[] args) {
		Pair<Integer, String> p1 = new Pair<Integer, String>(1, "홍길동");
		Pair<Integer, String> p2 = new Pair<Integer, String>(1, "홍길동");
		
		boolean result = Util.<Integer, String>compare(p1, p2);
		
		if(result) {
			System.out.println("두 객체는 논리적으로 동일한 객체임");
		} else {
			System.out.println("두 객체는 논리적으로 동일한 객체가 아님");
		}
		System.out.println();
		
		
		Pair<String, String> p3 = new Pair<String, String>("001", "홍길동");
		Pair<String, String> p4 = new Pair<String, String>("002", "홍길동");
		
		result = Util.<String, String>compare(p3, p4);
		
		if(result) {
			System.out.println("두 객체는 논리적으로 동일한 객체임");
		} else {
			System.out.println("두 객체는 논리적으로 동일한 객체가 아님");
		}
	}
}

 

결과 화면3

 

 

package kr.or.ddit.basic;

class Util {
	public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
		boolean keyCompare = p1.getKey().equals(p2.getKey());
		boolean valueCompare = p1.getValue().equals(p2.getValue());
		
		return keyCompare && valueCompare;
	}
}

/**
 * 멀티타입<K, V>을 가지는 제너릭 클래스
 * @param <K>
 * @param <V>
 */
class Pair<K, V> {
	private K key;
	private V value;
	
	public Pair(K key, V value) {
		super();
		this.key = key;
		this.value = value;
	}
	
	public K getKey() {
		return key;
	}
	public void setKey(K key) {
		this.key = key;
	}
	public V getValue() {
		return value;
	}
	public void setValue(V value) {
		this.value = value;
	}
	
	// 키와 값을 모두 출력하기
	public void displayKeyValue(K key, V value) {
		System.out.println(key.toString() + " : " + value.toString());
	}
}


public class T03GenericMethodTest {
	public static void main(String[] args) {
		Pair<Integer, String> p1 = new Pair<Integer, String>(1, "홍길동");
        
		// displayKeyValue가 제너릭 메소드가 아니기에 p1에 선언된 타입에 맞춰 값을 넣어야 함
		p1.displayKeyValue(100, "키");
	}
}

 

 

=> 모든 타입이 아닌 제한하여 파라미터를 받고 싶음

제한된 타입 파라미터 문법을 사용하게 되었다.