[JAVA 다시보기] 자바기초

---

HelloWorld 출력함수

public class Sec0101 {
    /**
     * Hello World 출력함수
     */
    public void exam01(){
        // 출력단축키 sout
        System.out.println("Hello World");
    }

    public void exam02(){
//        예제 1) x, y 정수 변수를 만들어서 덧셈결과를 화면에 출력하세요
        int x = 1;
        int y = 2;
        int result = x + y;
        System.out.println(result);
    }
}

변수

package chap02;

/**
 * packageName : chap02
 * fileName : Sec0201
 * author : GGG
 * date : 2023-09-18
 * description :
 * 요약 :
 *          변수          : 값을 저장할 수 있는 메모리 공간
 *          변수 사용 범위 : {} 안에서만 사용가능
 *                         만약에 {} 안에 {}가 있다면 변수는 안에 {} 도 사용가능함
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-18         GGG          최초 생성
 */
public class Sec0201 {
    public void exam01(){
//        변수 선언
        int value = 20;

//        변수 연산
//        예제 2) 변수 value에 값을 10 더하는 연산을 한 후 화면에 출력하세요
        int result = value + 10;

        System.out.println(result);
    }

    public void exam02(){
//        예제 3) x=3, y=5가 있습니다.
//        x와 y 값을 바꾸어서 출력하세요
//        swap 코딩
        int x = 3;
        int y = 5;
//        swap 코딩
        int temp = x; // x의 값을 임시변수에 넣어둠
        x = y;        // x의 값이 overwrite 됨
        y = temp;     // 임시변수 값을 y에 넣음
//        출력
        System.out.println("x = " + x +" , y = " + y);
    }

    /**
     * 변수의 허용범위 예제
     */
    public void exam04(){
        int v1 = 15;
        if(v1 > 10){
            int v2;
            v2 = v1 - 10;
        }
//        int v3 = v1 + v2 + 5; // v2는 변수 사용불가라서 에러 발생
    }
}

기본자료형

package chap02;

/**
 * packageName : chap02
 * fileName : Sec0202
 * author : GGG
 * date : 2023-09-18
 * description : 기본 자료형(Type)
 * 요약 :
 *         정수 : byte(1), short(2), int(4, ***), long(8, **)
 *         char : 2byte 자료형, 문자 1개를 의미, 홑따옴표('')표시
 *         (저장시 유니코드(숫자)로 저장되고 출력시는 문자로 출력됨)
 *         String(***) : 쌍따옴표("")로 감싼 문자열을 의미
 *         실수 : float(4), double(8, ***)
 *         boolean : 참/거짓 자료형, true/false
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-18         GGG          최초 생성
 */
public class Sec0202 {
    public void exam01(){
//        1bit : 최소 단위, 8bit = 1byte, 1024byte = 1KB
//        1024KB = 1MB, 1024MB = 1GB, 1024GB = 1TB, 1024TB = 1HB
//        2진수 표현 : 0b 를 붙이면 2진수(0, 1로 표현하는 수)
        int var1 = 0b1011; // 2진수(0b 붙이면 2진수)
        int var2 = 0206;   // 8진수(0 붙이면 8진수)
        int var3 = 365;    // 10진수
        int var4 = 0xB3;   // 16진수 (0x를 붙이면 16진수)

        System.out.println("var1 : " + var1);
        System.out.println("var2 : " + var2);
        System.out.println("var3 : " + var3);
        System.out.println("var4 : " + var4);

    }


    public void exam03(){
        long var1 = 10;     // 정수 8byte
        long var2 = 20L;    // L 붙이면 long 자료형

        System.out.println(var1);
        System.out.println(var2);
    }

    public void exam04(){
//        아스키코드
        char c1 = 'A';      // 문자를 직접 저장
        char c2 = 65;       // 십진수로 저장 => 'A'

        System.out.println(c1);
        System.out.println(c2);
    }

    public void exam05(){
        String name = "홍길동";
        String job = "프로그래머";

        System.out.println(name);
        System.out.println(job);

    }

