1025

Wrapper

기본자료형을 감싼다 객체가 아닌데 객체처럼 사용

package com.greedy.section04.wrapper;

public class Application1 {

public static void main(String[] args) {
	
	/* Wrapper 클래스
	 * 
	 * 상황에 따라 기본 타입의 데이터를 인스턴스화 해야 하는 경우들이 발생한다.
	 * 이 때 기본타입의 데이터를 먼저 인스턴스로 변환 후 사용해야 하는데
	 * 8가지에 해당하는 기본 타입의 데이터를 인스턴스화 할 수 있도록 하는 클래스를
	 * 래퍼클래스(Wrapper class)라고 한다.
	 * */
	
	/* 박싱(Boxing)과 언박싱(UnBoxing)
	 * 
	 * 기본타입을 래퍼클래스의 인스턴스로 인스턴스화 하는것을 박싱(Boxing)이라고 하며
	 * 래퍼클래스 타입의 인스턴스를 기본타입으로 변경하는 것을 언박싱(UnBoxing)이라고 한다.
	 * */
	int intValue = 20;
	
	Integer boxingNumber1 = new Integer(intValue); // 인스턴스화 - 박싱(Boxing) // 생성자이용
	Integer boxingNumber2 = Integer.valueOf(intValue); //static 메소드 이용
	
	int unBoxingNumber1 = boxingNumber1.intValue(); // 언박싱(UnBoxing) // intValue() 이용
	
	/*
	 * 오토 박싱(AutoBoxing)과 오토 언박싱(AutoUnBoxing)
	 * JDK 1.5 부터는 박싱과 언박싱이 필요한 상황에서 자바 컴파일러가 이를 자동으로 처리해준다.
	 * 이러한 자동화된 박싱과 언박싱을 오토박싱, 오토언박싱이라고 부른다.
	 * */
	
	Integer boxingNumber3 = intValue; // 오토박싱
	
	int unBoxingNumber2 = boxingNumber3; // 오토 언박싱
	
	int inum = 20;
	
	Integer integerNum1 = new Integer(20);
	Integer integerNum2 = new Integer(20);
	Integer integerNum3 = 20;
	Integer integerNum4 = 20;
	
	System.out.println("int와 Integer 비교 : " + (inum == integerNum1));
	System.out.println("int와 Integer 비교 : " + (inum == integerNum3));
	
	/* 생성자를 이용해 생성한 인스턴스의 경우 ==로 비교하지 못한다.
	 * 단, 오토박싱을 이용해서 생성한 값은 ==로 비교가 가능하다.
	 * */
	
	System.out.println("integer와 integer 비교 : " + (integerNum1 == integerNum2)); // 주소값비교
	System.out.println("integer와 integer 비교 : " + (integerNum1 == integerNum3));
	System.out.println("integer와 integer 비교 : " + (integerNum3 == integerNum4));
	
	/* 래퍼클래스 타입의 인스턴스를 비교할 때는 equals()를 사용해야 한다. */
	System.out.println("equals() : " + (integerNum1.equals(integerNum2)));
	System.out.println("equals() : " + (integerNum1.equals(integerNum3)));
	System.out.println("equals() : " + (integerNum3.equals(integerNum4)));
}

}

int와 Integer 비교 : true
int와 Integer 비교 : true
integer와 integer 비교 : false
integer와 integer 비교 : false
integer와 integer 비교 : true
equals() : true
equals() : true
equals() : true

package com.greedy.section04.wrapper;

public class Application2 {

public static void main(String[] args) {
	
	/* parsing : 문자열(String)값을 기본자료형 값으로 변경하는 것을 parsing이라고한다. */
	
	byte b = Byte.parseByte("1");
	short s = Short.parseShort("2");
	int i = Integer.parseInt("4");
	long l = Long.parseLong("8"); //8L 안됨
	float f = Float.parseFloat("4.0"); // 4.0f는 된다.
	double d = Double.parseDouble("8.0");
	boolean bl = Boolean.parseBoolean("true");
	
	/* Character는 parsing 기능을 제공하지 않는다. */
	char c = "abc".charAt(0); 
			
	
}

}

