[JAVA] 기초 문법 Practice1

JAVA의 JDK설치 및 환경변수 설정을 먼저 진행한 후 JAVA에서 제일 많이 쓰이는 IDE인 Intellij를 다운로드 하여 JAVA 기초 문법에 대해서 연습하였다.

본격적으로 JAVA 프로그래밍을 시작하면서 기초부터 탄탄히 공부해서 코딩테스트 문제도 잘 풀어나갈 수 있는 실력을 갖추어야겠다.

컴파일 타임 환경 / 런타임 환경

실행은 되는데 특정환경에서 에러가 나는 부분은
컴파일 타임에서 에러난 것이 아니라 런타임에서 에러난 것.

런타임 환경보다 컴파일 타임에서 에러나는 것이 좋다.
미리 에러가 나와줘야지 서비스 오픈을 안하기 때문에.

openjdk 11 download 구글 검색
java SE 11 Windows 다운로드
환경변수 설정

C:\Program Files\jdk-11.0.0.1\bin
javac.exe = 컴파일러
java.exe = 인터프리터

JDK = 자바

⭐Intellij github 연동

1. Intellij에서 파일생성
2. Intellij의 터미널에서 git init
3. git remote add origin 레포주소
4. git add .
5. git commit -m “first”
6. git push origin main

⭐변수란?
어떤 값을 담는 상자 a=3
오른쪽에 있는 값을 왼쪽에 넣는다.

- 변수(variable)란 데이터를 저장하기 위해 프로그램에 의해 이름을 할당
- 데이터(data)를 저장할 수 있는 메모리 공간을 의미
- 변수의 명명규칙
    - 영문자(대소문자), 숫자 등으로만 구성
    - 숫자로 시작할수 없음
    - 이름 사이에는 공백을 포함할 수 없음
    - 자바에서 미리 정의된 키워드는 사용할 수 없음
        - int, String등

기본형 변수

⭐실수
- 실수형 타입 중 기본이 되는 타입은 double형
- D 또는 d는 생략 가능함
- 부동 소수점(floating point) 방식이 표준
    - 많은 수를 표현할 수 있다는 장점
    - 그러나, 이진수의 근사치를 저장하다보니, 미세한 오차가 발생하여 10진수를 완벽하게 표현할 수 없다는 것은 단점
- 소수점 연산에 오차가 있다고 생각해야함.
- 이 오차를 해결하기위해 BigDecimal 사용

⭐BigDecimal
- BigDecimal은 Java에서 숫자를 정밀하게 저장하고 표현할 수 있는 방법
- 돈과 소수점을 다룬다면 BigDecimal은 선택이 아니라 필수
- BigDecimal의 유일한 단점은 느린속도, 사용의 번거로움
- 원리
    - BigDecimal타입은 내부적으로 수를 십진수 정수로 저장

⭐문자형 타입
- char
- 현재는 utf-8(유니코드)가 대부분 웹서비스의 표준
    - 2바이트

⭐논리형 타입
- 논리형은 참(true)이나 거짓(false) 중 한가지 값만을 가질 수 있는 불리언 타입
- false는 0, true 1
- 추후 제어문에서 중요하게 사용됨

⭐타입변환
- 하나의 타입을 다른 타입으로 바꾸는 것
- 묵시적(자동)타입변환
    - java에서 자동으로 상황에 맞게 타입을 변환해주는 것
    - 바이트의 크기가 작은 타입으로 타입 변환을 할 경우는 데이터의 손실이 발생하므로 컴파일러가
    오류를 발생. 큰타입으로의 변환은 가능
    - 명시적 타입변환

⭐변수
- 기본형 변수
    - 정수형 : int, long 등
    - 실수형 : float, double
    - 문자형 : char

- int는 선언만 할 경우 메모리상에 0이할당
- String은 선언만할경우 메모리상에 null이 할당

연산자
- 자바에서는 여러 종류의 연산을 수행하기 위한 다양한 연산자(operator)를 제공

전위 증감 연산자
- 현재 라인의 명령문이 실행되기 전에 값이 증감
++x

후위 증감 연산자
- 현재 라인의 명령문이 실행되고 나서 값이 증감
x++

 

//        print는 출력후 줄바꿈 없음. println은 출력후 줄바꿈
        System.out.print(a);
        
        String myString = "hello world";