    /**
     * 특수기호 : /n, /t, ", \(이스케이프문자)
     */
    public void exam06(){
        System.out.println("번호\t이름\t직업");                   // 탭 문자
        System.out.print("행 단위 출력\n");                       // 줄바꿈 문자
        System.out.println("우리는 \"개발자\" 입니다.");            // \" 사용
        System.out.println("봄\\여름\\가을\\겨울");                // \\ 사용
    }

    /**
     * 실수 : float(4), double(8, ***)
     */
     
    public void exam07(){
        float var2 = 3.14f;         // float 사용시 끝에 f 붙임
        double var3 = 3.14;         // double

        System.out.println(var2);
        System.out.println(var3);

//        e : 지수 표현식

        double var6 = 3e6;          // 3000000.0
        double var7 = 2e-3;         // 0.002

        System.out.println(var6);
        System.out.println(var7);
    }
}

형변환

package chap02;

/**
 * packageName : chap02
 * fileName : Sec0203
 * author : GGG
 * date : 2023-09-18
 * description : 자료형 변환
 * 요약 :
 *          자동 타입 변환 : 자동으로 자료형이 변환되는 것 : 작은(byte) 자료형 -> 큰 자료형
 *          강제 타입 변환 : 강제로 자료형 변환 : 사용법 : (자료형)변수명, 큰 자료형 -> 작은 자료형
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-18         GGG          최초 생성
 */

/**
 * 자동 형변환 예제
 */
public class Sec0203 {

    public void exam01(){
        byte byteValue = 10;    // 1byte 정수형
//        자동 자료형 변환
        int intValue = byteValue;
        System.out.println("intValue : " + intValue);

//        실수 자동 형변환
        float floatValue = 100.5F;
        double doubleValue = floatValue;
        System.out.println("doubleValue : " + doubleValue);
    }

    /**
     * 강제 형변환 예제
     * 참고) 아스키코드 변환 : char 변수 <- int 값 : 아스키코드 -> 문자로 변환
     *                      int 변수 <- char 값 : 아스키코드 변환 <- 문자
     */
    public void exam02(){
        int intValue = 44032;                // 4byte
//        char charValue = intValue;         // int 4byte, char 2byte 이므로 오류발생 강제형변환 필요
        char charValue = (char)intValue;     // 강제 형변환

//        TODO : char 자료형에 아스키 코드(숫자) 변환 : 아스키코드(숫자) -> 문자로 변환
        char alpha = 65;    // A
//        TODO : 정수형 자료형에 문자 -> 아스키코드로 변환
        int beta = 'A';     // 65


        System.out.println("charValue : " + charValue);

//        double(8) -> int(4) 강제 형변환
        double doubleValue = 3.14;
//        int intValue2 = doubleValue;      // 오류발생
        int intValue2 = (int)doubleValue;

        System.out.println("intValue : " + intValue2);
    }

    /**
     * 문자열 + 숫자 = 문자열
     */
    public void exam06(){
//        결합 연산
        String str1 = 10 + 2 + "8";     // 128
        System.out.println(str1);

        String str2 = 10 + "2" + 8;     // 1028
        System.out.println(str2);

        String str3 = "10" + (2 + 8);   // 1010
        System.out.println(str3);
    }

    /**
     *  문자열 -> int 자료형 변경 : Integer.parseInt("값");
     *  int -> 문자열 변경 :
     */
    public void exam07(){
        // 문자열 -> int 자료형으로 변경
        int value1 = Integer.parseInt("10");            // 문자열 -> 정수
        double value2 = Double.parseDouble("3.14");     // 문자열 -> 실수
        boolean value3 = Boolean.parseBoolean("true");  // 문자열 -> 참/거짓

        System.out.println(value1);
        System.out.println(value2);
        System.out.println(value3);

        // int -> 문자열 자료형으로 변경
        String str1 = String.valueOf(10);           // 정수 -> 문자열로 변경 (속도 빠름)
        String str2 = "" + 10;                         // 빈문자열 + 정수 = 문자열
        String str3 = String.valueOf(3.14);         // 실수 -> 문자열
        String str4 = String.valueOf(true);         // 참/거짓 -> 문자열

        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        System.out.println(str4);
    }
}

입출력함수 및 문자열 비교함수

package chap02;

import java.util.Scanner;

