권현재

이번에는 객체지향언어의 두번째 특정 상속에 대해 알아보자

일반적으로 상속이라고 하면 부모가 자식에게 물려줄때 사용된다.

Java에서도 똑같다.

100개의 method가 있는 class A가 있다고 가정하자.

이때 이미 A는 많은 곳에서 사용되고 있고 변경하기에는 위험부담이 있을 수 있다.

이때는 A의 기능을 그대로 가져오면서, 새로운 method를 추가할 수 있는데 이때 상속 개념을 이용할 수 있다.

아주 쉽게 아래의 코드를 살펴보자 ( extends 사용 )

package lifeCoding_Inheritance;

// 부모가 만든기능을 자식이 가져올 수 있고 자식을 부모로 한 자식을 또 만들 수 있음

class Calculator{
    int left, right;

    public void setOprands(int left, int right){
        this.left = left;
        this.right = right;
    }

    public void sum(){
        System.out.println(this.left+this.right);
    }

    public void avg(){
        System.out.println((this.left+this.right)/2);
    }
}

class MultiplicationableCalculator extends Calculator { // 뺄셈 불가능
    public void multiplication(){
        System.out.println(this.left * this.right);
    }
}

class DivisionableCalculator extends MultiplicationableCalculator { // 곱하기 가능
    public void division(){
        System.out.println(this.left / this.right);
    }
}
public class _03_ {
    public static void main(String[] args) {
        DivisionableCalculator c1 = new DivisionableCalculator(); // 뺄셈 기능은 없음
        c1.setOprands(20, 10);
        c1.sum();
        c1.avg();
        c1.multiplication(); // 200
        c1.division(); // 2
    }
}

더하기, 나누기 기능이 있는 Calculator를 상속받은 MultCalculator, MultCalculator의 기능을 상속받은 DivisionCaculaotr

이렇게 상속받은 클래스를 인스턴스 c1에 저장하여 method를 사용할 수 있다.

java에도 scope 개념이 있다.

scope( 유효 범위 ) 는 사실 지금까지 코드를 작성하면서 당연시하게 생각했던 것들 중 몇가지가 있다.

한마디로 정리하면 변수가 접근할 수 있는 범위 라고 생각하면 좋을 것 같다.

let i = 0;

for (let i = 0; i < 5; i++) {
	System.out.println(i); // 0, 1, 2, 3, 4 
}

System.out.println(i); // 0

이렇게 for문 안에 있는 i는 밖에서 사용할 수 없다.

그럼 아래 코드처럼 변경하면 어떻게 될까 ?

package lifeCoding_03_scope;

// 무한 루프
public class _02_ {
    static int i; 
    
    static void a() {
        i = 0; 
    }
    
    public static void main(String[] args) {
        for (i = 0; i < 5; i++) {
            a();
            System.out.println(i); // 무한 반복
        }
    }
}

아래 코드를 보면 scope의 개념을 명확하게 잡을 수 있다.

즉 메소드에 변수가 선언되지 않았을 경우 클래스에서 같은 이름의 변수를 찾아올 수 있지만, 그 반대는 적용 될 수 없다.

package lifeCoding_03_scope;

class C {
    int v = 10;
    void m() {
        int v =  20;
        System.out.println("v : " + v);           // 지역변수
        System.out.println("this.v : " + this.v); // 전역변수
    }
}
public class _06_ {
    public static void main(String[] args) {
        C c1 = new C();
        c1.m();
    }
}

참고 영상 : https://www.youtube.com/playlist?list=PLuHgQVnccGMCeAy-2-llhw3nWoQKUvQck

class는 객체지향언어에서 핵심적으로 사용하는 기능 중 하나라고 할 수 있다.

class는 무엇인가 ?

class는 하나의 "물건" 이라고 할 수 있으며 java에서 모든 코드는 class안에서 존재해야한다.

