java01. varibles

ex01_hello

// 1. 주석처리

// a. 한줄주석 : //

// b. 블럭주석 : /* */

/*

2. eclipse 단축기

1) 신규파일 : ctrl + n

2) 라인주석 : ctrl + / toggle(o)

3) 블럭주석 : ctrl + shift + / toggle(x)

4) 되돌리기 : crtl + z

5) 라인삭제 : ctrl + d

6) 라인복사 : ctrl + alt + up(down)

7) 라인이동 : alt + up(down)

8) 자동완성 : ctrl + space

9) 구조보기 : ctrl + o

10) 자동import : ctrl + shift + o

11) 단축키보기 :ctrl + shift + l

12) 실행 : ctrl + F11 or F11

 

*/

ex02_varibles

// 직접 입력(표현)된 값

// 10진수

int var1 = 10; // 10은 literal, var1은 변수

System.out.println("10진수= " +var1);

// 8진수 : 숫자 맨앞에 0으로 시작되는 리터럴

int var2 = 010;

System.out.println("8진수= " +var2);

// 16진수

int var3 = 0x10;

System.out.println("16진수= " +var3);

// 2진수

int var4 = 0b10;

System.out.println("2진수= " +var4);

// 서로 다른 데이터타입의 연산

char c1 = 'A';

int i1 = 10;

System.out.println("c1+i1= " +(c1+i1)); // 연산 시 큰 타입으로 자동형변환 후에 연산

System.out.println("c1+i1= " +(c1+(char)i1)); // int타입을 char타입으로 강제형변환

 

double d1 = 10.0;

System.out.println("d1+i1= " +(d1+i1));

 

// 기본적으로 작은 크기의 타입과 큰 크기의 타입의 연산결과는 큰 데이터타입으로

// 자동 형변환 된 후에 연산이 된다.

// 따라서 결과값을 저장하는 변수타입은 큰 크기의 타입을 선언되어야 한다.

 

double d2 = 10 + 10.0; // 자동형변환

int i2 = (int)(10 + 10.0); //강제형변환

 

 

/*

1. 변수란?

프로그램은 작업을 처리하는 과정에서 필요에 따라 데이터를 메모리에 저장한다. 이때 변수를 사용하는데 변수(variable)는

값을 저장하는 하나의 메모리 공간을 의미한다.

변수랁 이름은 프로그램에서 수시로 값이 변동될 수 있기 때문이다 .따라서 변수란 변동된 값을 가진 하나의

메모레 공간이라고 한다. 변수에는 복수개의 값을 저장할 수 있고 하나의 값만 저장할 수 있다. 즉, 변수란 하나

또는 복수의 값을 저장할 수 있는 메모리 공간을 의미한다.

 

 

2. 변수의 명명규칙

1) 첫 번째 글자는 문자이거나 $, 언더바(_)로 시작해야 하고 숫자로 시작 할 수 없다.(필수)

2) 변수명은 대문자와 소문자가 구분이 된다.(필수)

3) 첫 번째 글자는 소문자로 시작하고 단어 구분마다 대문자로 선언 (관례)

- camel case(firstName), snake case(first_name)

4) 변수명의 길이에는 제한이 없다.

5) 한글변수명도 가능하다. 하지만 사용하지는 않는다(관례)

6) 자바예약어(if, for...)는 사용할 수 없다.

 

3. 변수의 사용

변수를 사용한다는 것은 변수에 값을 저장하고 읽는 행위를 말한다. 변수에 값을 저장할 때는

대입연산자(=)를 사용한다. 일반 수학에서는 "=는 좌변과 우변이 같다"는 의미이지만 프로그램에서 는

우변의 변수 or 값을 좌변의 변수에 대입(저장)한다는 의미이다.

 

변수를 선언하고 처음의 값을 저장할 경우는 초기화한다고 하고 이 값을 초기값이라고 한다.

따라서, 자바에서는 변수에 초기값을 준다는 의미는 "변수의 초기화"라고 한다.

 

리터럴(literal), 상수(constant, 변하지 않는 값)는 같은 의미이지만 Java에서는 literal은

값을 변경할 수 없는 자료, 상수는 " 한 번값을 저장하면 변경할 수 없는 변수"로 정의하기 때문에

Java에서는 literal과 constant는 구분해서 사용한다.

 

*/

//1. 변수의 선언방법

// a. 변수타입(데이터타입) 변수명;

// b. 변수타입(데이터타입) 변수명 = 초기값; 의 형태로 선언한다.

 

int firstNumber = 10; // 한번 선언된 변수는 재선언할 수 없다.

 

// firstNumber = 10.0; // 에러 : 선언된 데이터타입과 다른 데이터타입은 원칙적으로 불가