/**
 * packageName : chap02
 * fileName : Sec0204
 * author : GGG
 * date : 2023-09-18
 * description :
 * 요약 :
 *          System.out.println() : 화면에 출력하고 줄바꿈 함수
 *          System.out.print() : 화면에 출력하는 함수
 *          System.out.printf("%d %s %f", 정수변수, 문자열변수, 실수변수)
 *          Scanner : 콘솔 입력을 받기 위한 클래스(객체 정의)
 *                    한라인 입력 받기 함수      : .nextLine();
 *                    공백까지 입력 받기 함수    : .next();
 *                    참고) nextInt(), nextDouble() 등...
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-18         GGG          최초 생성
 */
public class Sec0204 {

    public void exam05(){
//        입력받기 : System.in (키보드 입력)
        Scanner scanner = new Scanner(System.in);
        String inputData;   // 입력 문자열
        while(true){
            inputData = scanner.nextLine();     // 1 라인 입력받기
            System.out.println("입력된 문자열 :" + inputData);
//            TODO: 코드를 완성하세요 (입력된 문자열이 q가 들어오면 반복문 종료하게)
//            TODO: 자바에서 문자열 비교 equal 함수 사용
//                  문자열.equals("문자열2") : 같으면 true, 아니면 false
            if (inputData.equals("q")) {
                break;
            }
        }
        System.out.println("종료");

    }

}

연산자

package chap03;

import java.util.Scanner;

/**
 * packageName : chap03
 * fileName : Sec0301
 * author : GGG
 * date : 2023-09-18
 * description :
 * 요약 :
 *          산술 : +, -, *, /, %(나머지 연산자)
 *          부호 : +, -
 *          문자열 붙이기 : +
 *          대입연산자 : =, +=, -=, *=, /=, %=
 *          증감 : ++, --
 *          비교 : ==, !=, >, <, >=, <=,(1문자 비교, 숫자비교) instanaceof
 *          TODO : 문자열 비교 : 문자열.equals(문자열2)
 *          논리 : !, &, |,(비트연산자) &&(논리곱), ||(논리합)
 *          삼항 : (조건식)? A : B
 *          우선순위 필요하면 () 쓸 것
 *
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-18         GGG          최초 생성
 */
public class Sec0301 {
    public void exam01(){
        int x = -100;
        int result1 = +x;
        int result2 = -x;
        System.out.println("result1 : " + result1);
        System.out.println("result2 : " + result2);

    }

    public void exam03(){
        boolean play = true;
        System.out.println(play);
        play = !play;  // false
        System.out.println(play);
    }

    /**
     * 사칙연산 예제 : /(나눗셈) 조심
     */
    public void exam04(){
        int v1 = 5;
        int v2 = 2;

        int result = v1 + v2;
        System.out.println(result);
        System.out.println("---------------------------------");
        int result2 = v1 / v2;
        System.out.println(result2);    // 정수/정수 => 실수부분이 잘림
        System.out.println("---------------------------------");
        // TODO : 나눗셈 개선 코딩 : 강제 형변환 후 계산해야함
        double result3 = (double)v1 / (double)v2;
//        double result3 = (double)v1 / v2;     // 같은 결과
        System.out.println(result3);
    }

//    연습문제 : 정수 1개를 입력받아 그대로 출력하기
//    입력 : 5
    public void exam05(){
        Scanner sc = new Scanner(System.in);
        System.out.println(sc.next());
    }

//    연습문제2 : 문자 2개 입력받아 순서 바꿔 출력하기
    public void exam06(){
        Scanner sc = new Scanner(System.in);
        String strFirst = sc.next(); // 공백까지 입력받기
        String strSecond = sc.next(); // 공백까지 입력받기
        System.out.println(strSecond + " " + strFirst);
    }


    /**
     * char : 내부적으로 정수로 저장됨(유니코드 : 아스키코드 확장판(한글, 중국어 등을 표시))
     */
    public void exam07(){

        char c1 = 'A' + 1; // char(정수) : 'B' ('A' 아스키코드(65) 65 + 1 = 66)
        char c2 = 'A';
        System.out.println(c1);
        System.out.println(c2);
    }