class Calculator {
    int left, right;
    public void setOprands(int left, int right) {
        this.left = left;
        this.right = right;

        // this.left -> "Calculator 안에서" 선언된 left
        // left -> 매개변수
    }
    public void sum(){
        System.out.println(this.left + this.right);
    }
    public void avg(){
        System.out.println( (this.left + this.right) / 2);
    }
}

그럼 class와 method의 차이점은 무엇일까?

간단하게 method는 class의 기능이라고 생각하면 간단하다.

class -> 계산기

method -> 더하기, 빼기, 곱하기 등등...

그럼 위 class와 method 는 어떻게 사용할까?

아래의 코드 예시를 통해 인스턴스 개념도 함께 알아 볼 수 있다.

public class _04_ {
    public static void main(String[] args) {
        Calculator c1 = new Calculator();
        
        // new Calculator() : Calculator 객체를 새로 만들어 c1에 담음, ( c1은 타입은 new 객체와 동일해야합니다. - 해당 객체만 품을 수 있음 )
        // 인스턴스 : c1에 담겨있는 실제 객체의 내용, 구체적인 객체
        
        c1.setOprands(10, 20); // c1안에는 Calculator 객체가 들어있고, setOprands 메소드에 10, 20 매개변수 적용
        c1.sum(); // 30
        c1.avg(); // 15

        Calculator c2 = new Calculator(); // new 연산자를 통해 새로운 인스턴스 (c1, c2 ... ) 를 담아 언제든지 sum, avg 메서드를 호출해서 원하는 작업이 가능합니다.
        c2.setOprands(20, 40);
        c2.sum();
        c2.avg();
    }
}

클래스 : Calculator();

인스턴스 : c1, c2

그럼 왜 class와 instance는 왜 구분하고 어떻게 선언할까?

class 안에 매우 많은 method가 있다고 가정해보자.

이때 전역적으로 공통적으로 사용되는 변수와 해당 기능에서만 사용하는 변수를 구분하기 위해 사용할 수 있다.

( scope 개념이 들어가는데 해당 내용은 scope 게시글에서 자세히 알아보자 )

그래서 아래와 같이 정리할 수 있다.

클래스 변수 : 클래스가 가지고 있는 변수를 모든 인스턴스에서 받아서 사용 가능 -> 인스턴스 메소드에 접근 불가능
인스턴스 변수 : 인스턴스마다 다른 값을 가지는 변수 -> 클래스 메소드에 접근 가능

아래 예시 코드를 천천히 보면 이해할 수 있을 것이다.

package lifeCoding_02_member;

// 인스턴스 변수 -> Non-Static Field
// 클래스 변수 -> Static Field
// 클래스 메소드에서는 인스턴스 변수에 접근 할 수 없다.
// 인스턴스 메소드에서는 클래스 변수에 접근 할 수 있다.