package com.greedy.section04.wrapper;

public class Application3 {

public static void main(String[] args) {
	
	/* parsing과 반대로 기본자료형 값을 문자열로 변경하는 경우 */
	
	/* valueOf() : 기본자료형 값을 Wrapper클래스 타입으로 변환시키는 메소드
	 * toString() : 필드값을 문자열로 반환하는 메소드
	 * */
	
	String b = Byte.valueOf((byte)1).toString(); // -> 문자열 1로 바꿈
	String s = Short.valueOf((short)2).toString();
	String i = Integer.valueOf(4).toString();
	String l = Long.valueOf(8L).toString();
	String f = Float.valueOf(4.0F).toString();
	String d = Double.valueOf(8.0).toString();
	String bl = Boolean.valueOf(true).toString();
	String c = Character.valueOf('a').toString();
	
	/* String 클래스의 valueOf를 사용할 수 있다. */
	String str = String.valueOf(10);
	
	/* 문자열 합치기를 이용해 String으로 변환할 수 있다. */
	String str2 = 123 + "";
	
	
}

}
package com.greedy.section05.calendar;

import java.util.Date;

public class Application1 {

public static void main(String[] args) {
	
	/* Date 클래스 생성 방법 (2가지) */
	
	/* 1. 기본생성자를 사용하는 방법 */
	/* 기본 생성자로 인스턴스를 생성하면 운영체제의 날짜 / 시간  정보를 이용해서 인스턴스를 만들게 된다.*/
	java.util.Date today = new java.util.Date(); //import에는 1개만 들어갈 수있음
	
	/* toString() 메소드가 오버라이딩 되어 있어서 쉽게 필드값을 출력해 볼 수 있다. */
	System.out.println(today.toString());
	
	/* 2. Date(long date) 사용하는 방법 */
	/* getTime() : 1970년 1월 1일 0시 0분 0초 이후 지난 시간을 millisecond로 계산하여 long타입으로 반환한다.*/
	System.out.println(today.getTime());
	
 	Date time = new Date(1666663344024L);
 	
 	/*
 	 * 하루 = 24시간, 1시간 = 60분, 1분 = 60초, 1초 = 1000밀리초
 	 * 
 	 * 1000 * 60 * 60 * 24가 하루가된다.
 	 * */
 	System.out.println(time);
}

}

Tue Oct 25 12:06:07 KST 2022
1666667167474
Tue Oct 25 11:02:24 KST 2022

package com.greedy.section05.calendar;

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