    // 연습문제3 : char 이용하는 문제
    // 값이 'A' 로 주어져 있습니다. 'A' 대문자 이면 대문자이군요 라고 출력하고, 소문자이면 소문자이군요라고 출력, 숫자이면 숫자이군요 라고 출력

    public void exam08(){
        int charCode = 'A';
        if(charCode >= 65 && charCode <= 90) {
            System.out.println("대문자이군요");
        } else if (charCode >= 97 && charCode <= 122) {
            System.out.println("소문자이군요");

        } else if(charCode>=48 && charCode<=57) {
            System.out.println("숫자이군요");
        } else {
            System.out.println("다른 문자이군요");
        }
    }

    /**
     * 연습문제 : 정수 1개가 주어진다. 2와 3의 배수이면 2 또는 3의 배수이군요
     *          아니면, 2 또는 3의 배수가 아니군요
     */
    public void exam10(){
        int value = 6;

        if((value % 2 == 0) || (value % 3 == 0)){
            System.out.println("2 또는 3의 배수이군요");
        } else {
            System.out.println("2 또는 3의 배수가 아니군요");
        }
    }

}

if문과 switch문

package chap04;

/**
 * packageName : chap04
 * fileName : Sec0401
 * author : GGG
 * date : 2023-09-19
 * description : 조건문
 * 요약 :
 *          if문 - if(조건문1){실행문1} else if(조건문2){실행문2} else{실행문3};
 *          => 조건문1 true 실행문1 실행되고 조건문2 true 실행문2 실행되고 모두 아니면 실행문3 실행
 *          switch문 - switch(변수) { case 값1: 실행문1;break; case 값2: 실행문2;break;
 *                                     default: 실행문3;break;
 *          }
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public class Sec0401 {
    /**
     * 예제 1 : 초기값이 90이상이면 점수가 90보다 큽니다.
     *                          등급은 A입니다. 출력
     *                90이하이면 점수가 90보다 작습니다.
     *                         등급은 B입니다. 출력
     */
    public void exam01(){
        int score = 93;     // 초기값
        if(score >= 90){
            System.out.println("점수가 90보다 큽니다.");
            System.out.println("등급은 A입니다.");
        } else {
            System.out.println("점수가 90보다 작습니다.");
            System.out.println("등급은 B입니다.");
        }
    }

    /**
     * 자바 랜덤 함수 소개하는 예제
     * 랜덤 함수 : Math.random() : 0 ~ 1 사이의 숫자(실수)를 내보내기(retrun)
     * 1 ~ 10 까지의 정수를 뽑기
     * 가공 :
     *      1 <= x < 11 의 정수 뽑기로 변환
     *      1) 0.0 <= Math.random() < 1.0
     *      2) 0.0 * 10 <=  Math.random() * 10 < 1.0 * 10                       // 10 곱하기
     *      3) (int)0.0 * 10 <=  (int)Math.random() * 10 < (int)1.0 * 10        // 강제 형변환 : 실수 -> 정수
     *         => 0 <= (int)Math.random() * 10 < 10
     *      4) 0 + 1 <= (int)Math.random() * 10 + 1 < 10 + 1
     *        => 1 <= (int)Math.random() * 10 + 1 < 11
     */

    public void exam04(){
        // 예제 : 주사위를 던져서 나오는 숫자를 화면에 출력하세요
        // 단, 1 ~ 6 까지의 랜덤하게 나오는 것
        int num = (int)(Math.random() * 6) + 1;      // 1 ~ 10 => 1 ~ 6
//        조건문
        if(num == 1){
            System.out.println("1번");
        } else if(num == 2){
            System.out.println("2번");
        } else if(num == 3){
            System.out.println("3번");
        } else if(num == 4){
            System.out.println("4번");
        } else if(num == 5){
            System.out.println("5번");
        } else {
            System.out.println("6번");
        }
    }

    /**
     * switch 문을 이용해서 코딩하기
     * 예제 : 부장이면 "700만원" 출력, 과장이면 "500만원" 출력
     *       그외 "300만원" 출력
     */

    public void exam08(){
        String position = "과장";

        switch (position){
            case "부장":
                System.out.println("700만원");
                break;
            case "과장":
                System.out.println("500만원");
                break;
            default:
                System.out.println("300만원");
        }
    }
}

