TIL 241008

 

 

Java 문법 종합반 1주차

 

---

 

 

Java

- 공통 실행환경이 있어서 여러 기기에서 실행 가능하다.

- 코드를 이해하기 쉽고 유지 보수가 쉽다.

- 안정성이 높아서 프로그래밍 오류를 방지하고 보안상 안전하다.

  (Compiler가 먼저 오류를 체크)

- 대규모 앱 개발이 가능하다.

- 다양한 개발 도구와 라이브러리를 사용할 수 있다.

 

JVM

"Java Virtual Machine" 의 약자로 “자바 가상 머신”이라는 뜻

여러가지의 기기위에 Java 프로그램을 실행시킬 수 있는 가상의 기기를 만들어주는 것을 의미한다. 

JVM은 Java의 놀이터라고 보면 됨

어느 장비(PC,모바일,서버 등..)에서든 JVM 을 깔아주면 Java가 놀 수 있는 놀이터가 된다. 

 

 

※ JVM 구성

 

바이트 코드
Java 프로그램 변환코드

작성한 코드가 운영체제가 읽을 수 있는 코드(바이트 코드)로 Java 컴파일러가 변환한 코드

 

Java 컴파일러

작성한 Java 코드들(.java 파일)을 운영체제가 읽을 수 있는 바이트 코드(.class 파일) 로 변환하는 변환기

 

인터프리터
Java .class 코드 해석기
운영체제가 읽은 바이트 코드를 기기(기계)가 실행할 수 있는 기계어로 번역

JIT 컴파일러
빠른 Java .class 코드 해석기
인터프리터의 효율을 높여주는 서포터 해석기

메모리 영역
Java 데이터를 저장하는 영역
운영체제로 부터 JVM이 할당받은 메모리 영역

클래스 로더
Java .class 바이트 코드를 메모리 영역에 담는 운반기
JVM으로 class(바이트 코드)를 불러와서 메모리에 저장함

가비지 컬렉터
Java 쓰레기 청소기
메모리 영역에서 안쓰는 데이터를 주기적으로 흡수해가는 청소기

 

// 클래스
// public : (접근)제어자, public(공공의, 공통의)
public class Main {

    // [JDK]
    // (1) compiler : .java -> .class
    // (2) JRE
    // (3) JDB : 디버깅
    
    // () : 소괄호
    // {} : 중괄호
    // [] : 대괄호
    
    // main  메소드
    // 자바 프로젝트(앱)는, 제일 먼저 클래스의 main 메소드를 실행시킨다.
    // = JVM의 약속
    // static : 이 프로그램이 시작될 때 무조건 실행되는 녀석임을 표현

    // output
    // void : 메서드의 출력값의 데이터 타입
    // void : "아무것도 없다." -> 출력은 없다.

    // input
    // String[] args : 매개변수 자리
    public static void main(String[] args) {

        // 객체 : 특징(속성, 변수), 행동(메소드)
        // print -> 줄 바꿈은 하지 x
        // println -> 줄 바꿈 o
        // ln : line
        // System.out.println("Our First ");

        // 1. 7
        // 2. 3
        // 3. 3.14
        // 4. JAVA
        System.out.println(7); // 숫자를 쌍따옴표로 감싸면 숫자가 아니라 7이라는 문자를 표현한 것
        System.out.println(3);
        System.out.println(3.14);
        System.out.println("JAVA"); // 문자를 쓸 때는 쌍따옴표로 감싸야 한다. 아무것도 안하면 변수로 인식함

    }
}

 

 

 

 

기본형 변수

 

논리형 변수: boolean

True/False 값만 저장

public class Main {

    public static void main(String[] args) {
        // 우리의 playground!

        // (1) boolean
        // 변수를 선언해보자 ==> 타입 이름 = 값;
        boolean flag = true;
        flag = false;

        System.out.println(flag);
    }
}

 

 

 

문자형 변수: char

'A' , '1'과 같은 문자 하나만 저장

public class Main {

    public static void main(String[] args) {
        // 우리의 playground!
        // (2) 문자형(char)
        char alphabet = 'A'; // 쌍싸옴표로 넣어주면 문자형이 아니라 문자열로 인식
        System.out.println(alphabet);
    }
}

 

 

 

정수형 변수: byte, short, int, long

 

1byte = 8bit

bit : 0과 1을 표현

byte =  - 128 ~ 127

              => 256

byte : -128 ~ 127 범위의 숫자만 저장
short (2byte) 는 -32,768~32,767 범위의 숫자만 저장
int (4byte) 는 -21억~21억 범위의 숫자만 저장
long (8byte) 은 9백경 정도의 매우 큰수를 저장. 숫자뒤에 알파벳 L 을 붙여서 표기한다.

 

각 변수 표현 범위를 넘는 숫자를 넣게되면 오버플로우가 발생한다.

public class Main {

    public static void main(String[] args) {
        // 우리의 playground!
        // (3) 정수형(byte, short, int, long)

        byte byteNumber = 127; // -128 ~ 127(1byte)
        short shortNumber = 32767; // -32,768 ~ 32,767
        int intNumber = 2147483647;
        long longNumber = 2147483647L;

        System.out.println(byteNumber);
        System.out.println(shortNumber);
        System.out.println(intNumber);
        System.out.println(longNumber);
    }
}

 

 

 

