JAVA 변수와 자료형

#01. VSCode 설정

1) Extention 설치

이름	개발자	설명
Extension Pack for Java	Microsoft	자바 개발에 필요한 필수 익스텐션 모음
PlantUML	jebbs	클래스 다이어그램 생성 도구
PlantUML Previewer	Mebrahtom Guesh	PlantUML로 작성된 다이어그램 뷰어
PlantUML Syntax	Quido Hoekman	PlantUML 문법 강조 도구

2) 프로젝트 생성

1. Ctrl+Shift+P를 눌러 명령창을 연 후 Java: Create Java Project를 선택한다.
2. 다음 단계에서 No build tools를 선택한다.
3. 프로젝트(각 단원별 폴더)가 생성될 작업 디렉토리를 지정한다.
4. 프로젝트의 이름을 입력한다. (여기서는 02_변수와_자료형)

3) 소스코드 작성

모든 소스코드는 src 폴더 안에서 작성되어야 한다.

4) 코드 실행 및 디버깅

F5를 눌러서 코드를 실행한다.

BreakPoint가 설정되어 있는 경우 디버깅이 진행된다.

5) VSCode 디버깅 단축키

단축키	설명
F9	중단점 설정/해제
F5	디버깅 시작 디버깅 중인 경우 - (다른 중단점이 존재할 경우) 다음 중단점으로 이동 - (다른 중단점이 없을 경우) 나머지 코드 일괄 실행
F10	다음 줄 실행
F11	메서드 호출 구문에서 해당 메서드 안으로 들어가기

#02. 메모리

데이터를 저장할 수 있는 물리적 장치

1) 휘발성 메모리

전원을 OFF하면 저장되어 있는 데이터가 모두 삭제된다.

• ex) RAM 카드

2) 비휘발성 메모리

전원을 OFF 하더라도 데이터가 삭제되지 않는다.

• ex) 하드 디스크, USB

#03. 컴퓨터의 데이터 단위

컴퓨터에 저장될 수 있는 데이터는 이진수 형태이므로 0아니면 1로만 구성된다.

1) bit

이진수 값 하나를 의미.

• 1bit는 두 개의 정보를 표현할 수 있다. (0 혹은 1)
• 2bit는 네 개의 정보를 표현할 수 있다. (00, 01, 10, 11)
• nbit는 2의 n제곱 개의 정보를 표현할 수 있다.
  • 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 …

2) 인코딩

• 글자를 부호화 하기 위한 규격.
  • ex) 모스부호

ANSI

• 이진수를 사용해서 알파벳을 부호하 하기 위한 미국 표준 규격
• 7bit로 알파벳 한 글자를 표현한다.
• 미국 전용.

확장 ANSI

• ANSI에서 다른 언어를 표현하기 위한 1bit를 추가하여 8bit로 한 글자를 표현하는 방식
• 영어 + 1개국어 표현이 가능하기 때문에 언어별로 종류가 나누어진다.
  • ex) euc-kr, euc-jp, euc-ch …
• 확장 ANSI가 국제표준으로 정해진 후 컴퓨터에서 데이터의 크기의 초소 단위를 8bit로 정하고 이를 1byte라고 부르기 시작함.
• 영어는 1byte로 한 글자를 표현 가능함.
• 한국어와 같은 조합형 글자는 두 개 이상의 byte가 모여야 한 글자를 구성할 수 있다.

UTF-8

• 확장 ANSI가 영어+1개국어 밖에 표현하는 한계를 개선하여 언어 종류에 상관 없이 3byte로 한 글자를 표현하는 방식.
• 한번에 모든 언어를 표현할 수 있다.
• 현재 사실상 산업 표준으로 사용되고 있다.

3) 컴퓨터의 용량 단위

• byte : 최소단위 (이진수 8개)
• kbyte : 1kb = 1024b
• mbyte : 1mb = 1024kb
• gbyte : 1gb = 1024mb
• tbyte : 1tb = 1024gb

#04. 변수

메모리에 저장된 데이터.

쉽게 생각하면 값을 대입하기 위한 메모리 영역이라고 할 수 있다.

1) 변수 사용하기

변수의 선언

변수에 저장할 수 있는 값의 종류를 명시하고 그 옆에 변수의 이름을 정의한 다음 세미콜론으로 명령을 종료한다.