public class Application2 {

public static void main(String[] args) {
	
	/* Calendar 클래스 사용 */
	/* API 문서를 확인했던것처럼 Calendar 클래스는 abstract 클래스로 작성되어 있다.
	 * 따라서 Calendar 클래스를 이용해서 인스턴스를 생성하는 것이 불가능하다.
	 * */
	
	/* Calendar 클래스를 이용한 인스턴스 생성 방법에는 두가지 방법이 있다.
	 * 1. getInstance() static 메소드를 이용해서 인스턴스를 반환받는 방법
	 * 2. 후손 클래스인 GregorianCalendar 클래스를 이용해서 인스턴스를 생성하는 방법
	 * */
	
	Calendar calendar = Calendar.getInstance();
	
	System.out.println(calendar);
	
	Calendar gregorianCalendar = new GregorianCalendar() ;
	
	System.out.println(gregorianCalendar);
	
	
	/* 상황에 따라 특정 일자를 기준으로 한 Date 타입의 인스턴스가 필요한 경우도 있다. */
	
	/* 2022년 10월 04일 09:30:00 */
	int year = 2022;
	int month = 9; // 월은 0 ~ 11월로 시작하기 때문에 9는 10월을 의미한다.
	int dayOfMonth = 4;
	int hour = 9;
	int min = 30;
	int second = 0;
	
	Calendar startDay = new GregorianCalendar(year, month, dayOfMonth, hour, min, second);
	
	System.out.println(startDay);
	
	System.out.println(startDay.getTimeInMillis());
	
	Date date = new Date(startDay.getTimeInMillis());
	
	System.out.println(date);
	
	Date date2 
	= new Date(new GregorianCalendar(year, month, dayOfMonth, hour, min, second).getTimeInMillis());

   System.out.println(date2);
   
   /* 생성된 인스턴스의 필드 정보를 Calendar 클래스에 있는 get() 메소드를 사용하여 반환받을 수 있다. */
   int startYear = startDay.get(1);
   int startMonth = startDay.get(2);
   int startDayOfMonth = startDay.get(5);
   
   System.out.println(startYear);
   System.out.println(startMonth); // 9는 10월을 의미
   System.out.println(startDayOfMonth);
   
   System.out.println(Calendar.YEAR);
   System.out.println(Calendar.MONTH);
   System.out.println(Calendar.DAY_OF_MONTH);
   
   System.out.println("year : " + startDay.get(Calendar.YEAR));
   System.out.println("month : " + startDay.get(Calendar.MONTH));
   System.out.println("dayOfMonth : " + startDay.get(Calendar.DAY_OF_MONTH));
   /* 요일(일(1), 월(2), 화(3), 수(4), 목(5), 금(6), 토(7)의 의미*/ 
   System.out.println("dayOfWeek : " + startDay.get(Calendar.DAY_OF_WEEK));
   
   String day = "";
   switch(startDay.get(Calendar.DAY_OF_WEEK)) {
       case Calendar.SUNDAY : day = "일"; break;
       case Calendar.MONDAY : day = "월"; break;
       case Calendar.TUESDAY : day = "화"; break;
       case Calendar.WEDNESDAY : day = "수"; break;
       case Calendar.THURSDAY : day = "목"; break;
       case Calendar.FRIDAY : day = "금"; break;
       case Calendar.SATURDAY : day = "토"; break;
       
   }
   System.out.println("요일 : " + day);
   
   System.out.println("amPm : " + startDay.get(Calendar.AM_PM)); // 0은 오전 1은 오후
   
   System.out.println("hourOfDay : " + startDay.get(Calendar.HOUR_OF_DAY)); // 24시간 체계
   System.out.println("hour : " + startDay.get(Calendar.HOUR)); //12시간 체계
   

   
}

}