class C1{
    static int static_variable = 1; // 클래스 변수 ( static 변수 )
    int instance_variable = 2; // 인스턴스 변수 ( static 없음 )
    static void static_static(){ // 클래스 메소드가 클래스 변수를 호출
        System.out.println(static_variable);
    }
    static void static_instance(){ // 클래스 메소드가 인스턴스 변수를 호출
        // 클래스 메소드에서는 인스턴스 변수에 접근 할 수 없다.
        // System.out.println(instance_variable);
    }
    void instance_static(){
        // 인스턴스 메소드에서는 클래스 변수에 접근 할 수 있다.
        System.out.println(static_variable);
    }
    void instance_instance(){
        System.out.println(instance_variable);
    }
}
public class _04_ {
    public static void main(String[] args) {
        C1 c = new C1();
        // 인스턴스를 이용해서 정적 메소드에 접근 -> 성공
        // 인스턴스 메소드가 정적 변수에 접근 -> 성공
        c.static_static(); // 1

        // 인스턴스를 이용해서 정적 메소드에 접근 -> 성공
        // 정적 메소드가 인스턴스 변수에 접근 -> 실패
        c.static_instance(); // 에러 발생, static 메소드에서 instance 변수에 접근할 수 없다.

        // 인스턴스를 이용해서 인스턴스 메소드에 접근 -> 성공
        // 인스턴스 메소드가 클래스 변수에 접근 -> 성공
        c.instance_static(); // 1

        // 인스턴스를 이용해서 인스턴스 메소드에 접근 -> 성공
        // 인스턴스 메소드가 인스턴스 변수에 접근 -> 성공
        c.instance_instance(); // 2

        // 클래스를 이용해서 클래스 메소드에 접근 -> 성공
        // 클래스 메소드가 클래스 변수에 접근 -> 성공
        C1.static_static(); // 1

        // 클래스를 이용해서 클래스 메소드에 접근 -> 성공
        // 클래스 메소드가 인스턴스 변수에 접근 -> 실패
        C1.static_instance(); // 에러 발생

        // 클래스를 이용해서 인스턴스 메소드에 접근 -> 실패
        // C1.instance_static(); // 에러 발생

        // 클래스를 이용해서 인스턴스 메소드에 접근 -> 실패
        // C1.instance_instance(); // 에러 발생
    }

}

Java에서 Method (함수) 를 활용할 수 있습니다.

앞에서 기본적으로 main 함수안에 코드를 작성하였는데, main 앞에 void가 있습니다.

void 위치는 Method return 값의 타입을 의미하며, return 값이 없을경우 void로 표시합니다.

아래의 예시를 보면 getPowerByexp() Method는 return 값으로 int 형을 내보내고, main()의 경우 return 값이 없는 것을 확인 할 수 있습니다.

public class _04_ParameterAndReturn {
    public static int getPower(int number) {
        int result = number * number;
        return result;
        // return number * number
    }
    public static int getPowerByExp(int number, int exponent) {
        int result = 1;
        for (int i = 0; i < exponent; i++) {
            result *= number;
        }
        return result;
    }
    public static void main(String[] args) {
        // 전달값과 반환값이 있는 메소드
        int retVal = getPower(2);
        System.out.println((retVal)); // 2 * 2 = 4

        retVal = getPower(3);
        System.out.println(retVal); // 3 * 3 = 9

        retVal = getPowerByExp(3,3);
        System.out.println(retVal); // 3 * 3 * 3 = 27

        System.out.println(getPowerByExp(2,4)); // 2 * 2 * 2 * 2 = 16
    }
}

그럼 여기서 Java의 오버로딩 개념을 알아볼 수 있습니다.

Java에서는 Method를 만들때 return 값을 미리 정하여 생성합니다.

그럼 return 값이 다르고, Method 이름이 같은 경우 어떻게 될까요?

이때는 전달값(매개변수)의 타입과 갯수에 맞는 Method를 자동으로 찾아 실행시키는데 이것을 overLoading이라고 합니다.

public class _05_Overloading {
    public static int getPower(int number) {
        int result = number * number;
        return result;
        // return number * number
    }

    public static int getPower(String strNumber) {
        int number = Integer.parseInt(strNumber); // 문자열값을 뽑아서 int 로 변환
        return number * number;
    }

    public static int getPower(int number, int exponent) {
        int result = 1;
        for (int i = 0; i < exponent; i++) {
            result *= number;
        }
        return result;
    }

    public static void main(String[] args) {
        // 메소드 오버로딩
        // 같은 이름의 메소드를 여러 번 선언
        // 1. 전달값(매개변수)의 타입이 다르거나
        // 2. 전달값(매개변수)의 갯수가 다르거나
        // 3. 반드시 함수의 조건(타입)이 아닌 매개변수의 타입이나 갯수여야함
        System.out.println(getPower(3)); // 3 * 3 = 9
        System.out.println(getPower("4")); // 4 * 4 = 16
        System.out.println(getPower(3,3)); // 3 * 3 * 3 = 27
    }
}