반복문 for

package chap04;

/**
 * packageName : chap04
 * fileName : Sec0402
 * author : GGG
 * date : 2023-09-19
 * description : 반복문
 * 요약 :
 *          for문 : for(초기화식; 조건식; 증감식) {반복문;}
 *          => 조건식이 true 일때만 반복문이 실행됨
 *          while문 : 초기화식;
 *                    while(조건식) {
 *                        반복문;
 *                        증감식;
 *                    }
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public class Sec0402 {

    /**
     * 예제1 : 1 ~ 10까지 숫자를 화면에 출력하세요
     */
    public void exam01() {
        // fori : for문 단축키
        for (int i = 1; i < 11; i++) {
            System.out.println(i);
        }
    }

    /**
     * 예제2 : 1 ~ 100 까지의 합
     */

    public void exam02() {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        System.out.println("1~100 까지의 합 : " + sum);
    }

    /**
     * 예제 : 주사위 2 : 주사위를 던져서 나오는 숫자를 계속 화면에 출력하되 6이 나오면 반복문을 중단하고 빠져나오세요
     * 단, 빠져 나올때 프로그램 종료 라고 출력하세요
     */
    public void exam08() {

        while (true) {
            int num = (int) (Math.random() * 6) + 1;
            System.out.println(num);
            if (num == 6) {
                break;
            }
        }
        System.out.println("프로그램 종료");
    }

    /**
     * 예제 : 1 ~ 10 사이의 수 중에서 짝수만 출력하는 코드 : continue
     */
    public void exam09() {
        for (int i = 1; i <= 10; i++) {
            if (i % 2 != 0) continue;
            System.out.println(i);
        }
    }

    /**
     * (참고) 새로나온 사용법 : 반복문의 라벨
     * 활용 : 중첩 for문에서 주로 사용
     */
    public void exam10() {
        Outter:
        for (char upper = 'A'; upper <= 'Z'; upper++) {
            for (char lower = 'a'; lower <= 'z'; lower++) {
                System.out.println(upper + "-" +lower);      // 화면 출력
//                g 가 나오면(안쪽/바깥쪽 모두) 반복문 중단
                if(lower == 'g'){
                    break Outter;       // 이중 중첩 반복문 탈출
                }
            }
        }
        System.out.println("프로그램 종료");
    }
}

참조자료형과 참조변수

package chap05;

/**
 * packageName : chap05
 * fileName : Sec0501
 * author : GGG
 * date : 2023-09-19
 * description : 참조 자료형과 참조 변수
 * 요약 :
 *          기본 자료형 : int(4), long(8), float(4), double, boolean 자료형
 *          => 스택 메모리 영역에 그대로 저장됨
 *          참조 자료형 : String(문자열), 배열, 객체
 *          => 힙 메모리 영역에 값이 저장되고 , 스택 메모리 영역에 주소값이 저장됨
 *          JVM(Java Virtual Machine) : 자바 가상 머신 : jdk(자바가상머신)
 *          역할 : linux / windows(운영체제) 모든 곳에서 실행할 수 있게 만드는 프로그램
 *          비교연산자(==) : 기본자료형에서는 값을 비교하고,
 *                         참조자료형에서는 주소값을 비교하게 됨
 *                         (스택 메모리 영역의 저장된 값을 비교함)
 *          null 포인트 에러(예외) : 프로그램을 강제 비정상 중단함
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public class Sec0501 {
    /**
     * 비교연산자(==) 와 equals 함수 예제
     */
    public void stringEqualExam(){
//        참조 자료형
//        참조자료형 객체변수 = new 생성자함수();
//        메모리에 랜덤한 주소(방번호)값으로 생성됨
        String strVar1 = new String("신민철");
        String strVar2 = new String("신민철");

//        주소값(방번호)비교 : 개발자 입장에서는 의미 없음
        if(strVar1 == strVar2){
            System.out.println("두개의 주소가 같음");
        } else {
            System.out.println("두개의 주소가 다름");
        }
        
//        equals() 함수 사용 : 값을 비교하는 함수
        if(strVar1.equals(strVar2) == true){
            System.out.println("두개의 값이 같음");
        } else {
            System.out.println("두개의 값이 다름");
        }

//        null 포인터 예외(에러)
//        배열에서 null 에러
        int[] intArray = null;  // 없음(공간 없음)
        intArray[0] = 10;   // 0번지 방에 10번을 넣으니 null 에러가 발생

//        객체에서 null 에러
        String str = null;      // 권장코딩 : String str = "";  빈 문자열로 초기화
//        문자열의 길이를 가져오는 함수 : 문자열.length()
        System.out.println("총 문자 수는 : " + str.length());    // null 에러 발생
    }
}

