5월 9일 내용정리-1
1.제한된 타입 파라미터
<T extends 최상위타입> T에 들어오는 타입을 제한 하고 싶을때 쓰임.
최상위타입에는 class도 들어 갈수있고, interface도 들어갈수 있다(왜? 구현이아니라 제한이기때문)
2.public <T extends 최상위타입> 리턴타입 메서드(매개변수,..){...}
타입파라미터에 지정되는 구체적인 타입은 상위 타입이거나 상위 타입의 하위 또는 구현클래스만 가능
메서드의 중괄호{}안에서 타입 파라미터 변수로 사용 가능한 것은 상위타입의 멤버(필드, 메서드)로 제한,하위타입에만 있는 필드와 메서드는 사용할 수 없음
3.와일드카드타입(<?>,<? extends...><?super...>)
(1)제네릭타입<?>:제한없음, 타입파라미터로 모든 클래스나 인터페이스 타입이 올 수 있음
(2)제네릭타입<? extends 지정타입>:상위 클래스 제한 (= 지정타입 포함 하위타입 받을수 있음, 예 C기준 C,D,E 올수있음)
(3)제네릭타입<? super 지정타입>:하위 클래스 제한 (= 지정타입 포함 상위타입 받을수 있음, 예 C기준 C,B,A 올수있음)
4.제네릭 메서드
public<타입파라미터,...>리턴타입 메서드명(매개변수,...){...}
예) publicBox box (T name){...}
리턴타입변수=<구체적인타입>메서드명(매개값); 명시적으로 구체적인 타입을 지정
예) Box box01= box(10);
리턴타입변수=메서드명(매개값); 매개값을 보고 구체적인 타입 추정
예) Box box01 = box(10);
지정해준 타입파라미터가 리턴타입을 지정해주기도 하고 매개변수의 타입으로 지정해주기도함
5.제한된 클래스
Number 타입으로 올수 있는거는 short,byte,Double,Integer,long
Number 는 int 클래스타입이아니라서 Integer로 자동 박싱 된다.
6.compare에서 값을 비교할때
앞의 값>뒤의 값 +1 반환
앞의 값<뒤의 값 -1 반환
앞의 값=뒤의 값 0반환
7.student=new T[capacity];
타입 파라미터로 배열을 생성하려면 new T[capacity];형태로는 배열을 생성할 수 없음
Object 타입으로 배열을 생성한 후 강제 형변환 처리
students = (T[]) new Object[capacity];
8.타입의 매개변수로는 기초타입이 올수 없다. 그래서 랩퍼클래스를 사용한다. 예) Int->Integer
Entry<String, Int> e1 =new Entry<>("김선달",20);
Entry<String, Integer> e1 =new Entry<>("김선달",20);
package study_0509;
public class Util {
public static <T> BOX <T> box(T name){
BOX<T> box01= new BOX<T>();
box01.set(name);
return box01;
}
public static <K,V> boolean compare(pa<K,V> p1,pa<K,V> p2 ) {
boolean keycompare= p1.getKey().equals(p2.getKey());
boolean valuecompare=p1.getValue().equals(p2.getValue());
return keycompare&&valuecompare;
}
public static<T extends Number>int compare(T t1, T t2) {
double v1=t1.doubleValue(); // Number의 doubleValue() 메서드를 사용
double v2=t2.doubleValue(); // Number의 doubleValue() 메서드를 사용
return Double.compare(v1, v2); //v1이 작으면-1,v1이 크면+1,v1=v2 같으면 0
}
}package study_0509;
public class UtilTest {
public static void main(String[] args) {
// 제네릭 메서드를 호출해서 사용하는 방법
// BOX<Integer>box02=Util.box(100); 뒤에타입 생략가능
BOX<Integer>box02=Util.<Integer>box(100);
int intValue = box02.get();
System.out.println(intValue);
// BOX<String> box03 = Util.box("김자바"); 뒤에타입 생략가능
BOX<String> box03 = Util.<String>box("김자바");
String strValue = box03.get();
System.out.println(strValue);
//==================================================================
int result = Util.compare(10, 15);
System.out.println(result);
int result01 = Util.compare(4.5, 15);
System.out.println(result01);
// String result02 = Util.compare("a","b"); Number 타입으로 제한을걸어서 String 타입은 올수 없다.
}
}package study_0509;
public class pa <K,V>{//제네릭 타입
private K key;
private V Value;
public pa (K key,V Value) {
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) {
Value = value;
}
}package study_0509;
public class compareTest {
public static void main(String[] args) {
pa<Integer,String> p1= new pa<>(1,"노트");
pa<Integer,String> p2= new pa<>(1,"노트");
// boolean result = Util.<Integer,String>compare01(p1,p2);
boolean result = Util.<Integer, String>compare(p1, p2);
if(result) {
System.out.println("논리적으로 같은(동등) 객체");
}else {
System.out.println("논리적으로 다른(동등하지 않은) 객체");
}
}
}package study_0509;
public class Course<T> {
private String name; // 학생 이름
private T[] students; // 수강생 저장 배열
public Course(String name, int capacity) {
this.name = name;
students = (T[]) new Object[capacity];
}
public String getName() {
return name;
}
public T[] getStudents() {
return students;
}
public void add(T t) { // 배열에 비어 있는 부분을 찾아서 수강생을 추가하는 메서드
for(int i=0; i<students.length; i++) {
if(students[i]==null) {
students[i] = t;//배열의 빈공간에 값을 저장하고
break; // 값이 저장되면 종료
}
}
}
}