230705 자바 강의

[IntegerExample.java]

package ddit.chap02.sec02;

public class IntegerExample {

	// 조정자, 코치
	public static void main(String[] args) {
		
		// 워크호스
		byteInteger();
		shortInteger();
		integer();
		longInteger();
		
	}
	
	public static void byteInteger() {
		
		// byte : 1byte 공간.
		//        -128 ~ 127 저장 가능.
		//		  127보다 크거나 -128보다 작은 범위를 벗어나는 literal은 오류 발생.
		//        수식에 의한 범위를 초과하는 경우 순환적용된 값(128은 -128로, 129면 -127로) 출력.
		
//		byte num1 = 128; // 127보다 크므로 오류
//		byte num2 = -129; // -128보다 작으므로 오류
		
		byte res = 127;
		System.out.println(++res); // -128
		System.out.println(++res); // -127
		
	}
	
	public static void shortInteger() {
		
		// short : 2byte 공간.
		//         -32768 ~ 32767 저장 가능.
		//		   32767보다 크거나 -32768보다 작은 범위를 벗어나는 literal은 오류 발생.
		//         수식에 의한 범위를 초과하는 경우 순환적용된 값(32768은 -32768로, 32769면 -32767로) 출력.
		
//		short num1 = 32768; // 32767보다 크므로 오류
//		short num2 = -32769; // -32768보다 작으므로 오류
		
		short res1 = 32767;
		System.out.println(++res1); // -32768
		System.out.println(++res1); // -32767
		
		///////////////////////////////////////////////////////////////////
		
		short sh1 = 200;
		short res2 = (short) (sh1 + 10); // 오류 발생. 수식(sh1 + 10) 중에 10이 int이므로 [short->int로 바뀜 + int = int]. 따라서 강제 형변환(캐스트(short))이 되어야 함.
		System.out.println(res2); // 210
		
		short sh2 = 10;
		short res3 = (short) (sh1 + sh2); // 수식(sh1 + sh2)에서 변수의 데이터 타입이 int보다 작으면 무조건 int로 자동 형변환(프로모션)이 일어남.
		System.out.println(res3); // 210
		
	}
	
	public static void integer() {
		
		// int : 4byte 공간.
		//       기본 정수 타입.
		//       -2147483648 ~ 2147483647 저장 가능.
		//		 2147483647보다 크거나 -2147483648보다 작은 범위를 벗어나는 literal은 오류 발생.
		//       수식에 의한 범위를 초과하는 경우 순환적용된 값(2147483648은 -2147483648로, 2147483649면 -2147483647로) 출력.
		
//		int num1 = 2147483648; // 2147483647보다 크므로 오류
//		int num2 = -2147483649; // -2147483648보다 작으므로 오류
		
		int res1 = 2147483647;
		System.out.println(++res1); // -2147483648
		System.out.println(++res1); // -2147483647
		
		///////////////////////////////////////////////////////////////////
		
		int int1 = 300;
		int res2 = (int) (int1 + 20L); // 오류 발생. 수식(int1 + 20L) 중에 20L이 long이므로 [int->long으로 바뀜 + int = long]. 따라서 강제 형변환(캐스트(int))이 되어야 함.
		System.out.println(res2); // 320
		
		///////////////////////////////////////////////////////////////////
		
		int num = 200; // 200이라는 값은 자동으로 기본 정수 타입 취급.
		int res = 1000000*1000000;
		System.out.println("res : " + res); // res : -727379968, 순환적용된 값이 적용.
//		res=10000000000; // 리터럴을 직접 입력시키는 것은 오류.
		
	}
	
	public static void longInteger() {
		
		// long : 8byte 공간
		//        –9223372036854775808 ~ 9223372036854775807 저장 가능. (-2^63 ~ 2^63-1)
		//        리터럴 끝에 L(l) 추가하여 long 타입의 정수임을 표현.
		//		  9223372036854775807보다 크거나 -9223372036854775808보다 작은 범위를 벗어나는 literal은 오류 발생.
		//        수식에 의한 범위를 초과하는 경우 순환적용된 값(9223372036854775808은 -9223372036854775808로, 9223372036854775809면 -9223372036854775807로) 출력.
		
//		long num1 = 9223372036854775808L; // 9223372036854775807L보다 크므로 오류
//		long num2 = -9223372036854775809L; // -9223372036854775808L보다 작으므로 오류
		
		long res = 9223372036854775807L;
		System.out.println(++res); // -9223372036854775808
		System.out.println(++res); // -9223372036854775807
		
		///////////////////////////////////////////////////////////////////
		
		long num = 100L; // 리터럴 끝에 L(l) 추가하여 long 타입의 정수임을 표현.
		long res1 = 1000000*1000000; // 수식 결과 리터럴이 int 타입으로 저장되므로 범위 초과에 의한 순환적용 값 출력
		long res2 = 1000000L*1000000L; // 수식 결과 리터럴이 long 타입으로 저장됨.
		
		System.out.println("res1 : " + res1); // res1 : -727379968
		System.out.println("res2 : " + res2); // res2 : 1000000000000
		
	}

}