사실 지금까지 조건문, 반복문은 다른 언어와 크게 다르지 않아 문법의 예시만 간단하게 작성하였다.

그러나 지금부터는 Java만의 사용방법이 나온다. 

첫번째로 Java의 배열 선언 방법이다.

우선 배열이란 같은 자료형의 값 여러개를 저장하는 연속된 공간을 의미한다.

하나의 변수에 하나의 값만 할당하는것이 아니라, 하나의 변수에 배열을 할당하여 index 에 맞게 호출하여 사용할 수 있게 해준다.

첫번째 배열 선언 방법 

String[] coffees = new String[4]; // 최대 4개의 값이 들어갈 수 있는 배열을 coffees에 할당한다.

coffees[0] = "아메리카노"; 
coffees[1] = "카페모카";
coffees[2] = "라떼";
coffees[3] = "카푸치노";

두번째 배열 선언 방법

String[] coffees = new String[] { "아메리카노", "카페모카", "라떼", "카푸치노" };

세번째 배열 선언 방법

String[] coffees = { "아메리카노", "카페모카", "라떼", "카푸치노" };

위 예제 모두 값으로 String이 할당되어야 하는 공통점이 있다. 또한 첫번째 방법으로 배열의 index값을 재선언하는것도 가능하다.

위에 예제를 1차원 배열이라고 한다.

그러나 배열안에 배열이 들어가는 경우 ( 2차원 배열)가 발생한다면 어떻게 할까?

        String[] seatA = {"A1", "A2", "A3", "A4", "A5"};
        String[] seatB = {"B1", "B2", "B3", "B4", "B5"};
        String[] seatC = {"C1", "C2", "C3", "B4", "B5"};

        // 3 x 5 크기의 2차원 배열
        String[][] seats = new String[][] {
                {"A1", "A2", "A3", "A4", "A5"},
                {"B1", "B2", "B3", "B4", "B5"},
                {"C1", "C2", "C3", "C4", "C5"},
        };

위의 예제처럼 2차원 배열을 표현할 수 있다.

위에 내용이 모두 이해되었다면 아래의 출력값을 예측해보자

        // 10 x 15 에 해당하는 영화관 좌석
        String[][] seats3 = new String[10][15];
        String[] eng = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J"};
        for (int i = 0; i < seats3.length; i++) {
            for (int j = 0; j < seats3[i].length; j++) {
                seats3[i][j] = eng[i] + (j + 1);
            }
        }

하나의 for문을 사용하는 것 말고 이중 for문과 while, 그리고 Continue에 대해 알아보자

        // 이중 반복문

        // 별 (*) 사각형 만들기
        /*

        *****
        *****
        *****
        *****
        *****

         */
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println( "--------------------");

        // 별 (*) 왼쪽 삼각형 만들기

        /*

        *
        **
        ***
        ****
        *****

         */

        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < i + 1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println("--------------------");

        //별 (*) 오른쪽 삼각형 만들기

        /*
        
            *
           **
          ***
         ****
        *****

         */

        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 4 - i; j++) {
                System.out.print(" ");
            }
            for (int k = 0; k <= i ; k++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

        // continue

        // 치킨 주문 손님중에 노쇼 손님이 있다고 가정

        // for 문
        int max = 20; // 최대 치킨 판매 수량
        int sold = 0; // 현재 치킨 판매 수량
        int noShow = 17; // 대기번호 17번 손님이 노쇼
        for (int i = 1; i <= 50; i++) {
            System.out.println(i + "번 손님, 주문하신 치킨 나왔습니다.");

            // 손님이 없다면 ? (noShow)
            if (i == noShow) {
                System.out.println(i + "번 손님, 노쇼로 인해 다음 손님에게 기회가 넘어갑니다.");
                continue; // 실행을 멈추고 다음 증감문 실행 ( sold 가 +1 되지 않음 )
            }

            sold++; // 판매 처리
            if(sold == max) {
                System.out.println("금일 재료가 모두 소진되었습니다.");
                break;
            }
        }
        System.out.println("영업을 종료합니다.");

        System.out.println("--------------------");

        // while 문
        sold = 0;
        int index = 0; // 손님 번호
        while (index < 50) {
            index++;
            System.out.println(index + "번 손님, 주문하신 치킨 나왔습니다.");

            // 손님이 없다면 ( noShow )
            if(index == noShow) {
                System.out.println(index + "번 손님, 노쇼로 인해 다음 손님에게 기회가 넘어갑니다.");
                continue;
            }

            sold++;
            if(sold == max) {
                System.out.println("금일 재료가 모두 소진되었습니다.");
                break;
            }

        }
    }