//        문자열과 숫자를 합하면 문자가 된다.
        System.out.println(myString + a);
//        숫자와 숫자를 더하면 더하기 연산된다.
        System.out.println(10+20);
        
//        입력 : System.in(키보드입력) + Scanner(입력을 위한클래스)
        Scanner myScan = new Scanner(System.in);
        System.out.println("더하기를 할 숫자 2개를 입력해주세요");
        int inputs_int1 = myScan.nextInt();
        int inputs_int2 = myScan.nextInt();
        System.out.println("입력하신 두 수를 더한 값은 " + (inputs_int1+inputs_int2) + "입니다.");
        
        System.out.println("아무 문자열을 입력해주세요");
//        nextLine은 입력 받은 데이터를 한 줄 읽어서, String으로 리턴
        String inputs = myScan.nextLine();
        System.out.println("사용자가 입력한 문자열 : " + inputs);
        
//        nextInt은 입력 받은 데이터를 한 줄 읽어서, int으로 리턴
        int inputs_int = myScan.nextInt();
        System.out.println("사용자가 입력한 숫자는 : " + inputs_int);
        
        Scanner myScan = new Scanner(System.in);
        System.out.println("소수점 숫자를 입력해주세요");
        double input_double = myScan.nextDouble();
        System.out.println("사용자가 입력한 소수점 숫자 : " + input_double);
        
        Scanner myScan = new Scanner(System.in);
        System.out.println("true 또는 false를 입력해주세요");
        boolean input_boolean = myScan.nextBoolean();
        System.out.println("입력하신 true or false는 : " + input_boolean);

//        입출력 시스템 메모리 해제
//        써드 파티에 대한 사용 후 메모리 해제는 습관적으로 해주는게 좋다.
        myScan.close();
    }
}

 

import java.math.BigDecimal;

public class C02Variable {
    public static void main(String[] args) {
//        byte로 썼을때 -128~127까지의 표현이 가능하고, 그 이상을 세팅할때 오버/언더 플로우 발생.
        byte num1 = 127;
        byte num2 = -128;
        num1 ++;
        num2 --;
        System.out.println(num1);
        System.out.println(num2);

//        실수 : float, double(기본)
        float f1 = 1.123456789f;
        double b1 = 1.123456789;
        System.out.println("f1 : " + f1);
        System.out.println("b1 : " + b1);

//        부동소수점 오차 테스트
        double double_num = 0.1;
        
//        미세오차는 조정되어 정상적으로 출력
        System.out.println(double_num);

//        반복적인 연산시 오차가 확대되어 오차확인가능
        double a = 0;
        for(int i=0; i<1000; i++) {
            a = a + 0.1 * 10;
        }
        System.out.println(a/10);

        String abc = "hello";
        double d1 = 1.03;
        double d2 = 0.42;
        System.out.println(d1-d2);
        
//        저장할때는 문자열 -> 연산할때는 정수로 변환 -> 최종결과는 실수로 반환
//        정밀한 소수점 계산 할때는 BigDecimal 사용
        BigDecimal myBig1 = new BigDecimal("1.03");
        BigDecimal myBig2 = new BigDecimal("0.42");
        
//        변환 타입이 다르기 때문에 나는 에러를 doubleValue를 통해 bigdecimal을 double 형으로 변환
        double result = myBig1.subtract(myBig2).doubleValue();
        System.out.println(myBig1.subtract(myBig2));

//        문자 : char
        char my_char = '가';
        System.out.println(my_char);

//        boolean : true(1) or false(0)
//        boolean 기본값 : false(0)
        boolean my_bool = true;
        System.out.println(my_bool);
        
//        my_bool은 이미 true값이 들어가 있으므로 my_bool만 넣어줘도 성립가능
        if(my_bool) {
            System.out.println("조건식이 참 입니다.");
        }

        int bool_num1 = 20;
        int bool_num2 = 10;
//        조건식은 true아니면 false로 정의된다.
        if(bool_num1 > bool_num2) {
            System.out.println("조건식이 참 입니다.");
        }

//        묵시적 타입변환
        char ch1 = 'a';
        int ch1_num = ch1;
        System.out.println(ch1_num);
        
//        char형 알파벳 비교를 위한 묵시적 타입변환이 일어난다.
        System.out.println('A' > 'a');

        int my_int1 = 10;
//        int -> double
        double my_double1 = my_int1;
        System.out.println(my_double1);
//        에러 발생 : my_int1 = my_double1;
//        double -> int 명시적 타입은 가능 : 소수점값 손실발생 가능성이 있다.
        my_int1 = (int) my_double1;
        double my_double2 =  7.2f;
        System.out.println(my_double2);

//        명시적 타입변환
        char my_char2 = 'b';
        int char_num = (int)my_char2;
        
//        int a가 1 int b가 4일때 둘을 나눈값을 int에 담아 출력. double에 담아 출력.
        int a = 1;
        int b = 4;
        int c = a/b;
        System.out.println(c);
//        둘다 int이면 그 결과값이 int일 것으로 java가 예상을 하기때문에 이미
//        결과값이 나올때 오차가 발생. 그렇기 때문에 타입을 double로 지정해야함.(둘중에 하나라도)
        double d = a/b;
        System.out.println(d);
        double d2 = (double)a/b;
        System.out.println(d2);

//        변수와 상수
//        선언과 동시에 초기화
//        자료형은 첫 선언할때만 사용하면 된다.
        int a1 = 10;
//        변수값 변경
        a1 = 20;
        
//        선언만 한뒤에 나중에 초기화
        int a2; // 선언만 됐을때는 값이 0으로 초기화
        a2 = 20;
        
//        상수는 값의 재할당이 불가능
        final int AGES = 20;
//        상수는 값의 변경이 불가능 -> AGES = 30; 에러발생
//        상수는 선언만 한 뒤에 나중에 초기화 하는 방식이 java8이전에는 안됐었지만, 이후 가능해짐.
        final int AGES2;
        AGES2 = 20;
    }
}

 