int는 정수를 의미하고 4byte의 메모리 공간을 차지한다.

int num;

값의 할당

대입 연산자 =을 사용해서 선언한 변수에 데이터를 저장하는 것.

항상 오른쪽에서 왼쪽으로 대입된다.

num = 100;

선언과 할당의 일괄 처리

int num = 100;

2) 데이터 타입 (Data Type)

메모리에 저장되어 있는 이진수들을 해석하기 위한 규칙들.

메모리에 저장할 수 있는 값의 종류를 의미한다.

종류	크기	설명	값 형태
byte	1byte	-128~127 까지의 범위를 갖는 정수	ex) 1
short	2byte	byte 보다 큰 범위를 저장할 수 있는 정수	ex) 200
int	4byte	short 보다 큰 범위를 저장할 수 있는 정수	ex) 1234567
long	8byte	int 보다 큰 범위를 저장할 수 있는 정수	생략
float	4byte	실수	ex) 3.14
double	8byte	float 보다 더 정밀하게 소수점 자리를 표현할 수 있는 실수	ex) 3.141592…
boolean	2byte	참/거짓을 표현하는 논리값	true / false
char	2byte	한 글자. 홑따옴표로 감싼다.	‘a’

3) 변수 값 할용하기

같은 데이터 타입을 갖는 변수 여러 개를 한 번에 선언하기

int num1, num2;
num1 = 100;
num2 = 200;

이미 값이 할당된 변수는 다른 값으로 변경 가능

int pay = 100;
pay = 200;

변수 값을 다른 변수에 복사 가능

int x, y;
x = 50;
y = x;

int z = y;

변수의 이름 규칙

1. 언더바(_), 숫자, 영어, $기호만 사용 가능하다.
   • 관례상 $는 잘 사용하지 않는다.
2. 첫 글자는 숫자가 될 수 없다.
3. 자바에서 사용하는 예약어를 사용할 수 없다.
4. 첫 글자는 대부분 소문자로 시작한다.

두 개 이상의 단어를 조합하여 이름을 정의하는 경우

1. 스네이크 표기법 : 띄어 쓰기를 언더바(_)로 표현

int my_age;

1. 카멜 표기법 : 띄어쓰기가 시작되는 단어의 첫 글자를 대문자로 변경

int myAge;

문자열

쌍따옴표로 감싸진 문장을 저장할 수 있는 데이터 타입

String welcomeMessage = "Hello World";

4) 변수의 제약

선언되지 않은 변수는 사용할 수 없다.

int x;
x = 100;    // 선언된 변수를 사용하므로 ok
y = 200;    // 선언되지 않은 변수에 값을 대입하므로 에러

이미 선언된 변수를 중복 선언할 수 없다.

int z;
z = 200;

int z = 300;    // 중복선언 에러

float 타입 사용시 주의사항

double 타입과의 구분을 위해 대입시 F를 적용해야 한다. (필수)

float k = 12.345F;

long 타입 사용시 주의사항

int 타입과의 구분을 위해 대입시 L을 적용해야 한다. (권장)

long k = 12345678L

변수 값 출력하기

int myAge = 100;

System.out.println(myAge);      // 100이 출력된다.
System.out.println("myAge");    // myAge라는 문자열이 출력된다.

#05. 실습예제

📒 Ex01_변수의_사용

public class Ex01_변수의_사용 {
    public static void main(String[] args) {
        /** 1) 선언(declaration)과 할당(정의,definition)을 분리 */
        // 정수형 변수 a를 선언 --> 메모리의 특정 위치에 4칸을 점유
        int a;
        // a에 100을 할당(기록)
        a = 100;
        System.out.println(a);

        /** 2) 선언과 할당을 통합 */
        // 정수형 변수 b를 선언하고 a에 기록된 내용을 복사
        int b = a;
        System.out.println(b);

        /** 3) 실수형 변수 */
        // double 타입은 메모리의 8칸을 점유하고 소수점을 포함한 값을 저장한다.
        double c = 3.14;
        System.out.println(c);

        /** 4) 논리형 변수 */
        boolean d = true;
        System.out.println(d);
    }
}

📒 Ex02_리터럴

/**
 * 변수에 할당되기 위한 원초적인 값 형태
 *
 * int a = 100;
 * 위의 코드에서 100이 리터럴
 *
 * 리터럴은 변수에 대입되거나 직접 출력할 수 있다.
 */