실수형 변수: float, double

 

0.123, 0.99999 와 같은 소수점 실수값을 저장

float(4byte), double(8byte)

float 와 double 의 데이터값(리터럴)을 구분하기 위한 구분자로 float으로 담을 숫자뒤에 f 를 붙인다.

데이터값(리터럴) 뒤에 붙이는 구분값을 "접미사" 라고 함

public class Main {

    public static void main(String[] args) {
        // 우리의 playground!
        // (4) 실수형
        // float(4byte), double(8byte)

        float floatNumber = 0.123F;
        double doubleNumber= 0.123123123;

        // 변수를 할당하고 뒤에서 쓴다 = 변수를 참조한다.
        System.out.println(floatNumber);
        System.out.println(doubleNumber);
    }
}

 

 

 

참조형 변수

 

문자열 변수: String

public class Main {

    public static void main(String[] args) {
        // 우리의 playground!
        // 참조형!
        // (1) 문자열 변수
        String helloWorld= "Hello world!";

        System.out.println(helloWorld);
    }
}

 

 

 

배열: Object, Array, List ...

객체, 배열, 리스트와 같은 단일 저장공간에 담을 수 없는 값을 저장

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        // 우리의 playground!
        // 참조형!
        // (1) 문자열 변수
        // String helloWorld= "Hello world!";
        // (2) 배열
        int[] a = {1,2,3};

        System.out.println(a); // [I@4c873330
        System.out.println(Arrays.toString(a)); // [1, 2, 3]
    }
}

 

 

 

래퍼 클래스 변수

 

기본형 변수를 클래스로 한번 랩핑(감싸는) 변수

 

박싱: 기본 타입에서 래퍼 클래스 변수로 변수를 감싸는 것

언박싱: 래퍼 클래스 변수를 기본 타입 변수로 가져오는 것

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        // 우리의 playground!
        // 래퍼 클래스(Wrapper Class 변수)
        int number=21;

        Integer num = number; // boxing

        System.out.println(num.intValue()); // unboxing
    }
}

 

 

숫자를 문자로 변환

// 숫자 -> 문자
// import im(in) + port(항구)
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int asciiNumber = sc.nextInt();
        char ch = (char)asciiNumber; // 문자로 형변환을 해주면 숫자에 맞는 문자로 표현된다.

        System.out.println(ch);
    }
}

 

입력 97

출력 a

 

 

문자를 숫자로 변환

// 문자 -> 숫자

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        char letter = sc.nextLine().charAt(0); // 첫번째 글자만 받아오기위해 charAt(0) 메서드를 사용한다.
        int asciiNumber = (int)letter; // 숫자로 형변환을 해주면 저장되어있던 아스키 숫자값으로 표현된다.

        System.out.println(asciiNumber);
    }
}

 

입력 a

출력 97

 

 

 

문자와 문자열의 차이

 

선언 관점에서 차이점

 

문자 (char)

문자 한 개만 저장하며 따옴표를 사용하여 값을 지정 (ex. ’A’)

char alphabet = 'A';

 

문자열 (String)

문자 여러 개를 문장 형태로 저장하며 쌍따옴표를 사용하여 범위를 지정 (ex. “ABCDEFG”)

String message = "Hello World";

 

 

참조형 변수

 

다른 기본형 변수가 실제 값을 저장하는 저장공간 이라면 참조형 변수는 실제 값이 아닌 원본값의 주소값을 저장한다.

 

기본형 변수 : 원본값이 Stack 영역에 있음
참조형 변수 : 원본값이 Heap 영역에 있음

                      Stack 영역에는 따로 저장 해둔 원본값의 Heap 영역주소를 저장한다.

 

Stack 영역 vs Heap 영역

Stack

정적으로 할당된 메모리 영역
크기가 몇 byte 인지 정해져있는 기본형 변수를 저장. 추가로, 크기가 정해져있는 참조형 변수의 주소값도 저장.
Heap

동적으로 할당된 메모리 영역 (동적=>알 수 없을 때)
크기가 계속 늘어날 수 있는 참조형 변수의 원본을 저장

 

 

 

입력, 출력

 

입력

 

Java 프로그램에서는 기본적으로 Scanner.in 객체의 next() 명령을 사용해서 입력받는다.

Scanner sc = new Scanner(System.in); // Scanner 객체를 new 명령어로 생성
String input = sc.next(); // sc(Scanner)의 .next(); 를 실행하면 input 변수에 입력한 글자를 받을 수 있다.

 

출력 

 

Java 프로그램에서는 기본적으로 System.out 객체의 println() 명령을 사용해서 출력

Scanner sc = new Scanner(System.in);
String input = sc.next();
System.out.println("입력값 : " + input); // 입력한 글자를 출력
// 실행 결과
{입력}
입력값 : {입력}

 

 

비트&바이트