public class C03Operator {
    public static void main(String[] args) {
    
//        산술연산자
        int num1=8, num2=3;
////        *, /나눗셈, &나머지
        System.out.println("num1 + num2 = " + (num1 + num2));
        System.out.println("num1 * num2 = " + (num1 * num2));
        
//        몫만 구하면 int로, 소수점 자리까지 구하려면 double
        System.out.println("num1 / num2 = " + (num1 / (double)num2));
        System.out.println("num1 & num2 = " + (num1 & num2));

////        대입연산자
        int n1=7, n2=7, n3=7;
        n1 = n1-3; // 4
        n2 -= 3; // 4
        n3 = -3; // -3

//        /=, %=
        int n4 = 10; int n5 = 10;
        n4 /= 3;
        n5 %= 3;
        System.out.println("n4 = " + n4 + " n5 = " + n5);

//        증감연산자
//        ++는 헷갈리니까 따로빼서 쓰자!
        int a = 5;
        int b = a++; //후위연산자 : 실행문이 끝나고 증감
        System.out.println(a); //6
        System.out.println(b); //5

        a=5;
        b=++a; //전위연산자 : 실행문이 끝나기전에 증감
        System.out.println(a);
        System.out.println(b);

        int[] arr = {10,20,30};
        a=0;
        while(true) {
            System.out.println(arr[a]);
            a++;
        }

//        비교연산자 : ==, !=, >, >= ...
        char char1 = 'a';
        char char2 = 'A';
//        boolean 타입
        System.out.println(char1 == char2); //flase
        System.out.println(char1 != char2); //true

//        논리연산자 : &&, ||, !
        int num1 = 10; int num2=20;
        boolean result1, result2;
//        result1에 num1이 5보다 큰지 조건과 num1 20보다 작은지 조건을 and 조건을 통해 boolean값 담기
        result1 = (num1 > 5) && (num1 < 20);
        System.out.println(result1);
//        result2에 num2가 10보다 작은 조건과 num2가 30보다 작은 조건을 or조건을 통해 boolean값 담기
        result2 = (num2 < 10) || (num2 < 30);
        System.out.println(result2);
//        result1, result2 각각 출력
//        result2에 !달아서 출력
        System.out.println(!result2);

//        비트연산자 : &, 각자리의 수가 모두 1일경우에만 1
        System.out.println(2 & 1);
        System.out.println(2>0 & 3>0);
        int n1 = 10; int n2 = 20;
        if(n1>20 && n2<30){
            System.out.println("조건은 참입니다.");
        }
    }
}