public class Ex02_리터럴 {
    public static void main(String[] args) {
        // 정수형태의 리터럴은 int로 인식된다.
        System.out.println(100);

        // 정수의 리터럴은 변수의 datatype에 따라 자동 식별된다.
        int num1 = 100;
        System.out.println(num1);

        double num2 = 100;
        System.out.println(num2);

        // 실수의 리터럴은 값 뒤에 데이터 타입의 첫 글자(리터럴 문자)를 지정해서 구분해 함.
        // --> 지정하지 않을 경우 double로 인식
        // --> 첫 글자는 대소문자 구분 없음
        float num3 = 3.14F;
        System.out.println(num3);

        double num4 = 3.14D;
        System.out.println(num4);

        // `int`형의 리터럴 문자는 없지만 double은 `D`라고 명시하는 것이 가능
        double num5 = 100D;
        System.out.println(num5);
    }
}

📒 Ex03_상수

public class Ex03_상수 {
    public static void main(String[] args) {
        /** 1) 변수는 초기화 이후 다른 값으로 변경 가능함 */
        int age = 20;
        System.out.println(age);

        age = 21;
        System.out.println(age);

        /** 2) 상수는 초기화 이후 값을 변경할 수 없는 형태 */
        // 데이터 타입 앞에 `final`키워드를 적용하여 생성
        // 선언과 할당이 통합된 형태로만 생성 가능함
        // 상수의 이름은 모두 대문자로 지정하고 스네이크 표기법을 사용하는 것이 관례
        final double PI = 3.14;
        System.out.println(PI);

        // 상수의 값을 변경하려고 시도 --> 이 위치에서 에러 발생함
        //PI = 3.14159;

        // 에러가 발생하는 위치에서 프로그램이 중단되기 때문에 아래 코드는 실행되지 않음
        //System.out.println(PI);
    }
}

📒 Ex04_문자열

/**
 * 문자열 : 문자(char타입)을 나열한 형태. 쌍따옴표를 사용함 --> 문장
 * 기본 데이터 타입 8가지에 속하지 않음.
 *
 * 원래 문자열은 객체라는 형태의 특수한 변수이지만
 * 아직 설명되지 않은 내용이므로 일반 변수와 구분하지 않는다.
 */
public class Ex04_문자열 {
    public static void main(String[] args) {
        /** 1) 문자열 변수의 선언과 할당 */
        String name;
        name = "자바학생";
        System.out.println(name);

        /** 2) 빈 문자열 */
        // 내용이 없는 문자열 --> 따옴표를 열자마자 닫은 형태
        // 내용은 없지만 메모리 공간은 차지하고 있다는 점에서 존재하는 변수임
        String empty = "";
        System.out.println(empty);

        /** 3) 공백문자열 */
        // 띄어쓰기도 엄연한 글자
        String space = "     ";
        System.out.println(space);

        /** 4) null값 */
        // 나중에 할당하기 위해서 값을 비워 놓은 형태
        // 빈 문자열이나 공백문자열은 메모리를 소비하지만 null은 메모리를 차지하지 않는다.
        String nValue = null;
        System.out.println(nValue);
    }
}

#06. 데이터 타입별 상세 설명

1) 정수형 데이터 타입의 범위

각 정수형 데이터 타입이 저장할 수 있는 값의 범위를 이해하는 것이 중요합니다.

타입	크기	범위	용도
byte	1byte (8bit)	-128 ~ 127	작은 범위의 정수, 메모리 절약이 중요한 경우
short	2byte (16bit)	-32,768 ~ 32,767	중간 범위의 정수
int	4byte (32bit)	-2,147,483,648 ~ 2,147,483,647	일반적인 정수 (가장 많이 사용)
long	8byte (64bit)	-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807	매우 큰 정수

public class IntegerDataTypes {
    public static void main(String[] args) {
        // 각 타입의 최대값과 최소값
        System.out.println("byte 최소값: " + Byte.MIN_VALUE);
        System.out.println("byte 최대값: " + Byte.MAX_VALUE);

        System.out.println("short 최소값: " + Short.MIN_VALUE);
        System.out.println("short 최대값: " + Short.MAX_VALUE);

        System.out.println("int 최소값: " + Integer.MIN_VALUE);
        System.out.println("int 최대값: " + Integer.MAX_VALUE);

        System.out.println("long 최소값: " + Long.MIN_VALUE);
        System.out.println("long 최대값: " + Long.MAX_VALUE);
    }
}