Byte = 8 Bit
Byte(바이트)는 8개의 Bit(비트)로 구성
1 Byte 내에서 숫자 변수는 Bit 2진수를 10진수로 저장(표현)
10진수로는 0~255(2의8승)까지 저장(표현)
1 Byte 내에서 문자 변수의 경우만 Bit 2진수를 16진수로 저장(표현)

 

..뭔 말인지 모르겠다..

 

 

전체 주석처리 하는 방법

(windows) Ctrl + / 

주석처리 안될 때 => Ctrl + Shift 눌러서 Microsoft 입력기로 바꾸기

 

 

변수 타입 바꾸기(형변환)

 

Double, Float to Int

public class Main {

    public static void main(String[] args) {
        //형 변환 예제: 변수의 타입을 바꾸는 방법
        // 문자열 -> 숫자
        // 정수 -> 실수
        // 실수 -> 정수

        // double형 or float형 -> int
        // 실수 -> 정수(0.xxx -> 0)
        double doubleNumber = 10.101010;
        float floatNumber = 10.1010f;

        // 변환(int)
        int intNumber;
        intNumber = (int)doubleNumber; // double -> int
        System.out.println("Double Type => " + doubleNumber); // Double Type => 10.10101
        System.out.println("Int Type => " + intNumber); // Int Type => 10
    }
}

public class Main {

    public static void main(String[] args) {
        //형 변환 예제: 변수의 타입을 바꾸는 방법
        // 문자열 -> 숫자
        // 정수 -> 실수
        // 실수 -> 정수

        // double형 or float형 -> int
        // 실수 -> 정수(0.xxx -> 0)
        double doubleNumber = 10.101010;
        float floatNumber = 10.1010f;

        // 변환(int)
        int intNumber;
        intNumber= (int)floatNumber;

        System.out.println("Float Type => " + floatNumber); // Float Type => 10.101
        System.out.println("Int Type => " + intNumber); // Int Type => 10
    }
}

 

 

Int to Double, Float

public class Main {

    public static void main(String[] args) {
        //형 변환 예제: 변수의 타입을 바꾸는 방법
        // 정수 -> 실수
        int intNumber = 10;

        double doubleNumber = (double)intNumber;
        float floatNumber = (float)intNumber;

        System.out.println("intNumber => "+intNumber);
        System.out.println("doubleNumber => "+doubleNumber);
        System.out.println("floatNumber => "+floatNumber);
    }
}

 

 

 

자동 형변환

 

1) 자동 타입변환은 작은 크기의 타입에서 큰 크기의 타입으로 저장될 때 큰 크기로 형변환이 발생한다.

public class Main {

    public static void main(String[] args) {
        // 변수 타입별 크기 순서
        // byte(1) -> short(2) -> int(4) -> long(8) -> float(4) -> double(8)
        // float가 long 보다 크기가 더 큰 이유? 부동소수점을 쓰고있기 때문에 표현할 수 있는 식이 더 많다.

        // (1) byte -> int
        byte byteNumber = 10;
        int intNumber = byteNumber;
        System.out.println(intNumber); // 10

        // (2) char(1 byte) -> int(4) 형변환
        char charAlphabet = 'A';
        intNumber = charAlphabet; // char -> int로 자동 형변환
        System.out.println(intNumber); // 65 (대문자 A가 가지고 있는 유니코드)

        // (3) int -> long number 혛변환
        intNumber = 100;
        long longNumber = intNumber;
        System.out.println(longNumber); // 100

        // (4) int -> double 형변환
        intNumber = 200;
        double doubleNumber = intNumber;
        System.out.println(doubleNumber); // 200.0
    }
}

 

 

2) 작은 크기의 타입이 큰 크기의 타입과 계산될 때 자동으로 큰 크기의 타입으로 형변환이 발생한다.

public class Main {

    public static void main(String[] args) {
        // 작은 크기의 타입이 큰 크기의 타입과 '계산'될 때,
        // 자동으로 큰 크기의 타입으로 형 변환이 된다.
        int intNumber = 10;
        double doubleNumber = 5.5;
        double result = intNumber + doubleNumber;

        System.out.println("Plus => " + result); // Plus => 15.5

        // 1) 정수로 나누기
        int iResult = intNumber / 4;
        // 2) 실수로 나누기
        double dResult = intNumber / 4.0;

        System.out.println(iResult + " / " + dResult);// 2 / 2.5
    }
}

 

int형 연산 => 소수점 버려짐

double형 연산 => 소수점 저장

 

 

자동 형변환 vs 강제 형변환

작은 타입 > 큰 타입 형변환시 (자동 형변환)
더 큰 표현범위를 가진 타입으로 변환되는것이라 값의 손실이 없음
값의 손실없이 변환이 가능하기 때문에 컴파일러가 자동으로 형변환을 해준다.

큰 타입 > 작은 타입 형변환시 (강제 형변환 = 캐스팅)
더 작은 표현범위를 가진 타입으로 변환된는것이라 값의 손실이 생김
값의 손실이 생기기 때문에 자동으로 형변환을 해주지 않고 개발자가 선택하여 형변환을 한다.