---

[FloatExample.java]

package ddit.chap02.sec02;

public class FloatExample {

	public static void main(String[] args) {
		
		// 실수 자료형 : float, double
		
		// 1) float : 4byte 표현 (1bit(부호), 8bit(지수), 23bit(가수 : 소숫점 이하의 수) = 총 32bit)
		//            1.4e-45(1.4*10^-45) ~ 3.4e+38. long 보다 큰 범위를 가진다. 자동 형변환 기준점.
		//            리터럴 끝에 F(f) 추가해야 함. ex) 3.1415926f
		
		// 2) double : 8byte 표현 (1bit(부호), 11bit(지수), 52bit(가수 : 소숫점 이하의 수) = 총 64bit)
		//             4.9e-324 ~ 1.8e+308
		//             기본 실수 타입.
		//             리터럴 끝에 D(d) 추가하거나 생략할 수 있음. ex) 3.1415926d
		
//		float f1 = 3.14; // 오류. 리터럴 뒤에 f가 없으면 기본형 double로 취급됨.
		float f2 = 0.1f;
		
		double d1 = 3.14; // D(d) 생략 가능.
		double d = 3.14d;
		double d2 = 0.1;
		double d3 = f2; // float f2 = 0.1f;의 값이 double로 전환되어 바뀜.
		
		
		if(f2==d2) {
			System.out.println("같은 크기의 수");
		}else {
			System.out.println("다른 크기의 수");
			System.out.println("d3 : " + d3);
		}
		// 다른 크기의 수
		// d3 : 0.10000000149011612
		// float f2 = 0.1f; 와 double d2 = 0.1; 는 다른 크기의 수이다.
		
		if(f2==d3) {
			System.out.println("같은 크기의 수");
		}else {
			System.out.println("다른 크기의 수");
		}
		// 같은 크기의 수

	}

}

---

[CharExample.java]

package ddit.chap02.sec02;

public class CharExample {

	public static void main(String[] args) {
		
		// char : 2byte(부호 없는 정수) : 0 ~ 65535
		//        ''안에 표현하는 한 글자 저장. '대한민국' 중에 '대'만 저장됨. 2자 이상 저장 불가.
		//        ASCII로 변환하여 저장. 정수와 호환됨.
		char ch1 = 'a'; // 점유공간 1byte. 글자 수 1개.
		char ch2 = '대'; // 점유공간 3byte(초성,중성,종성). 글자 수 1개.
		char ch3 = '한';
		
		System.out.println("ch1 : " + ch1); // ch1 : a
		System.out.println((int)ch1); // 97
		System.out.println("ch1 : " + (char) (ch1+1)); // ch1 : b => 97+1=98. 형변환에 의해 b로 바뀜.
		
		System.out.println("ch2 : " + ch2); // ch2 : 대
		System.out.println("ch2 : " + (int) ch2); // ch2 : 45824
		
		System.out.println("ch3 : " + (int) ch3); // ch3 : 54620
		
		System.out.println(ch2+ch3); // 45824 + 54620 = 100444
		
		//ABCD....Z 출력
		for(char c='A'; c<='Z'; c++) {
			System.out.print(c); // ABCDEFGHIJKLMNOPQRSTUVWXYZ
		}
		
		System.out.println(); // 줄바꿈
		
		for(int i=65; i<=90; i++) {
			System.out.print(i);
			System.out.print((char)i + " ");
			// 65A 66B 67C 68D 69E 70F 71G 72H 73I 74J 75K 76L 77M 78N 79O 80P 81Q 82R 83S 84T 85U 86V 87W 88X 89Y 90Z 
		}
		
		short s1 = 67;
//		char ch4 = s1; // 오류 발생. (short->char(X))
		
		byte b1 = 100; 
//		char ch5 = b1; // 오류 발생. (byte->char(X))
		// byte, short는 음수가 포함되는데, char는 음수가 포함되지 않으므로 음수 표현 불가.
		
		char ch6 = 'a';
		short s2 = (short) ch6; // char가 short보다 더 넓은 범위를 가지므로 변경 불가. 그러므로 (short)과 같은 캐스트 연산자를 사용해야 함.
		
		int res = ch6; // int 는 음수 표현도 가능하고, char 보다도 넓은 범위값을 가지므로 얼마든지 저장 가능.
		
	}

}

---

[BooleanExample.java]

package ddit.chap02.sec02;

public class BooleanExample {