자바에서 if, else if, SwitchCase를 사용하는 방법은 JavaScript와 크게 다르지 않다.

하나씩 예제를 살펴보자

if 문

 // 조건문 if
        int hour = 10; // 오전 10시
        // if 문 내에서 하나의 문장을 실행할 때는 { } 생략 가능
        if (hour < 14) System.out.println("아이스 아메리카노 + 1");
        if (hour < 14) {
            System.out.println("아이스 아메리카노 + 1");
            System.out.println("샷추가");
        }
        System.out.println("커피 주문 완료 #1");

else if

        hallabongAde = false; // 한라봉 에이드
        mangoJuice = false; // 망고 주스
        boolean orangeJuice = false;

        if (hallabongAde) {
            System.out.println("한라봉 에이드 + 1");
        } else if (mangoJuice) {
            System.out.println("망고 주스 + 1");
        } else if (orangeJuice) {
            System.out.println("오렌지 주스 + 1");
        } System.out.println("아이스 아메리카노 + 1");

        System.out.println("커피 주문 완료 #2");

switch Case

        //Switch Case

        // 석차에 따른 장학금 지급
        // 1등 : 전액 장학금
        // 2등 : 반액 장학금
        // 3등 : 반액 장학금
        // 그 외 : 장학금 대상 아님
        
        int ranking = 4; // 등수

// ranking 이 1이면 case 1, case 값이 아니면 default 값 실행
        ranking = 2;
        switch (ranking) {
            case 1 :
                System.out.println("전액 장학금");
                break;
            case 2 :
                System.out.println("반액 장학금");
                break;
            case 3:
                System.out.println("반액 장학금");
                break;
            default:
                System.out.println("장학금 대상 아님");
        }
        System.out.println("조회 완료 #2");
        
        
        
// 중고상품의 등급에 따른 가격을 책정 (1급 : 최상, 4급 : 최하)
        int grade = 1; // 등급
        int price = 7000; // 기본 가격

        switch (grade) {
            case 1 : price += 1000;
            case 2 : price += 1000;
            case 3 : price += 1000;
            break;
        }
        System.out.println(grade + "등급 제품의 가격은 : " + price + "원");
        // 1등급이면 1, 2, 3일때의 구문 모두 실행
        // 2등급이면 1 등급일때의 구문 실행 x