int firstnumber = 20; // 대소문자 구분

// int firstNumber = 30;

int 한글명변수 = 40;

 

System.out.println("firstNumber = " + firstNumber);

System.out.println("firstnumber = " + firstnumber);

// System.out.println("FirstNumber = " + FirstNumber);

System.out.println("한글명변수 = " + 한글명변수);

 

 

//2. 변수의 선언

int val1; // 선언만 하고 초기화하지 않은 경우

//System.out.println("val1 = " + val1); // 에러 : 초기화되지 않은 변수는 사용불가

val1 = 20;

System.out.println("val1 = " + val1);

 

int val2 = 20; // 선언과 동시에 초기화

System.out.println("val2 = " +val2);

 

int val3;

// int val4 = val3 + 50;

// 1. 변수의 선언 : 선언 & 초기화

int val1 = 10;

int val2 = 20;

System.out.println("val1 = " + val1);

 

System.out.println("val2 = " + val2);

 

System.out.println("val1+val2 = " + val1+val2);

System.out.println("(val1+val2) = " + (val1+val2));

 

 

// 2. 변수의 동시선언

int a, b, c;

// System.out.println("a=" +a); 초기화 에러

int x=10, y=20, z=30;

System.out.println("x="+x+",y=" +y +",z="+z);

int l, m , n=40; // l,m은 초기화되지 않음

// System.out.println("l="+l+",m="+m+",n="+n);

System.out.println();

 

// 3. 변수선언과 변수타입

// a. 기본타입(primitive)

// 1) 정수 : byte(1), char(2), short(2), int(4), long(8)

// 정수의 기본 타입은 int

byte b1; // -128~127 범위의 값만 가질 수 있다.

byte b2;

b1 = -128;

b2 = 127;

System.out.println("b1="+b1+",b2="+b2);

// b1 = -129; // -128을 벗어난 에러

// b2 = 128; 127을 벗어난 에러. byte타입이 표현할 수 있는 숫자범위를 초과한 에러

b1 = (byte) -123123; // 정수의 기본 타입은 int, int를 byte로 변환

b2 = (byte) 123123; // int타입을 byte로 강제변환

System.out.println("b1="+b1+",b2="+b2);

 

char c1 = 'A'; // 한 개의 문자(내부적으로 유니코드값(정수))으로 저장된다 .char은 작은 따옴표

char c2 = '가'; // A는 내부적으로 65, 가는 44032의 정수(유니코드)값으로 저장된다.

// char c3 = "A"; // ""문자열이기 때문에 에러

// char c4 = 'AA'; // 한개이상의 문자를 저장불가

char c5 = 65; //A

char c6 = 44032; //가

char c7 = 97; //a

char c8 = 48; //0

// System.out.println("c1=" +c1 +",c2=" +c2+ ",c3=" +c3 +",c4=" +c4+ ",c5=" +c5 +",c6=" +c6+ ",c7=" +c7 +",c8=" +c8 );

 

// short

short s1; // -2의 15승 ~ 2의 15승-1의 범위

short s2;

s1 = -32768;

s2 = 32767;

System.out.println("s1=" +s1+ ",s2=" +s2);

System.out.println();

 

// int

int i1 = 'A'; // int i1 = 65;와 동일

int i2 = 'Z'; // int i2 = 90;

int i3 = '0';

int i4 = -2147483648;

int i5 = 2147483647;

System.out.println("i1=" +i1+ ",i2=" +i2+ ",i3=" +i3);

 

// long

long l1; // -2의 61승 ~ 2의 61승-1

long l2;

 

// l1 = -2147483649; // 숫자리터럴의 기본타입은 int타입

// l2 = 2147483648; // int 표현범위를 초과한 에러

l1 = -2147483649L; // 정수라서 L or l로 선언을 해줘야

l2 = 2147483648l; // int -> long 변환 -> l2에 값을 대입

 

System.out.println("l1=" +l1+ ",l2=" +l2);

System.out.println();

 

// 2) 실수 : float(4), double(8)

// java에서는 정수타입의 기본형은 int이지만 실수타입의 기본형은 double타입이다.

// 따라서 float로 선언할 경우 long타입처럼 뒤에 F or f로 선언하거나 데이터 타입을

// 변경(형변환)해야 한다.

 

//float

float f1 = 1.0F;

float f2 = 1.0f;

System.out.println("f1=" +f1+ ",f2=" +f2);

 

// double : 실수의 기본타입

double d1 = 1.0D;

double d2 = 3.14d;

double d3 = 1.0;

double d4 = 3.14;

System.out.println("d1=" +d1+ ",d2=" +d2+ ",d3=" +d3+",d4"+d4);

// 3) 논리 : boolean(1) : true, false 내부적으로 true=1, false=0의 정수값을 가지고 있다.