2) 실수형 데이터 타입의 정밀도

public class FloatingPointPrecision {
    public static void main(String[] args) {
        // float의 정밀도 (약 7자리)
        float f1 = 1.23456789F;
        System.out.println("float: " + f1);  // 1.2345679 (반올림됨)

        // double의 정밀도 (약 15자리)
        double d1 = 1.234567890123456789;
        System.out.println("double: " + d1); // 1.2345678901234568 (반올림됨)

        // 부동소수점 연산의 부정확성
        double result = 0.1 + 0.2;
        System.out.println("0.1 + 0.2 = " + result); // 0.30000000000000004

        // 정확한 계산이 필요한 경우 BigDecimal 사용 권장
        System.out.println("부동소수점 연산은 완전히 정확하지 않을 수 있습니다.");
    }
}

3) 문자형(char)과 문자열(String)의 차이

public class CharVsString {
    public static void main(String[] args) {
        // char: 단일 문자 (홑따옴표 사용)
        char single = 'A';
        char korean = '가';
        char symbol = '$';

        System.out.println("char: " + single);
        System.out.println("char: " + korean);
        System.out.println("char: " + symbol);

        // String: 문자열 (쌍따옴표 사용)
        String text = "Hello World";
        String empty = "";
        String singleCharAsString = "A";

        System.out.println("String: " + text);
        System.out.println("String: " + empty);
        System.out.println("String: " + singleCharAsString);

        // char의 Unicode 값
        System.out.println("'A'의 Unicode 값: " + (int)single);
        System.out.println("'가'의 Unicode 값: " + (int)korean);
    }
}

#07. 변수 명명 규칙과 모범 사례

1) 변수 명명 규칙 (강제사항)

public class NamingRules {
    public static void main(String[] args) {
        // ✅ 올바른 변수명
        int age;
        int user_id;
        int $money;
        int _count;
        int number123;

        // ❌ 잘못된 변수명 (컴파일 에러)
        // int 123number;  // 숫자로 시작 불가
        // int user-id;    // 하이픈 사용 불가
        // int for;        // 예약어 사용 불가
        // int user id;    // 공백 사용 불가
    }
}

2) 변수 명명 모범 사례 (권장사항)

public class NamingBestPractices {
    public static void main(String[] args) {
        // ✅ 좋은 변수명 (의미가 명확함)
        int studentAge = 20;
        double accountBalance = 1000.50;
        String firstName = "John";
        boolean isLoggedIn = false;

        // ❌ 좋지 않은 변수명 (의미가 불분명함)
        int a = 20;
        double b = 1000.50;
        String s = "John";
        boolean flag = false;

        // 상수는 대문자와 언더스코어 사용
        final int MAX_STUDENTS = 30;
        final double TAX_RATE = 0.1;
        final String DATABASE_URL = "jdbc:mysql://localhost:3306/mydb";
    }
}

#08. 타입 변환 (Type Casting)

1) 자동 타입 변환 (Widening Conversion)

public class AutomaticTypeCasting {
    public static void main(String[] args) {
        // 작은 타입에서 큰 타입으로는 자동 변환
        byte byteValue = 10;
        short shortValue = byteValue;    // byte → short
        int intValue = shortValue;       // short → int
        long longValue = intValue;       // int → long
        float floatValue = longValue;    // long → float
        double doubleValue = floatValue; // float → double

        System.out.println("byte: " + byteValue);
        System.out.println("short: " + shortValue);
        System.out.println("int: " + intValue);
        System.out.println("long: " + longValue);
        System.out.println("float: " + floatValue);
        System.out.println("double: " + doubleValue);
    }
}

2) 강제 타입 변환 (Narrowing Conversion)

public class ManualTypeCasting {
    public static void main(String[] args) {
        // 큰 타입에서 작은 타입으로는 강제 변환 필요
        double doubleValue = 3.14;
        float floatValue = (float) doubleValue;
        long longValue = (long) floatValue;
        int intValue = (int) longValue;
        short shortValue = (short) intValue;
        byte byteValue = (byte) shortValue;

        System.out.println("double: " + doubleValue);
        System.out.println("float: " + floatValue);
        System.out.println("long: " + longValue);
        System.out.println("int: " + intValue);
        System.out.println("short: " + shortValue);
        System.out.println("byte: " + byteValue);

        // 데이터 손실 예시
        int bigNumber = 1000;
        byte smallByte = (byte) bigNumber;
        System.out.println("1000을 byte로 변환: " + smallByte); // -24 (데이터 손실)
    }
}