기본적으로 문자열을 컨트롤 할 수 있는 메소드들이 있다.

        String s = "I like Java and Python and C.";
        System.out.println(s); // I Like Java and Python and C.

        // 문자열의 길이
        System.out.println(s.length()); // 29

        // 대소문자 변환
        System.out.println(s.toUpperCase()); // 대문자로
        System.out.println(s.toLowerCase()); // 소문자로

        // 포함 관계
        System.out.println(s.contains("Java")); // 포함된다면 true, 포함되지 않는다면 false
        System.out.println(s.contains("C#")); // false
        System.out.println(s.indexOf("Java")); // 위치(index) 정보 7
        System.out.println(s.indexOf("C#")); // -1
        System.out.println(s.indexOf("and")); // 처음 일치하는 위치 정보 12
        System.out.println(s.lastIndexOf("and")); // 마지막에 일치하는 위치 정보 23
        System.out.println(s.startsWith("I like")); // 해당 문자열로 시작하면 true, 아니면 false
        System.out.println(s.endsWith(".")); // 해당 문자열로 끝나면 true, 아니면 false

 String s = "I like Java and Python and C.";
 
 // 문자열 변환
 System.out.println(s.replace("and", ",")); // "and" 를 "," 로 변환
 System.out.println(s.substring(7)); // 인덱스 기준 7 부터 시작 (이전 내용은 삭제)
 System.out.println(s.substring(s.indexOf("Java")));
 // "Java" 가 시작하는 위치부터, "." 이 시작하는 위치 바로 앞까지
 System.out.println(s.substring(s.indexOf("Java"), s.indexOf("."))); // 시작 위치부터 끝 위치 "직전" 까지
 
 // 공백 제거
 s = "       I Love Java.      ";
 System.out.println(s);
 System.out.println(s.trim()); // 앞뒤 공백 제거
 
 // 문자열 결합
 String s1 = "Java";
 String s2 = "Python";
 System.out.println(s1 + s2);
 System.out.println(s1 + "," + s2); // Java,Python
 System.out.println(s1.concat(",").concat(s2)); // Java,Python // s1에 ,를 결합하고 또 s2를 결합시킴

// 문자열 비교
String s1 = "Java";
String s2 = "Python";

System.out.println(s1.equals("Java")); // 문자열 내용이 같으면 true, 다르면 false
System.out.println(s2.equals("python")); // 대소문자가 다르므로 false
System.out.println(s2.equalsIgnoreCase("python")); // 대소문자 구분 없이 문자열 같은지 여부 체크

// 문자열 비교 심화 (자바에서 문자열을 비교하기 위해서는 == 가 아니라 equals 메서드를 사용해야함 ★
s1 = "1234"; // 벽에 붙은 메모지의 비밀번호 정보 (참조)
s2 = "1234";
System.out.println(s1.equals(s2)); // true (내용 비교)
System.out.println(s1 == s2); // true (참조 비교)

s1 = new String("1234");  // 각각 테이블에 따라 비밀번호가(메모) 다름
s2 = new String("1234");
System.out.println(s1.equals(s2)); // true
System.out.println(s1 == s2); // 서로 참조가 다르므로 (각각 다른 메모리 공간을 사용) false

// 특수문자, 이스케이프 문자 (Escape Sequence, Escape Character, Special Character)
// \n, \t, \\, \", \'

System.out.println("자바가");
System.out.println("너무");
System.out.println("재미있어요");

// \n : 줄바꿈
System.out.println("자바가\n너무\n재밌어요");

// \t : 탭
// 해물파전 9000원
// 김치전 8000원
// 부추전 8000원
System.out.println("해물파전\t\t9000원");
System.out.println("김치전\t\t8000원");
System.out.println("부추전\t\t8000원");

// \\ : 역슬래시
System.out.println("C:\\Program Files\\Java"); //

// \" : 큰따옴표
// 단비가 "냐옹" 이라고 했어요
System.out.println("단비가 \"냐옹\"이라고 했어요" );

// \' : 작은 따옴표, ' 만 사용도 가능
// 단비가 '뭘 봐?' 라는 표정을 지었어요
System.out.println("단비가 \'뭘 봐?\' 라는 표정을 지었어요");
System.out.println("단비가 '뭘 봐?' 라는 표정을 지었어요");

char c = 'A'; // 케릭터 변수는 ""가 아닌 ''를 사용
c = '\''; // c 에 ' 를 넣고싶을때 사용
System.out.println(c);

참고 영상 : https://www.youtube.com/watch?v=NQq0dOoEPUM

연산하는 방법은 JavaScript와 크게 다르지 않다.