boolean bool1 = true;

boolean bool2 = false;

System.out.println("bool1=" +bool1+ ",bool2=" +bool2);

 

// b. 참조타입(reference)

// 변수의 사용범위

// local vs global(지역변수 vs 전역변수)

int var1=10;

System.out.println("var1의 값=" +var1);

System.out.println();

 

if(true) {

int var2;

var1 = 20; // 전역변수

var2 = 20; // 지역변수

// var3 = 33; // 다른 지역의 변수

System.out.println("var1="+var1);

System.out.println("var2="+var2);

 

}

// System.out.println("var2="+var2);

// 에러 : var2는 if블럭 안에서 선언된 지역변수이기 때문에 if블럭 밖에서는 사용할 수 없다.

System.out.println();

if(true) {

int var3;

var1 = 30;

// var2 = 20; // 이 블럭(지역)에서는 사용불가

var3 = 30;

System.out.println("var1="+var1);

 

}

System.out.println("var1="+var1);

ex03_datatype

// 실수의 기본 데이터타입은 double;

double d1 = 3.14;

double d2 = 3.14D;

double d3 = 3.14d;

 

// float f1 = 3.14; // 3.14데이터타입은 double

float f1 = (float)3.14; // 강제형변환

float f2 = 3.14f; // 명시적으로 선언

float f3 = 3.14F; // 명시적으로 선언

 

// 실수(float)는 정밀도의 문제가 있다.(컴퓨터는 이진법으로 원초적인 문제)

float f4 = 0.1234567890123456789f;

double d4 = 0.1234567890123456789d;

System.out.println("f4="+f4+" ,d4="+d4);

// 실수 0.1을 표현할 때 정확하게 표현불가 즉, 정확한 값이 아니라 0.1에 근사값으로 리턴된다.

System.out.println("1.0-0.9="+(1.0-0.9));

System.out.println("1.0-0.9="+(1.0*10-0.9*10)*0.1);

// 1. 기본타입 - 정수(byte, short, char, int, long), 실수(float, double), 논리(boolean)

// 2. 참조타입 - Class, Array, Interface, Enum

// String(문자열)은 참조(Reference)타입, 문자열은 String 이라는 클래스 타입이다.

// 자바에서는 클래스로 선언된 것은 모두 참조타입이다.

// 자바에서는 문자열을 표현할 때는 큰 따옴표로 선언한다.

// 작은 따옴표는 char타입을 선언할 때 사용한다.

 

char c1 = 'A'; // 기본타입인 정수타입 중 하나인 char타입

// char c2 = "A"; // 에러 : char타입은 한개으 ㅣ문자(내부적으로 유니코드 정수값)만 저장할 수 있다.

String str1 = "A"; //str1은 객체라고 보면 된다.

String str2 = "AAA";

// 참조타입은 객체가 저장되어 있는 주소

System.out.println(str1);

System.out.println(str2);

System.out.println("문자열 A가 저장되어 있는 메모리 주소 = " +str1.hashCode());

System.out.println("문자열 A가 저장되어 있는 메모리 주소 = " +str2.hashCode());

System.out.println("str1이 저장한 값 = " +str1.toString());

System.out.println("str2이 저장한 값 = " +str2.toString());

System.out.println();

 

// literal 과 constant 비교

// java에서는 상수의 변수명은 관계로 모두 대문자로 선언, 단어마다 언더바(_) 즉 스네이크 방식으로 선언한다.

// 상수는 final로 선언된 변수를 의미한다. constant값이 한번 설정이 되면 변경할 수 없다.

final int min_value = 0; // 관례에 위배

final int MIN_VALUE = 0; // 관례에 따른 상수의 변수명 선언방법

// min_value = 10; //에러 : 상수(final로 선언된 변수)는 변경할 수 없다.

 

final int MAX_VALUE; // 선언만 되고 초기화가 안된 경우

MAX_VALUE = 100; // 초기화

// MAX_VALUE = 10000; // 에러

final double PI = 3.141592;

 

ex04_typechange

// 형변환

// 1. 강제형변환(Casting)

float f1 = (float) 3.14; // double인 3.14를 float로 강제형변환한 후 f1에 대입

 

int i1 = 44032; // '가'

char c1 = '가';

c1 = (char) i1; // int(4byte)를 char(1byte)로 강제형변환

System.out.println(c1 + "의 유니코드 값 =" + i1);

System.out.println(i1 + "의 유니코드 값 =" + i1);

System.out.println((char)i1 + "의 유니코드 값 =" + i1);

System.out.println();

 

 

 

 

// 2. 자동형변환(Promotion)

long l1 = 500; // int(4byte)인 500을 long 타입인 l1으로 자동형변환