배열

package chap05;

import java.util.Arrays;

/**
 * packageName : chap05
 * fileName : Sec0502
 * author : GGG
 * date : 2023-09-19
 * description : 배열
 * 요약 :
 *       배열 : 같은 자료형의 데이터를 연속된 공간에 나열하고 인덱스를 부여해 놓은 자료구조
 *       인덱스 : 배열 항목에 붙인 번호 , 0 ~ n 까지의 범위
 *       배열 선언(정의) : 자료형[] 변수;
 *       배열 생성 : 1) 자료형[] 변수 = {값1, ..., 값n};
 *                 2) 자료형[] 변수 = new 자료형[길이];
 *                 3) 자료형[] 변수 = new 자료형[길이] {값1, ... , 값n};
 *       배열 길이 : 배열의 값의 개수, 배열변수.lenght (읽기전용)
 *       다차원 배열 : 배열 안에 또 다른 배열이 있음
 *              자료형[][] 변수 = new 자료형[크기][크기];
 *              자료형[][] 변수 = {{값1...},{값1...}};
 *              => for문 코딩 (2개사용)
 *              => int[][] arr = {{1,2,3}, {4,5,6}}
 *              => 팁 ! : for(int i = 1; i<=2; i++){
 *                          for(int j = 1; j <=3; j++){
 *                       }
 *                      }
 *       향상된 for 문 : for(자료형 변수 : 배열) {} => 자동으로 인덱스 증가
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public class Sec0502 {
    /**
     * 예제 : 학생 10명의 성적을 저장하고 평균값 구하기
     */
    public void getStudent(){
//        배열의 초기값
        int[] score = {83, 84, 85, 86, 87, 88, 89, 90, 91, 92};
        int sum = 0;    // 합계 변수
        for (int i = 0; i < score.length ; i++) {
            sum += score[i];        // 배열의 값 모두 더하기(누적합)
        }
//        평균구하기
        double avg = (double)sum / 10; // 평균
        System.out.println("sum = " + sum + " , avg = " + avg);
    }

    /**
     * 예제 2 : 배열에서 함수의 매개변수로 전달시 주의점
     */

    public void arrayFunc(){

        int[] scores = {84, 91, 88};

        int sum2 = add(scores);     // ok 가능
//        이렇게 하면 안됨
//        int sum3 = add({84, 91, 88});   // 에러 발생
//        참고)
        int sum4 = add(new int[]{84, 91, 88});  // 가능

        System.out.println(sum2);
        System.out.println(sum4);
    }


    // 더하기 함수 생성해서 호출해서 쓰기
    public int add(int[] scores) {
        int sum = 0;
        for (int i = 0; i < 3; i++) {
            sum += scores[i];
        }
        return sum;
    }

    /**
     * 배열의 2번째 정의 방법
     */

    public void arrayTwo(){
        int[] arr1 = new int[3];    // 배열의 정의(선언) : 빈방을 만들기(메모리에)
//        정수 : 기본값(0), 문자열 : null, 실수 : 0.0 등
//        배열의 3가지 방에 값넣기
        arr1[0] = 10;
        arr1[1] = 20;
        arr1[2] = 30;
//        배열 출력
        for (int i = 0; i < 3; i++) {
            System.out.println(arr1[i]);    // 배열 값 출력
        }

//        TODO: 배열의 안에 값을 간단히 확인하기
//        참고
//        사용법 : Arrays.toString(배열변수)
        System.out.println(Arrays.toString(arr1));
    }

    /**
     * 얇은 복사(shallow copy) vs 깊은 복사(depp copy)
     */
    public void copyArray(){
//        TODO: 얇은 복사
        int[] oldArray = {1, 2, 3};
        int[] copyArray = oldArray;     // 얇은 복사(주소값)을 복사
        int[] newArray = new int[3];    // 깊은 복사용 변수
//        스택방         |                        힙
//        oldArray      | 100       <------>    100 : {1, 2, 3}
//        copyArray     | 100
//        TODO : 얇은 복사 특징 : oldArray 값을 변경하면 copyArray 값도 같이 변경됨
//             : copyArray 값을 변경해도 원본인 oldArray 도 변경됨

//        위의 현상을 피하고자 깊은 복사를 함
//        TODO : 깊은 복사 : 반복문 이용
        for (int i = 0; i < newArray.length ; i++) {
            newArray[i] = oldArray[i];      // 깊은 복사(원본값 바뀌어도 복사본이 바뀌지 않음)
        }


    }

    /**
     * 향상된 for문 : for(자료형 변수 : 배열) {반복문};
     * 아래 점수 총합을 출력하세요
     */
    public void AdvancedExam(){
        int[] scores = {95, 71, 84};        // 국영수 점수 배열
        int sum = 0;
        for (int s : scores) {
            sum += s;
        }
        double avg = (double)sum / scores.length;
        System.out.println("점수의 총합 : " + sum + ", 점수의 평균 : " + avg);

    }
}