아래의 문제를 통해 한번에 알아 볼 수 있다.

문제 : 키가 120cm 미만의 아이는 놀이기구를 타지 못한다. 아이의 키가 주어졌을때, 아래와 같이 출력해야한다.

정답 예시:

아이의 키가 130cm 인 경우 : "키가 130cm 이므로 탑승 가능합니다."

아이의 키가 110cm 인 경우 : "키가 110cm 이므로 탑승이 불가능합니다."

정답 코드 :

 public static void main(String[] args) {
 
        int height = 121;
        String result = (height >= 120)
                ? "키가 " + height + "cm" + " 이므로 탑승 가능합니다"
                 : "키가 " + height + "cm" + " 이므로 탑승 불가능합니다.";
                 
        System.out.println(result);
    }

삼항연사자와 + 연산을 이용하여 조건에 맞는 결과를 출력할 수 있다.

참고 영상 : https://www.youtube.com/watch?v=NQq0dOoEPUM

JavaScript에서는 var, let, const 를 사용하면 바로 변수를 선언하여 문자열, 숫자, 불린 등 타입과 관계없이 변수를 할당할 수 있었다. 

그러나 이렇게 선언하고 할당하여 사용할 경우 Type 에서 에러가 발생하여 마치 지뢰밭을 만든다는 표현을 많이 들었다.

( 이후 타입스크립트로 보강되었지만 지금은 Java를 학습중이니 해당 내용은 잠시 넣어두자 )

Java에서는 이런 지뢰밭(?)을 만들지 못하게 하였다.

바로 변수 선언과 동시에 타입을 지정하기 때문이다.

아래 종류를 살펴보자

데이터 타입

// 문자열 
String a = "안녕하세요"
char b = "A" // 한글자

// 정수형
int c = 234 // 21억보다 작을경우
long d = 10000000000000L // 21억 보다 클 경우 long 을 사용하고 뒤에 L 또는 l을 추가합니다.

// 실수형
float e = 1.2F // double보다 
double f = 30.24 //

// 불린형
boolean g = false

특이하게 정수와 실수를 구분하고 정밀한 값을 사용할때 실수형에서도 두가지로 나눠 사용한다.

그럼 정수와 실수의 연산에서는 무엇을 사용해야 할까?

그것은 내가 어떤 결과값을 원하는지에 따라 다르다. 

// 정수 결과값을 원할 경우 
int a = 93 + (int)10.5; // 103

// 실수 결과값을 원할 경우
int b = 93 + (double)10.5 // 103.5

이미 선언되어있는 변수를 새로운 변수에 저장하기 위해서는 아래 규칙을 알 필요가 있다.

// 변수에 형변환된 데이터 집어넣기

double convertedScoreDouble = score; // 186 -> 186.0 자동으로 형변환
// int -> long -> float -> double (자동 형변환)

 int convertedScoreInt =(int) score_d; // 191.8 -> 191
// double -> float -> long -> int (수동 형변환)

살짝 응용해서 숫자를 문자열로 문자열을 숫자로 변경하는 방법을 알아보자

// 숫자를 문자열로
String s1 = String.valueOf(93); // 93이란 정수를 문자열로 변경해줍니다.
s1 = Integer.toString(93); // 93이란 정수를 문자열로 변경해줍니다.
System.out.println(s1); // 93

String s2 = String.valueOf(98.8); // 실수를 문자열로 변경해줍니다.
s2 = Double.toString(98.9); // 실수를 문자열로 변경해줍니다.
System.out.println(s2); // 98.8

// 문자열을 숫자로
int i = Integer.parseInt("93");
System.out.println(i); // 93
double d = Double.parseDouble("98.8");
System.out.println(d); // 98.8;

int error = Integer.parseInt("자바"); // 에러발생

참고영상 : https://www.youtube.com/watch?v=NQq0dOoEPUM