i1=(int)l1; // 강제형변환

System.out.println(i1 + "의 값 =" + l1);

System.out.println();

 

double d1 = 3.141592; // 형변환 발생되지 않는다.

System.out.println(d1+"의 값=" +d1);

 

// 2. 강제형변환시 값이 짤리는 경우

i1 = (int)d1; // 강제형변환

System.out.println(i1+"의 값=" +d1);

 

byte b1 = (byte)128;

System.out.println(b1+"의 값=" +b1);

b1 = (byte)100000;

System.out.println(b1+"의 값=" +b1);

System.out.println();

 

// 3. 연산시 형변환

double d2 = 10 + 3.141592; // int(10)이 double(10.0)자동형변환 후 연산

System.out.println(d2+"의 값=" +d2);

 

d2 = 10 + (int)3.141592; // double(3.141592)가 int(3)로 강제형변환 후 연산 후 double로 자동형변환

System.out.println(d2+"의 값=" +d2);

 

d2 = (int)(10+3.141592); //int(10)이 double(10.0)으로 자동형변환 후 연산결과(13.141592)가 int로 강제형벼환 후 double로 자동형변환

 

int i2 = (int)(10+3.141592);

// int(10)이 double(10.0)으로 자동형변환 후 연산결과(13.141592)가 int로 강제형변환 후 결과값을 대입

/*

형변환(Casting, Promotion)이란?

모든 리터럴과 변수는 데이터타입이 있다. 프로그램을 작성하다 보면 서로 달느 데이터타입의

값을 연산하는 경우가 자주 발생 하는데 모든 연산은 기본적으로 동일 타입의 데이터만 연산할

수 있기 때문에 서로 다른 타입의 연산을 수행하는 경우에는 연산을 수행하기 전에 형변환을

통해 동일 타입의 데이터타입으로 변환해 주어야 한다.

 

형변환이란? 변수 또는 리터럴의 데이터타입을 다른 데이터타입으로 변환하는 것을 말한다.

큰 크기의 데이터타입에서 작은 크기의 데이터타이븡로 변환하는 것을 '강제형변환(Casting,

명시적)'이라 하고 작은 크기에서 큰 크기의 데이터타입으로 변화하는 것을 '자동형변환(

Promotion,묵시적)'이라고 한다.

 

byte(1) < short(2) < int(4) < long(8) < float(4) < double(8)

 

자동형변환은 자동으로 변환되기 때문에 개발자가 별도로 정의할 것이 없지만 수동형변환은

개발자가 명시적으로 선언해야 한다. Casting방법은 아래와 같다.

 

데이터타입 변수명 = (데이터타입)값[or 표현식(변수명 or 연산수행)]

 

a. double d1 = int_value + double_value; // int_value가 double로 자동형변환 후 연산결과가 double로 저장

b. double d1 = (double) int_value + double_value;

c. double d1 = int_value + (int) double_value;

d. double d1 = (double)(int_value + (int)double_value);

 

*/

ex05_accuracy

int i1 = 123456780;

int i2 = 123456780;

 

// 형변환될 때 정밀도

float f1 = i1;

System.out.println("i1=" +i1);

System.out.println("i2=" +i2);

System.out.println("f1=" +f1);

System.out.println();

 

i2 = (int) f1; // 정밀도 문제 발생

System.out.println("i2=" +i2);

 

int result = i1 - i2;

System.out.println("정밀도 문제발생 : "+result);

 

// 실수(float)를 연산할 경우에는 정밀도 문제가 발생된다.

// float 0.1을 정확히 표현할 수 없다. 그러므로 실수의 연산은

// float로 연산하지 말고 double로 연산할 것을 권고한다.

System.out.println("double의 연산 : "+(1.0 - 0.1));

System.out.println("double과 float의 연산 : "+(1.0 - 0.1f)); // 형변환

System.out.println("float와 float의 연산 : "+(1.0f - 0.1f)); // 형변환

ex06_op

// 연산시에 형변환 발생

byte b1 = 10;

byte b2 = 20;

byte b3 = (byte)30;

//Java에서는 정수형 연산의 기본은 int타입으로 연산된다.

byte b4 = (byte)(b1 + b2); // b1, b2가 int로 자동형변환 후 더한 결과를 byte로 강제형변환 결과를 b4에 대입

int i1 = b1 + b2; //b1, b2를 int로 자동형변환 후 더하기 연산결과를 i1에 대입

 

char c1 = '가'; // 유니코드 A=65, a=98

char c2 = '1';

// char c3 = c1 + c2;

char c3 = (char)(c1 + c2);

System.out.println("c3=" +c3);

 

int i2 = (char)(c1+c2);

System.out.println("i2=" +i2);

System.out.println("c2=" +c2);