	public static void main(String[] args) {
		
		// boolean : 1byte에 저장.
		//           true/false.
		//           모든 기본타입은 boolean으로 변환 불가능.
		//           주로 조건문 구성에 사용.
		//           연산자 중 관계연산자(>,<,==,>=,<=,!=)와 논리연산자(!, &&, ||)의 연산결과는 boolean 값이다.
		//           기본 값 : false
		
		boolean flag = true;
		int num = 200;
		String name = "홍길동";
		
		System.out.println(flag); // true
		
		flag = num>1000 && name.equals("홍길동"); // false && true = false
		// .equals("홍길동") : 모든 클래스가 다 가지고 있는 메소드. 
		// Object 클래스에서 정의. 모든 클래스의 조상. 변수 없이 메소드로만 구성되고, 모든 클래스가 상속 받아 사용.
		
		System.out.println(flag);
		
		Person p1 = new Person();
		Person p2 = new Person();
		System.out.println("객체 내용 비교 : " + p1.equals(p2)); // 객체 내용 비교 : false
		System.out.println("객체 주소 비교 : " + (p1==p2)); // 객체 주소 비교 : false
		System.out.println("p1 객체 주소 값 : " + p1); // p1 객체 주소 값 : ddit.chap02.sec02.Person@215be6bb
		System.out.println("p2 객체 주소 값 : " + p2); // p2 객체 주소 값 : ddit.chap02.sec02.Person@4439f31e
		
		/*
		 * 자동 형변환(promotion)
		 * 작은 표현 범위 -> 큰 표현 범위
		 * long -> float
		 * 형변환 연산자 생략.
		 * 
		 * 형변환 연산자(cast 연산자)? (타입)
		 * 
		 * 강제 형변환
		 * 필요에 따라서 원하는 타입으로 변환.
		 * 예를 들면 실수를 정수로 바꾸는 것. 2(int)/5(int) = 2(int) => 2(float)/5(int) = 2.5(float)
		 * 형변환 연산자를 반드시 사용.
		 * 
		 * ---------------------------------------------------------------
		 * 
		 * String 클래스
		 * java.lang 패키지에 들어있음. ex) System, Math 클래스 등을 포함.
		 * 문자열 취급. " "
		 * 내용 변경이 불가능한 클래스. 자바에서는 immutable class라 부른다.
		 * 한번 데이터가 저장되면 내용을 변경하거나 길이를 늘릴 수 없다.
		 * 
		 * 클래스를 사용하기 위해서는 클래스를 객체로 만들어 주어야 한다. 즉 원래는 String을 객체화(인스턴스화)해야 한다. 이 때 적용되는 연산자가 new.
		 * Person p1 = new Person();
		 * 그러나 예외가 하나 있으니, new가 없어도 객체가 될 수 있는 것이 String 클래스.
		 * 
		 * String name;
		 * String name = "홍길동"; 문자열은 Method 메모리의 literal pool 영역에 저장되고, call stack 메모리에 name이라는 변수 메모리 주소를 가리킴.
		 * 
		 * String str1 = new Stirng("홍길동"); 은 저장되는 공간이 다름.
		 * 변수 str1 은 call stack 메모리에 저장되고, new Stirng("홍길동")은 heap 메모리에 저장되어 "홍길동"이라는 값이 str1을 가리키게 됨.
		 * 
		 * JVM의 메모리 주소에 문자열 할당.
		 * method
		 * call stack
		 * heap
		 * 
		 * new 라는 연산자로 객체화하면 heap 메모리 영역에 할당됨.
		 * new가 사용되지 않는 String 클래스는 데이터를 Method 메모리의 literal pool 영역에 저장.
		 * 이 떄, String 데이터를 사용하려면 literal pool 영역에 저장된 데이터가 call stack 메모리에 name이라는 변수를 가리킴.
		 * Method 메모리의 literal pool 영역에 저장된 데이터는 중복 불가(스캐닝으로 동일한 값을 찾아 call stack 메모리 주소만 가리키게 함).
		 * 
		 * 지역변수는 call stack에 저장됨.
		 * 
		 * ---------------------------------------------
		 * 
		 * 문자열 -> 일반 기본타입
		 * "27" -> 27
		 * "false" -> false
		 * 
		 * 래퍼클래스명.parse기본타입(문자열);
		 * 
		 * Integer.parseInt("27");
		 * Boolean.parseBoolean("false");
		 * 
		 * ---------------------------------------------
		 * 
		 * 기본타입 -> 문자열
		 * String.valueOf(데이터)
		 * 
		 * 50 -> "50"
		 * String.valueOf(50)
		 * 50+"";
		 */
		
	}

}

class Person {
	
}

---

[PromotionExample.java]

package ddit.chap02.sec03;

public class PromotionExample {