java.util.GregorianCalendar[time=1666667183763,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Seoul",offset=32400000,dstSavings=0,useDaylight=false,transitions=30,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2022,MONTH=9,WEEK_OF_YEAR=44,WEEK_OF_MONTH=5,DAY_OF_MONTH=25,DAY_OF_YEAR=298,DAY_OF_WEEK=3,DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,HOUR=0,HOUR_OF_DAY=12,MINUTE=6,SECOND=23,MILLISECOND=763,ZONE_OFFSET=32400000,DST_OFFSET=0]
java.util.GregorianCalendar[time=1666667183781,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Seoul",offset=32400000,dstSavings=0,useDaylight=false,transitions=30,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2022,MONTH=9,WEEK_OF_YEAR=44,WEEK_OF_MONTH=5,DAY_OF_MONTH=25,DAY_OF_YEAR=298,DAY_OF_WEEK=3,DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,HOUR=0,HOUR_OF_DAY=12,MINUTE=6,SECOND=23,MILLISECOND=781,ZONE_OFFSET=32400000,DST_OFFSET=0]
java.util.GregorianCalendar[time=?,areFieldsSet=false,areAllFieldsSet=false,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Seoul",offset=32400000,dstSavings=0,useDaylight=false,transitions=30,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=?,YEAR=2022,MONTH=9,WEEK_OF_YEAR=?,WEEK_OF_MONTH=?,DAY_OF_MONTH=4,DAY_OF_YEAR=?,DAY_OF_WEEK=?,DAY_OF_WEEK_IN_MONTH=?,AM_PM=0,HOUR=9,HOUR_OF_DAY=9,MINUTE=30,SECOND=0,MILLISECOND=?,ZONE_OFFSET=?,DST_OFFSET=?]
1664843400000
Tue Oct 04 09:30:00 KST 2022
Tue Oct 04 09:30:00 KST 2022
2022
9
4
1
2
5
year : 2022
month : 9
dayOfMonth : 4
dayOfWeek : 3
요일 : 화
amPm : 0
hourOfDay : 9
hour : 9

제네릭

제네릭이란 데이터 타입을 일반화 한다는 것을 의미
제네릭을 활용하면 타입 변환 및 타입 검사에 들어가는 코드 생략이 가능

package com.greedy.section01.generic;

public class Application {

public static void main(String[] args) {
	
	/* 제네릭(generic)
	 * 제네릭의 사전적인 의미는 일반적인이라는 의미이다.
	 * 자바에서 제네릭이란 데이터의 타입을 일반화한다는 의미를 가진다.
	 * 
	 * JDK 1.5버전부터 추가된 문법
	 * 
	 * instanceof 비교 및 다운캐스팅 작성이 불필요
	 * */
	GenericTest<Integer> gt1 = new GenericTest<Integer>();
	
	gt1.setValue(10);
	
	System.out.println(gt1.getValue());
	System.out.println(gt1.getValue() instanceof Integer);
	
	/* JDK 7부터 타입선언 시 타입변수가 작성되면 타입 추론이 가능하기 때문에
	 * 생성자쪽의 타입을 생략하고 사용할 수 있게 한다.
	 * 단, 타입이 명시되지 않은 빈 다이아몬드 연산자는 사용해야 한다.
	 * */
	GenericTest<String> gt2 = new GenericTest<>(); // 왼쪽타입에서 추론가능해서 생략 가능
	gt2.setValue("홍길동");
	System.out.println(gt2.getValue());
	System.out.println(gt2.getValue() instanceof String);
	
	GenericTest<Double> gt3 = new GenericTest<>();
	gt3.setValue(0.5);
	System.out.println(gt3.getValue() instanceof Double);
	
}

}
package com.greedy.section01.generic;

public class GenericTest {

/* 제네릭 설정은 클래스 선언부 마지막 부분에 다이아몬드 연산자를 이용하여 작성하게 된다.
 * 다이아몬드 연산자 내부에 작성하는 영문자는 관례상 대문자로 작성한다.
 * 
 * 
 * 다이아몬드 연산자 내부에 작성한 T는 타입변수라고 부른다.
 * 
 * 타입변수를 자료형 대신 사용할 것인데, 가상으로 존재하는 타입이며
 * T가 아닌 다른 영문자를 사용해도 무방하다.
 * 
 * 또한 여러 개의 타입변수를 작성할 때는 ,를 이용해서 여러 개 기술할 수도 있다.
 * */

private T value;

public void setValue(T value) {
	
	this.value = value;
	
}

public T getValue() {
	
	return this.value;
}

}

10
true
홍길동
true
0.5

package com.greedy.section02.extend.run;

import java.util.HashMap;
import java.util.Map;

import com.greedy.section02.extend.Bunny;
import com.greedy.section02.extend.DrunkenBunny;
import com.greedy.section02.extend.Rabbit;
import com.greedy.section02.extend.RabbitFarm;

public class Application1 {

public static void main(String[] args) {
	
	/* 제네릭 클래스 작성 시 extends 키워드를 이용하면 특정 타입만 사용하도록 제한을 걸 수 있다. */
	/* Animal 타입으로는 제네릭 클래스 인스턴스 생성이 불가능하다. */

// RabbitFarm farm1 = new RabbitFarm<>();

	/* Mammal 타입으로는 제네릭 클래스 인스턴스를 생성이 불가능하다. (T extends Rabbit일때) */

// RabbitFarm farm2 = new RabbitFarm<>();

	/* 전혀 다른 타입을 이용해서도 인스턴스 생성이 불가능하다. */

// RabbitFarm farm3 = new RabbitFarm<>();

	/* Rabbit 타입이거나 Rabbit의 후손으로는 인스턴스 생성이 가능하다.*/
	RabbitFarm<Rabbit> farm4 = new RabbitFarm<>();
	RabbitFarm<Bunny> farm5 = new RabbitFarm<>();
	RabbitFarm<DrunkenBunny> farm6 = new RabbitFarm<>();
	
	farm4.setAnimal(new Rabbit());
	((Rabbit) farm4.getAnimal()).cry();
	farm4.getAnimal().cry();              // 형변환 생략가능

	farm5.setAnimal(new Bunny());
	((Bunny) farm5.getAnimal()).cry();
	farm5.getAnimal().cry();
	
	farm6.setAnimal(new DrunkenBunny());
	((DrunkenBunny) farm6.getAnimal()).cry();
	farm6.getAnimal().cry();
	
	Map<Integer, Bunny> map = new HashMap<>();
	
	map.put(1, new Bunny());
	
	System.out.println(map.get(1));
	
	
}

}

package com.greedy.section02.extend.run;

import com.greedy.section02.extend.Bunny;
import com.greedy.section02.extend.DrunkenBunny;
import com.greedy.section02.extend.Rabbit;
import com.greedy.section02.extend.RabbitFarm;
import com.greedy.section02.extend.WildCardFarm;

public class Application2 {

public static void main(String[] args) {
	
	/* 와일드카드(WildCard)
	 * 
	 * 제네릭 클래스 타입의 객체를 메소드의 매개변수로 받을 때
	 * 그 객체의 타입 변수를 제한할 수 있다.
	 * 
	 * <?> : 제한 없음
	 * <? extends Type> : 와일드카드의 상한 제한(Type과 Type의 후손을 이용해 생성한 인스턴스만 인자로 사용가능)
	 * <? super Type> : 와일드카드의 하한 제한(Type과 Type의 부모를 이용해 생성한 인스턴스만 인자로 사용가능)
	 * */

	WildCardFarm wildCardFarm = new WildCardFarm();
	
	/* 농장 생성 자체가 불가능한것은 매개변수로 사용할수 없다.*/

// wildCardFarm.anyType(new RabbitFarm(new Mammal()));
// wildCardFarm.anyType(new RabbitFarm(new Reptile()));

	/* 어떠한 토끼 농장이던 매개변수로 사용이 가능하다.*/
	wildCardFarm.anyType(new RabbitFarm<Rabbit>(new Rabbit()));
	wildCardFarm.anyType(new RabbitFarm<Bunny>(new Bunny()));
	wildCardFarm.anyType(new RabbitFarm<DrunkenBunny>(new DrunkenBunny()));
	
	/* Bunny이거나 Bunny의 후손 토끼농장만 매개변수로 사용이 가능하고 
	 * 상위타입으로 만든 토끼농장은 매개변수로 사용이 불가능하다.
	 * */

// wildCardFarm.extendsType(new RabbitFarm(new Rabbit()));
wildCardFarm.extendsType(new RabbitFarm(new Bunny()));
wildCardFarm.extendsType(new RabbitFarm(new DrunkenBunny()));

	/* Bunny 이거나 Bunny의 상위타입 토끼 농장만 매개변수로 사용이 가능하고
	 * 하위타입으로 만든 토끼 농장은 매개변수로 사용이 불가능하다.
	 * */
	wildCardFarm.superType(new RabbitFarm<Rabbit>(new Rabbit()));
	wildCardFarm.superType(new RabbitFarm<Bunny>(new Bunny()));

// wildCardFarm.superType(new RabbitFarm(new DrunkenBunny()));

}

}

예외처리
오류와 에러
-시스템상 프로그램에 심각한 문제가 발행해서 실행중인 프로그램이 영향을 받는 것은 오류와 예외로 구분할 수 있음
-오류 (Error)
시스템 상에서 프로그램에 심각한 문제를 발생하여 실행중인 프로그램이 종료되는 것
-예외 (Exception)
오류와 마찬가지로 비정상적으로 종료시키지만 미리 예측하고 처리할 수 있는 미약한 오류

예외 클래스 계층 구조
Exception과 Error 클래스 모두 Throwable클래스의 자손이다.
예외클래스들의 차상위 클래스는 Exeption 클래스이며 예외처리를 해야하는 Checked Exception과 해주지 않아도 되는 Unchecked Exeption으로 나뉜다.

예외는 예외처리를 통해 코드의 흐름을 컨트롤 가능
-예외 처리 방법
1.thorws로 위임
(Exception 처리를 호출한 메소드에게 위임)
메소드 선언시 thorws ExceptionName문을 추가하여 호출한 상위 메소드에게 처리를 위임
2.try-catch 로 처리
(Exception 이 발생한 곳에서 직접 처리)
try : exception 발생할 가능성이 있는 코드를 안에 기술
catch : try 구문에서 exception 처리가 가능하나 exception에 대한 처리 기술
여러 개의 exception처리가 가능하나 exception간의 상속관계 고려

package com.greedy.section01.exception;

public class Application1 {

public static void main(String[] args) throws Exception {
	
	ExceptionTest et = new ExceptionTest();
	

// et.checkEnoughMoney(10000, 50000);

	et.checkEnoughMoney(50000, 10000);
	/* 예외 발생 구문 이하 구문은 동작하지 않고 되돌아온다.
	 * 하지만 메인메소드 또한 예외를 처리하지 않고 위임했다.
	 * 따라서 프로그램은 비정상적으로 종료되고 아래 구문은 출력되지 않는다.
	 * */
	
	System.out.println("프로그램을 종료합니다.");
}

}
package com.greedy.section01.exception;

public class ExceptionTest {

public void checkEnoughMoney(int price, int money) throws Exception {
	
	System.out.println("가지고 계신 돈은 " + money + "원 입니다.");
	
	if(money >= price) {
		
		System.out.println("상품을 구입하기 위한 금액이 충분합니다.");
	} else {
		
		/* 강제로 예외 발생 */
		/* 예외 발생 시키고 메소드 헤드에 throws 구문 추가한다.
		 * -> 예외를 발생시킨 쪽에서는 throws로 예외에 대한 책임을 위임해서
		 * 해당 예외에 대한 처리를 강제화 시킨다.
		 * */
		throw new Exception();
	}
	
	/* 예외가 발생하지 않는 경우에 실행이된다.*/
	System.out.println("즐거운 쇼핑 하세요~~~");
}

}
package com.greedy.section01.exception;

public class Application {

public static void main(String[] args) {
	
	/* try-catch를 이용한 방법 */
	
	ExceptionTest et = new ExceptionTest();
	
	try {
		
		et.checkEnoughMoney(10000, 50000);
		
		System.out.println("============= 상품 구입 가능 ===============");
	} catch (Exception e) {
		
		
		System.out.println("============= 상품 구입 불가 ===============");
	}
	
	System.out.println("프로그램을 종료합니다.");
}

}
package com.greedy.section01.exception;

public class Application2 {

public static void main(String[] args) {
	
	/* try-catch를 이용한 방법(예외발생) */
	
	ExceptionTest et = new ExceptionTest();
	
	try {
		
		et.checkEnoughMoney(5000, 10000);
		
		System.out.println("============= 상품 구입 가능 ===============");
	} catch (Exception e) {
		
		
		System.out.println("============= 상품 구입 불가 ===============");
	}
	
	System.out.println("프로그램을 종료합니다.");
}

}

가지고 계신 돈은 10000원 입니다.
상품을 구입하기 위한 금액이 충분합니다.
즐거운 쇼핑 하세요~~~
============= 상품 구입 가능 ===============
프로그램을 종료합니다.