열거형

package chap05;

import java.util.Calendar;

/**
 * packageName : chap05
 * fileName : Sec0503
 * author : GGG
 * date : 2023-09-19
 * description :    열거형 사용
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public class Sec0503 {
    /**
     * 열거형 사용 예제
     */
    public void EnumWeek(){
        Week today = null;
//        달력 객체 : Calendar
        Calendar calendar = Calendar.getInstance(); // 객체 가져오기
        int week = calendar.get(Calendar.DAY_OF_WEEK);  // 현재 요일(1 ~ 7 숫자)
//        조건식
        switch (week){
            case 1:
                today = Week.SUNDAY; break;
            case 2:
                today = Week.MONDAY; break;
            case 3:
                today = Week.TUESDAY; break;
            case 4:
                today = Week.WEDNESDAY; break;
            case 5:
                today = Week.THURSDAY; break;
            case 6:
                today = Week.FRIDAY; break;
            case 7:
                today = Week.SATURDAY; break;
        }
        System.out.println("오늘 요일 :" + today);
    }
}

package chap05;

/**
 * packageName : chap05
 * fileName : Week
 * author : GGG
 * date : 2023-09-19
 * description : 열거형 클래스
 * 요약 :
 *      열거 자료형 : 몇 가지로 제한된 상수를 가지는 자료형
 *      사용법(정의) : enum 변수명 { 상수1, 상수2, ... 상수n }
 *      클래스 내에서 사용
 *          변수명.상수명 ex) Week.MONDAY
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public enum Week {
    //    월,화,수,목,금,토,일 정의(상수)
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

package chap05;

import java.util.Arrays;

/**
 * packageName : chap05
 * fileName : Verify05
 * author : GGG
 * date : 2023-09-19
 * description :   배열 / 열거형 연습문제
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public class Verify05 {
    /**
     * 주어진 배열에서 최대값을 구해보세요
     */
    public void exam04() {
        int[] array = {1, 5, 3, 8, 2};
        int max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (max < array[i]) {
                max = array[i];
            }
        }
        System.out.println(max);
    }

    /**
     * 2) 중첩 for문을 이용해서 주어진 배열의 전체 항목의 합과 평균을 구해보세요.
     */
    public void exam05() {
        int[][] array = { { 95, 86 }, { 83, 92, 96 }, { 78, 83, 93, 87, 88 } };

        int sum = 0;
        int count = 0;

        for(int i = 0; i < array.length; i++){
            for(int j = 0; j < array[i].length; j++){
                sum += array[i][j];
                count += 1;
            }
        }
        double avg = (double) sum / count;



        System.out.println(sum);
        System.out.println(avg);
    }

}