	public static void main(String[] args) {
		
		int num1 = 100;
		short s1 = 15;
		byte b1 = 15;
		char ch1 = 'b';
		float f1 = 3.14f;
		long l1 = 1000L;
		
		int res = 0;
		short res1 = 0;
		float res2 = 0f;
		
		res = s1 + ch1; // s1(short -> int) + ch1(char -> int)
		System.out.println(res); // 113
		
//		res1 = s1 + b1; // s1(short->int) + b1(byte->int)로 바뀌어 short res1에 저장하려 하므로 오류.
		res1 = (short) (s1 + b1); // (short) s1 + (short) b1 -> 수식 계산의 결과값이 int가 되므로 소용 없음. 따라서, 수식 계산 이후 시점에서 형변환 해야 함.
		System.out.println(res1); // 30
		
//		res2 = num1 + f1; // 가능. res2(float) = num1(int) + f1(float)
		res2 = l1 + f1; // 가능. res2(float) = l1(long) + f1(float);
		System.out.println(res2); // 1003.14
		
	}

}

---

[CastExample.java]

package ddit.chap02.sec03;

import java.util.Scanner;

public class CastExample {

	public static void main(String[] args) {
		
		round();
		
	}
	
	public static void round() {
		
		// 여러 자리의 소숫점을 포함하는 실수를 키보드로 입력 받아 소숫점 3자리에서 반올림 후 출력하시오.
		// 키보드로 입력
		// 1) Scanner class import
		//    import java.util.Scanner
		// 2) Scanner class 객체 생성 - new 연산자 사용
		//    Scanner sc = new Scanner(System.in);
		// 3) 입력메시지 출력 - System.out.print("메시지");
		//    System.out.print("실수 자료 입력 : ");
		// 4) 입력자료 저장 - Scanner class의 입력자료형에 맞는 메서드 사용
		//    정수 입력 : nextInt()
		//    실수 입력 : nextFloat(), nextDouble()
		//    문자열 입력 : next() - 공백으로 데이터를 구분, nextLine() - 엔터키 전에 입력받은 문자열을 다 입력받음...
		
		Scanner sc = new Scanner(System.in);
		
		System.out.print("실수 자료 입력 : ");
		double number = sc.nextDouble();
		
		double number1 = number;
//		number1 = (int)((number1*100) + 0.5)/100; // /100에서 100이 int이므로 나눈 최종값에서 소수점 이하의 값(23.4567 -> 23.0)이 사라짐.
		number1 = (int)((number1*100) + 0.5)/100.0; // /100.0은 (int)((number1*100) + 0.5)의 수식 결과 값을 100.0으로 나눠 주므로 double형으로 바뀜.
		System.out.println("number1 = " + number1);
		
		number = number*100+0.5;
		number = (int)number;
		number = number/100;
		
		System.out.println("number = " +number);
		
		sc.close();
		
		///////////////////////////////////////////////////////////////////
		
		// 365일 5시간. 윤년 주기 4년.
		double year = 365.2422;
		int days = (int)year;
		System.out.println("days : " + days);
		double hours = (year - days) * 24;
		System.out.println("hour : " + hours);
		
	}

}

---

[Homework_02_02.java]

package ddit.chap02.sec03;

public class Homework_02_02 {

	public static void main(String[] args) {
		
		// 1년은 356.2422일이다. 이를 xxx일 xx시간 xx분 xx초로 환산하시오.
		
		double year = 365.2422;
		
		int day = (int) year;
		System.out.println("day : " + day); // day : 365
		
		int hour = (int) ((year - day) * 24); // 0.2422 * 24
		System.out.println("hour : " + hour); // hour : 5
		
		int minute = (int) (((year - day) * 24 - hour) * 60); // 0.8128 * 60
		System.out.println("minute : " + minute); // minute : 48
		
		int second = (int) ((((year - day) * 24 - hour) * 60 - minute) * 60); // 0.768000000000015 * 60
		System.out.println("second : " + second); // second : 46
		
		System.out.println(hour + "시간 " + minute + "분 " + second + "초"); // 5시간 48분 46초
		
		System.out.println("==============================");
		
		double ho;
		ho = 0.2422 * 24;
		System.out.println(ho); // 0.422에 하루 24시간을 곱해서 시간을 구한다.
		
		double min;
		min = ho % 5;
		min = min * 60;
		System.out.println(min); // 나머지 연산자(%)로 시간값을 제외한 나머지 값을 구한 후 60분을 곱하여 분값을 구한다.
		
		double sec;
		sec = min % 48;
		sec = sec * 60;
		System.out.println(sec); // 나머지 연산자로 분값을 제외한 나머지 값을 구한 후 60초를 곱하여 초값을 구한다.
		
		System.out.println((int)ho + "시간 " + (int)min + "분 " + (int)sec + "초"); // 5시간 48분 46초
		
	}

}