#09. 변수의 스코프 (Scope)

public class VariableScope {
    // 클래스 레벨 변수 (전역 변수)
    static int globalVariable = 100;

    public static void main(String[] args) {
        // 메서드 레벨 변수 (지역 변수)
        int localVariable = 200;

        System.out.println("전역 변수: " + globalVariable);
        System.out.println("지역 변수: " + localVariable);

        // 블록 레벨 스코프
        if (true) {
            int blockVariable = 300;
            System.out.println("블록 변수: " + blockVariable);
            System.out.println("지역 변수 접근: " + localVariable);
            System.out.println("전역 변수 접근: " + globalVariable);
        }

        // blockVariable은 여기서 접근 불가
        // System.out.println(blockVariable); // 컴파일 에러
    }
}

#10. 실전 문제 해결

1) 변수 값 교환

public class VariableSwap {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        System.out.println("교환 전: a=" + a + ", b=" + b);

        // 방법 1: 임시 변수 사용
        int temp = a;
        a = b;
        b = temp;

        System.out.println("교환 후: a=" + a + ", b=" + b);

        // 방법 2: 수학적 방법 (오버플로우 주의)
        a = a + b;  // a = 30
        b = a - b;  // b = 10
        a = a - b;  // a = 20

        System.out.println("다시 교환 후: a=" + a + ", b=" + b);
    }
}

2) 온도 변환 계산기

public class TemperatureConverter {
    public static void main(String[] args) {
        // 상수 정의
        final double CELSIUS_TO_FAHRENHEIT_RATIO = 9.0 / 5.0;
        final int FAHRENHEIT_OFFSET = 32;

        // 섭씨 온도
        double celsius = 25.0;

        // 화씨로 변환: F = C * 9/5 + 32
        double fahrenheit = celsius * CELSIUS_TO_FAHRENHEIT_RATIO + FAHRENHEIT_OFFSET;

        System.out.println("섭씨 " + celsius + "도는 화씨 " + fahrenheit + "도입니다.");

        // 화씨를 섭씨로 변환: C = (F - 32) * 5/9
        double backToCelsius = (fahrenheit - FAHRENHEIT_OFFSET) / CELSIUS_TO_FAHRENHEIT_RATIO;

        System.out.println("검증: 화씨 " + fahrenheit + "도는 섭씨 " + backToCelsius + "도입니다.");
    }
}

#11. 디버깅과 변수 값 확인

1) println을 활용한 디버깅

public class DebuggingWithPrint {
    public static void main(String[] args) {
        int x = 10;
        int y = 20;

        System.out.println("계산 시작");
        System.out.println("x = " + x);
        System.out.println("y = " + y);

        int sum = x + y;
        System.out.println("합계 계산 완료: " + sum);

        int product = x * y;
        System.out.println("곱셈 계산 완료: " + product);

        System.out.println("모든 계산 완료");
    }
}

2) 변수 타입 확인

public class VariableTypeCheck {
    public static void main(String[] args) {
        // 변수의 타입 정보 출력
        int intVar = 100;
        double doubleVar = 3.14;
        String stringVar = "Hello";
        boolean boolVar = true;

        System.out.println("intVar의 클래스: " + ((Object)intVar).getClass().getSimpleName());
        System.out.println("doubleVar의 클래스: " + ((Object)doubleVar).getClass().getSimpleName());
        System.out.println("stringVar의 클래스: " + stringVar.getClass().getSimpleName());
        System.out.println("boolVar의 클래스: " + ((Object)boolVar).getClass().getSimpleName());

        // instanceof 연산자 (String의 경우)
        if (stringVar instanceof String) {
            System.out.println("stringVar는 String 타입입니다.");
        }
    }
}

이제 Java 변수와 자료형에 대한 포괄적인 내용이 완성되었습니다. 기본 개념부터 실전 활용까지 다양한 예제와 함께 설명되어 있어 학습자가 단계적으로 이해할 수 있도록 구성했습니다.