배운 내용 

1. 예외 처리

• 자바에서 예외 처리를 할 때, try 와 catch를 사용한다.
• 먼저 try 블록 안에는 예외 발생 가능성이 있는 코드를 작성한다.
• catch에는 블록안에는 예외 처리를 실행하는 코드를 작성한다.
• 여기서 finally이라는 키워드가 있는데, 이 것은 예외 발생 여부와 상관없이 실행해야 하는 코드를 작성하는 곳이다.

public class TryCatchExample {
    public static void main(String[] args) {

        try {
            // try 블록에는 예외 발생 가능성이 있는 코드를 배치합니다.
        } catch (Exception e) {
            // catch 블록에는 try에서 실제 예외가 발생했을 시
            // 실행할 내용을 작성합니다.
            e.printStackTrace(); // 예외 원인을 알고싶다고 할때 (개발자가 어디가 원인인지 앟고 싶을때)
        } finally {
        	// 예외 처리와 상관없이 출력할 코드
        }
    }
}

• 하나의 try 블록 안의 코드는 다양한 예외가 발생할 수 있다.
• 그렇기 때문에 예외 종류마다 다르게 처리를 하고 싶다면, 다중 catch 문을 작성하여 처리해주면 된다.

public class TryCatchExample2 {
    public static void main(String[] args) {
        int[] arr = new int[5];

        try {
            System.out.println("정수: ");
            int num = sc.nextInt();

            int result = 100 / num;
            System.out.println(arr[result]);

            String s = null;
            s.equals("메롱");


            /*
             - 다중 catch문은 실제로 에러가 발생하면
              위에서부터 순서대로 catch문을 검색하면서 내려오기 때문에
              부모 타입의 예외를 자식 타입의 예외보다 위에 작성하시면 안됩니다.

             - catch 옆에 괄호에 예외 타입을 여러 개 작성하고 싶은 경우는
              | 기호를 사용하여 타입을 나열해 주시면, 하나의 catch 블록으로
              여러 타입의 예외를 동시에 처리할 수 있습니다.
              (java 7버전부터 가능한 문법)
             */

        } catch (InputMismatchException | ArithmeticException e) {
            System.out.println("잘못된 입력값입니다.");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("인덱스 범위를 벗어났어요.");
        } catch (NullPointerException e) {
            System.out.println("주소가 null 입니다!");
        } catch (Exception e) {
            System.out.println("알 수 없는 예외 발생!");
        } finally {
            System.out.println("예외 발생 여부와 상관 없이 항상 실행되는 문장!");
        }
    }
}

• 만약 메서드 또는 생성자를 호출한 곳으로 예외를 떠넘기고 싶으면 throws를 사용한다.
• 그렇게 되면 호출자는 꼭 try/catch를 사용하여 예외 처리를 해주어야 한다.
• throws를 사용하는 이유는 메서드를 호출하는 입장에서 매개값이 잘못될 경우, 예외를 발생시킬 수 있다는 일종의 정보를 제공할 수 있음.
• 메서드마다 일일히 예외 처리를 하는 것 보단, 호출 행위가 많은 곳에서 한번에 예외 처리를 하는 것이 코드의 가독성 및 작성하기에 좋음.

public class ThrowsExample {

    static  String[] greeting = {"안녕", "hello", "니하오"};


            /*
                # throws

                - throws는 예외의 원인이 메서드 선언부가 아닌 호출부에 있을 경우
                 예외 처리를 메서드의 호출부로 떠넘기는 방식입니다.

                - throws는 생성자에서도 선언이 가능하며, 메서드나 생성자를 호출 시
                 예외 처리를 강요하고 싶을 때 사용합니다.

                - 또한, 원하는 영역으로 예외를 모아서 한번에 처리하는 것도 가능합니다.
                */


    static void greet(int idx) throws Exception {
        System.out.println(greeting[idx]);
    }

    public static void main(String[] args) {
        try {
            greet(3);
        } catch (Exception e) {
            System.out.println("메서드의 매개값이 잘못되었어요!");
        }
    }
}

• 물론 main에도 throws를 사용할 수 있다. 하지만 이 것은 예외 처리를 안하겠다는 것과 동일하기 때문에, 예외 케이스가 아닌 이상, 안붙이는게 좋다.

• 예외 처리 뿐만 아니라, 예외 객체를 일부러 생성하여 예외를 발생시킬 수 있다.

public static int calcTotal(int n) {
		int sum = 0;
		for(int i=1; i<=n; i++) {
				sum += i;
		}
		return sum;
}


public static void main(String[] args) {
		int result1 = calcTotal(100);
		int result2 = calcTotal(-120);
}

• 만약 음수를 준다면, 예외가 발생하지 않고 리턴값을 받게된다. 하지만 사용자는 0 또는 0보다 작은 값을 보낸다면 강제로 종료하고 싶다. 그러나 리턴값이 int이기 때문에 return 메서드로는 강제 종료를 할 수 없다. 이 것을 해결하기 위해 예외 처리를 만들어 줘야 한다.

public static int calcTotal(int n) throws Exception {
		if(n <= 0) {
				throw new Exception(); //이 시점에서 강제로 예외를 발생시킴!
		}		

		int sum = 0;
		for(int i=1; i<=n; i++) {
				sum += i;
		}
		return sum;
}

public static void main(String[] args) {
		try {
			int result1 = calcTotal(100);
			int result2 = calcTotal(-120);
		} catch (Exception e) {
			System.out.println("매개값은 반드시 양수로 주셔야 합니다!");
		} 
}

• 개발자가 만든 어플리케이션에서 자체적으로 생길 수 있는 예외는 개발자가 직접 예외 클래스를 정의해서 만들 수 있다.
• 사용자 정의 예의 클래스는 Exception 클래스를 상속하여 제작.
• 이름은 Exception으로 끝나게 지어주면 됨.

public class MyException extends Exception {
		public MyException() {}

		public MyException(String message) {
				super(message);
		}
	...
}

2. 자바 표준 API

import java.util.Objects;

// clone 메서드를 오버라이딩 했다면 Cloneable 인터페이스를 구현해야 합니다.
public class Person implements Cloneable{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // toString(): 객체의 정보(필드)를 문자열 형태로 리턴.
    // Object가 들려주는 toString은 패키지 + 클래스 이름 + 주소값 -> 쓸 일이 잘 없다.
    // 대부분 오버라이딩 해서 사용하는 편.
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    // 같은 객체의 속성을 비교해서 동등 객체인지를 논리값으로 리턴하는 메서드
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true; // 주소값이 같다면 같은 객체애
        if (obj instanceof Person) {
            Person p = (Person) obj;
            if (p.age == this.age && this.name.equals(p.name)); return true;
        }
        return false; // Person 타입을 가질 수 없다면 동등 비교 의미가 없음.
    }


            //equals를 오버라이딩 할 때는 hashCode도 함께 오버라이딩을 진행해 주시는 것이 좋습니다.
            //equals를 재 정의한다는 것은 내가 원하는 방식의 동등 비교를 하겠다는 것이기 때문에
            //hashcode의 값도 그에 맞게 같이 재 정의가 되어야 합니다. (hash 주소를 equals에 맞게 정의)


    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    protected void finalize() throws Throwable {
        // 생성된 객체가 소명될 때 자동으로 호출되는 메서드 (gc가 실행될 때)
        // garbage collector 호출되는 순서를 보장할 수 없기 떄문에 사용을 권장하지 않음.
        super.finalize();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        // 객체 복사 메서드
        return super.clone();
    }
}

public class Main {
    public static void main(String[] args) {
        Person kim = new Person("김춘식", 30);
        Person hong = new Person("김춘식", 30);


        // 객체타입의 변수를 출력하거나 값을 얻을 떄는
        // 뒤에 자동으로 .toString()이 붙어서 진행됩니다. (Object 물려주는 메서드)
        System.out.println(kim);
        System.out.println(hong);

        System.out.println(kim.equals(hong));



// equals에서 동등한 객체라고 판명이 되었다면, 서로 다른 객체더라도
        // 객체의 고유한 주소를 동일하게 처리해서 서로 같은 객체임을 명확히 해야 합니다.
        // 그래야, 자바에서 기본으로 제공하는 클래스 중에 hash를 비교해서 동등 객체인지 아닌지를
        // 판별하는 자료구조(HashSet, HashMap)들이 정상적으로 동작할 수 있습니다.

        System.out.println(kim.hashCode());
        System.out.println(hong.hashCode());

        Person park = new Person("박영희", 100);
        try {
            Person clonePerson = (Person) park.clone();
            System.out.println("복사된 객체 정보: " + clonePerson);
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }
}

• Object 클래스는 자바의 최상위 클래스. 즉, 자바의 모든 클래스는 Object 메서드를 상속받고 있다는 뜻.
• equals(Object obj) : 두 객체가 같은지 비교함. 
• hashcode() : 객체의 해시 주소값을 반환. 
• toString() : 객체를 문자열로 반환하여 반환한다. 기본은 단순 패키지 경로 및 클래스 이름, 16진수의 주소값이 나타남.
• clone() : 객체를 복제하여 반환.
• getClass() : 객체의 클래스를 반환.

package etc.api.lang.system;

public class SystemTime {
    public static void main(String[] args) {

        // 1970년 1월 1일 자정을 기준으로 현재까지 소요된 시간을 밀리초로 리턴 (long)
        long start = System.currentTimeMillis();
        int total = 0;
        for (int i = 0; i < 2000000000; i++) {
            total += i;
        }
        long end = System.currentTimeMillis();

        System.out.println("실행 소요시간: " + (end - start) * 0.001 + "초");
        System.out.println(System.getProperties());



    }
}

• exit() : 현재 실행하고 있는 프로세스를 강제 종료. 정상 종료일 경우 매개값으로 0, 비정상 종료는 0외에 다른 값을 준다.
• currentTimeMillis() / nanoTime() : 1970년 1월 1일 자정을 기준으로 현재까지 흐른 유닉스 시간을 밀리세컨드 또는 나노세컨드 단위의 long값으로 리턴. 주로 프로그램의 실행 소요 시간 측정으로 사용된다.

import java.util.Arrays;

public class StringMethod {
    public static void main(String[] args) {

        String str = "Hello Java";

        // charAt(index): 문자열 인덱스에 따른 단일 문자를 반환.
        char c = str.charAt(4);
        System.out.println("4번 인덱스 = " + c);

        // subString(begin, end): 문자열을 범위를 지정해서 부분 추출.
        String ss1 = str.substring(1, 5); // 1번 이상 5번 미만.
        System.out.println("ss1 = " + ss1);

        String ss2 = str.substring(6); // 6번부터 끝까지 추출.
        System.out.println("ss2 = " + ss2);

        // length(): 문자열의 총 길이 반환.
        int len = str.length();
        System.out.println("len = " + len);

        // indexOf(str): 해당 문자가 있는 인덱스를 반환
        // 해당 문자가 존재하지 않는다면 -1을 리턴.
        int idx1 = str.indexOf("l"); // 앞에서부터 탐색
        System.out.println("idx1 = " + idx1);

        int idx2 = str.lastIndexOf("l"); // 뒤에서부터 탐색
        System.out.println("idx2 = " + idx2);

        // 여러 문자를 전달하면 시작 인덱스를 알려줍니다.
        int idx3 = str.indexOf("Java");
        System.out.println("idx3 = " + idx3);

        String str2 = "HeLLo WoRLd";
        String lower = str2.toLowerCase(); // 일괄 소문자 변경
        System.out.println("lower = " + lower);
        String upper = str2.toUpperCase(); // 일괄 대문자 변경
        System.out.println("upper = " + upper);

        // trim(): 문자열의 앞, 뒤 공백을 제거.
        String name = "                홍길동                   ";
        System.out.println(name.trim() + "님 안녕하세요~!");

        // replace(old, new): 기존 문자열 내부의 old값을 모두 찾아서 new 문자열로 일괄 변경
        String java = "자바는 재밌습니다. 자바 커피는 맛있습니다.";
        System.out.println(java.replace("자바", "java"));
        System.out.println(java.replace("습니", ""));

        // split(구분자): 문자열을 구분자로 구분하여 분할.
        // 분할된 문자들은 String 배열에 담겨서 리턴.
        String phone = "010-1234-5678";
        String[] numbers = phone.split("-");

        System.out.println(Arrays.toString(numbers));

        String pet = "멍멍이, 야옹이, 짹짹이";
        String[] pets = pet.split(", ");
        System.out.println(Arrays.toString(pets));

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

        // 문자열을 정수/실수 변환
        // 순수한 정수 or 실수가 아니라면 예외가 발생합니다.
        String s1 = "100";
        int s1num = Integer.parseInt(s1);
        String s2 = "3.14";
        double s2num = Double.parseDouble(s2);
        System.out.println(s1num + s2num);

        // 기본 타입을 문자열로 변경
        String s3 = String.valueOf(s1num);
        System.out.println("s3 = " + s3);


    }
}

public class StrBuliderExample {
    public static void main(String[] args) {
        String str = "Hello";
        System.out.println(str.hashCode());

        str = "Hello world!";
        System.out.println(str.hashCode());

        str = "hello~";
        System.out.println(str.hashCode());

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

        StringBuilder sb = new StringBuilder("hello");
        System.out.println(sb);
        System.out.println("sb의 주소값 = " + sb.hashCode());

        // 문자얄을 맨 끝에 추가하는 메서드 : append (문자열)
        sb.append(" world");
        System.out.println(sb);
        System.out.println("sb의 주소값 = " + sb.hashCode());

        // 문자열을 특정 인덱스에 삽입하는 메서드: insert(인덱스, 문자열)
        sb.insert(6, "my");
        System.out.println(sb);
        System.out.println("sb의 주소값 = " + sb.hashCode());

        // 특정 인덱스 범위의 문자열을 교체하는 메서드: replace(begin, end, 문자열)
        sb.replace(6, 8, "your");
        System.out.println(sb);
        System.out.println("sb의 주소값 = " + sb.hashCode());

        // 문자열 내의 특정 단어를 삭제하는 메서드 delete(begin, end)
        sb.delete(6, 11);
        System.out.println(sb);
        System.out.println("sb의 주소값 = " + sb.hashCode());

        // 문자열을 역순으로 배치
        sb.reverse();
        System.out.println(sb);
    }
}

• String 클래스는 아주 많이 사용하지만, 메모리를 과소비 한다는 단점이 존재.
• 이를 보완하는 StringBuilder가 등장하게 됨. 
• StringBuilder 객체는 메서드를 통해 문자열의 변화를 얼마든지 주더라도, 객체가 다시 생성되지 않고 기존 객체가 유지되기 때문에 속도 측면에서 String보다 훨씬 빠르다.

- Math 클래스

• abs() : 절대값을 구함.
• ceil() : 올림값을 구함.
• floor() : 내림값을 구함.
• max() : 수를 비교하여 최대값을 구함.
• min() : 수를 비교하여 최소값을 구함.
• random() : 랜덤값을 구함(0.0 <= 값 < 1.0)
• round() : 반올림값을 구함.

public class WrapperExample {

    public static void main(String[] args) {
        int a = 100;
        boolean b = false;
        char c = 'A';
        double d = 3.14;

        // boxing: 기본 데이터 타입을 객체 타입으로 변환
        Integer a2 = Integer.valueOf(a);
        Boolean b2 = Boolean.valueOf(b);
        Character c2 = Character.valueOf(c);
        Double d2 = Double.valueOf(d);

        // autoboxing: 기본 타입을 자동으로 객체형으로 변환
        Integer a1 = a;
        Boolean b1 = b;
        Character c1 = c;
        Double d1 = d;

        // unboxing: 객체 타입으로 포장된 값을 기본 데이터 타입으로 풀어내는 과정.
        int i = a1;
        boolean i1 = b1;
        char i2 = c1;
        double i3 = d1;


    }
}

• 자바의 자료형은 크게 기본형 / 참조형으로 나누어진다.
• 프로그래밍을 하다 보면, 기본형을 객체로 표현해야 하는 경우가 생기는데, 이 때 래퍼 클래스를 사용하면 된다.

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Date;

public class DateExample {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);

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

        LocalDate now = LocalDate.now();
        System.out.println(now);

        LocalTime lt = LocalTime.now();
        System.out.println(lt);

        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);

        LocalDateTime localDateTime = LocalDateTime.of(2022, 7, 1, 9, 0, 0);
        System.out.println("localDateTime = " + localDateTime);

        int year = localDateTime.getYear();
        System.out.println("year = " + year);

        // 문자 형태의 월 리턴 (Month라는 열거형 타입이 리턴)
        Month month = localDateTime.getMonth();
        System.out.println("month = " + month);

        int monthValue = localDateTime.getMonthValue();
        System.out.println("monthValue = " + monthValue);

        int day = localDateTime.getDayOfMonth();
        System.out.println("day = " + day);

        DayOfWeek week = localDateTime.getDayOfWeek();
        System.out.println("week = " + week);

        int dayOfYear = localDateTime.getDayOfYear();
        System.out.println("dayOfYear = " + dayOfYear);

        LocalDateTime d3 = localDateTime.plusDays(3);
        System.out.println("d3 = " + d3);

        LocalDateTime localDateTime1 = localDateTime.plusYears(1).plusMonths(2).plusDays(7);
        System.out.println("localDateTime1 = " + localDateTime1);

        LocalDateTime localDateTime2 = localDateTime.minusMonths(9).minusDays(23);
        System.out.println("localDateTime2 = " + localDateTime2);

        LocalDate start = LocalDate.of(2020, 12, 30);
        LocalDate end = LocalDate.of(2022, 9, 14);

        long between1 = ChronoUnit.DAYS.between(start, end);
        System.out.println("between1 = " + between1);

        long between2 = ChronoUnit.WEEKS.between(start, end);
        System.out.println("between2 = " + between2);

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

        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy년 MM월 dd일 E요일 a hh시 mm분 ss초");

        // 준비한 DateTimeFormatter 객체를 format()의 매개값으로 전달.
        String format = localDateTime.format(pattern);
        System.out.println("format = " + format);


    }
}

3.  SQL - 1(코드 안에 따로 정리)

• 데이터베이스 : 관련된 데이터들을 체계적으로 저장하고 관리할 수 있도록 구성된 데이터의 집합.
• DBMS : 데이터 베이스를 관리하기 위한 소프트웨어 시스템. 이 것은 사용자와 데이터베이스 간의 인터페이스 역할을 하며, 데이터의 저장 / 검색 / 수정 / 삭제 등을 수행.
• SQL : 관계형 데이터베이스 관리 시스템에서 데이터 조작, 정의, 제어하기 위해 사용되는 표준화된 프로그래밍 언어.

1. DDL : 데이터베이스 스키마를 생성, 변경, 삭제하기 위한 명령어
2. DML : 데이터를 검색, 삽입, 수정, 삭제하기 위한 명령어
3. DCL : 데이터베이스 사용자의 권한을 관리하기 위한 명령어
4. TCL : 데이터베이스 트랜잭션을 관리하기 위한 명령어

-- 오라클의 주석입니다.

/*
    여러 줄 주석입니다.
    !!
*/

-- SELECT [컬럼명(여러 개 가능)] FROM [테이블 이름]
SELECT * FROM employees;
SELECT employee_id, first_name, last_name FROM employees;

-- 컬럼을 조회하는 위치에서 산술 연산이 가능합니다.
SELECT 
    employee_id,
    first_name,
    last_name,
    salary,
    salary + salary * 0.1 AS 성과포함급여
FROM employees;

-- alias (컬럼명, 테이블명의 이름을 변경해서 조회합니다.)
SELECT 
    first_name AS 이름,
    last_name AS 성,
    salary AS 급여
FROM employees;

-- NULL값의 확인 (숫자 0이나 공백과는 다른 개념입니다.)
SELECT
    department_id, commission_pct
FROM employees;


/*
오라클은 홑따옴표로 문자를 표현하고, 문자열 안에 홑따옴표 특수기호를
표현하고 싶다면 ''를 두 번 연속으로 쓰시면 됩니다.
문자열 연결기호는 || 입니다. 문자열의 덧셈 연산을 허용하지 않습니다.
*/


SELECT
    first_name || '' || last_name || '''s salary is $' || salary AS full_name
FROM employees;

SELECT DISTINCT -- 중복행 제거
    department_id
FROM employees;

-- WHERE절 비교 (데이터 값은 대/소문자를 구분합니다.)
SELECT 
    first_name, last_name, job_id
FROM employees
WHERE job_id = 'IT_PROG';

SELECT
    *
FROM employees
WHERE last_name = 'king';

SELECT
    *
FROM employees
WHERE department_id = 50;

SELECT
    *
FROM employees
WHERE salary >= 15000 
AND salary < 20000;


SELECT
    *
FROM employees
WHERE hire_date = '04/01/30';

-- 데이터의 행 제한 (BETWEEN, IN, LIKE)
SELECT
    *
FROM employees
WHERE salary BETWEEN 15000 AND 20000;

SELECT
    *
FROM employees
WHERE hire_date BETWEEN '03/01/01' AND '03/12/31';

-- IN 연산자 (특정 값들과 비교할 때 사용)
-- %는 어떠한 문자든, _는 데이터의 자리 (위치)를 표현할 떄.

SELECT
    *
FROM employees
WHERE manager_id IN (101, 102, 103);

SELECT
    *
FROM employees
WHERE job_id IN ('IT_PROG', 'AD_VP');

-- LIKE 연산자 (지정 문자열 포함 여부)
SELECT
    first_name,
    last_name,
    hire_date
FROM employees;
WHERE hire_date LIKE '03%';  -- 03으로 시작되는 것 조회 

SELECT
    first_name,
    last_name,
    hire_date
FROM employees;
WHERE hire_date LIKE '%15'; -- 15로 끝나는 것 조회 

SELECT
    first_name,
    last_name,
    hire_date
FROM employees;
WHERE hire_date LIKE '%05%'; -- 05가 존재하는 모든 값을 조회 


SELECT
    first_name,
    last_name,
    hire_date
FROM employees;
WHERE hire_date LIKE '___05%'; -- 앞에 3글자가 있으면서 05로 시작되는 것 조회


-- IS NULL : null 값을 찾음
SELECT
    *
FROM employees;
WHERE commission_pct IS NULL;

SELECT
    *
FROM employees;
WHERE commission_pct IS NOT NULL;

-- AND, OR
-- AND가 OR보다 연산 속도가 빠름.
SELECT
    *
FROM employees
WHERE job_id = 'IT_PROG'
OR job_id = 'FI_MGR'
AND salary >= 6000;

SELECT
    *
FROM employees
WHERE (job_id = 'IT_PROG'
OR job_id = 'FI_MGR')
AND salary >= 6000;

-- 데이터의 정렬 (SELECT 구문의 가장 마지막에 배치됩니다.)
-- ASC : 오름차 (ascending)
-- DESC : 내림차 (descending)
SELECT
    *
FROM employees
ORDER BY hire_date;

SELECT
    *
FROM employees
WHERE job_id = 'IT_PROG'
ORDER BY hire_date DESC;

SELECT
    first_name,
    salary * 12 AS pay
FROM employees
ORDER BY pay DESC;

-- lower(소문자), initcap(앞글자만 대문자), upper(대문자)

/*
dual이라는 테이블은 sys가 소유하는 오라클의 표준 테이블로서,
오직 한 행에 한 컬럼만 담고 있는 dummy 테이블 입니다.
일시적인 산술 연산이나 날짜 연산 등에 주로 사용합니다.
모든 사용자가 접근할 수 있습니다.
*/

SELECT
    'abcdef',
    LOWER('abcDEF'),
    INITCAP('abcDEF'),
    UPPER('abcDEF')
FROM dual;

SELECT
    last_name,
    LOWER(last_name),
    INITCAP(last_name),
    UPPER(last_name)
FROM employees;

SELECT
    salary
FROM employees
WHERE LOWER(last_name) = 'austin';

-- length(길이), instr(문자 찾기, 없으면 0을 반환, 있으면 인덱스 값) 
SELECT
    'abcdef', LENGTH('abcdef'), INSTR('abcdef', 'b')
FROM dual;

SELECT
    first_name,
    LENGTH(first_name),
    INSTR(first_name, 'a')
FROM employees;

-- SUBSTR(자를 문자열, 시작 인덱스, 길이)
-- CONCAT(문자 연결)

SELECT
    first_name,
    SUBSTR(first_name, 1, 3),
    CONCAT(first_name, last_name)
FROM employees;


-- LTRIM(), RTRIM()
-- TRIM() -> 양쪽 공백 제거
-- LTRIM(param1, param2) -> param2의 값을 param1에서 찾아서 제거 (왼쪽부터)
-- RTRIM(param1, param2) -> param2의 값을 param1에서 찾아서 제거 (오른쪽부터)
SELECT
    LTRIM('javascript_java', 'java'),
    RTRIM('javascript_java', 'java')
FROM dual;

-- LPAD(), RPAD(): 좌, 우측을 지정한 문자열로 채우기
SELECT
    LPAD('abc', 10, '*'),
    RPAD('abc', 10, '#')
FROM dual;

-- REPLACE(str, old, new) 
SELECT
    REPLACE('my dream is a president', 'president', 'programmer')
FROM dual;

SELECT
    REPLACE(REPLACE('my dream is a president', 'president', 'programmer'), ' ', '')
FROM dual;

-- 숫자함수
-- ROUND(반올림)
-- 원하는 반올림 위치를 매개값으로 지정. 음수를 주는 것도 가능.
SELECT
    ROUND(3.1415, 3), ROUND(45.923, 0), ROUND(45.923, -1)
FROM dual;

-- TRUNC(절사)
-- 정해진 소수점 자리수까지 잘라냅니다.
SELECT
    TRUNC(3.1415, 3), TRUNC(45.923, 0), TRUNC(45.923, -1)
FROM dual;

-- ABS (절대값)
SELECT ABS(-34) FROM dual;

-- CEIL(올림), FLOOR(내림)
SELECT CEIL(3.14), FLOOR(3.14)
FROM dual;

-- MOD(나머지 나눗셈 연산)
SELECT
    10 / 4, MOD(10, 4)
FROM dual;


-------------------------------------------------------------

-- 날짜 함수
-- sysdate: 컴퓨터의 현재 날짜, 시간 정보를 가져와서 제공하는 키워드 함수 -> 시간 있음!
SELECT sysdate FROM dual;
SELECT systimestamp FROM dual; -- 더 세밀한 시간과 표준시 정보까지 제공.

-- 날짜 연산
SELECT sysdate + 1 FROM dual; -- 일자 덧셈 연산이 가능.


-- 날짜 타입과 날짜 타입은 서로 뺄셈 연산이 가능합니다.
-- 덧셈은 허용하지 않습니다.
SELECT
    first_name,
    sysdate - hire_date
FROM employees; -- 일자

SELECT
    first_name,
    (sysdate - hire_date) / 365
FROM employees; -- 년수


-- 날짜 반올림, 절사
SELECT ROUND(sysdate) FROM dual;
SELECT ROUND(sysdate, 'year') FROM dual; -- 년 기준 반올림
SELECT ROUND(sysdate, 'month') FROM dual; -- 월 기준 반올림
SELECT ROUND(sysdate, 'day') FROM dual; -- 주 기준 반올림 (해당 주의 일요일 날짜)

SELECT TRUNC(sysdate) FROM dual;
SELECT TRUNC(sysdate, 'year') FROM dual; -- 년 기준 반올림
SELECT TRUNC(sysdate, 'month') FROM dual; -- 월 기준 반올림
SELECT TRUNC(sysdate, 'day') FROM dual; -- 주 기준 반올림 (해당 주의 일요일 날짜)

-- 형변환 함수 TO_CHAR, TO_NUMBER, TO_DATE

-- 날짜를 문자로 TO_CHAR(값, 형식)
-- 날짜를 문자로 형 변환할 때 원하는 형식으로 날짜를 표현할 수 있습니다.
-- 날짜 포맷형식: Y - 연도, MM - 두자리 월, D - 일수 DY - 요일
-- 시간 포맷형식: HH12 - 시(1~12), HH24 (0-23), MI - 분, SS - 초

SELECT TO_CHAR(sysdate) FROM dual;
SELECT TO_CHAR(sysdate, 'YYYY-MM-DD DY PM HH:MI:SS') FROM dual;


-- 서식 문자와 함께 사용하고 싶은 일반 문자는 ""로 감싸서 전달.
SELECT 
    TO_CHAR(sysdate, 'YY"년" MM"월" DD"일"') 
FROM dual;


-- 숫자를 문자로 TO_CHAR(값, 형식)
-- 형식에서 사용하는 '9'는 실제 숫자 9가 아니라 자리수를 표현하기 위한 기호입니다.
SELECT TO_CHAR(20000, '99,999') FROM dual;
SELECT TO_CHAR(20000, 'L99,999') FROM dual;
SELECT TO_CHAR(20000.29, '99,999.9') FROM dual; -- 반올림 지원

SELECT
    first_name,
    TO_CHAR(salary, '$99,999') AS salary
FROM employees;

-- 문자를 숫자로 변환 TO_NUMBER(값, 형식)
SELECT '2000' + 2000 FROM dual; -- 자동 변환
SELECT '$3,300' + 2000 FROM dual; -- 에러
-- 변환하려는 문자가 깔끔한 숫자 형태가 아니라면, 서식문자를 이용해서 알려주세요.
SELECT TO_NUMBER('$3,300', '$9,999') + 2000 FROM dual;


-- 문자를 날짜로 TO_DATE(값, 형식)
SELECT TO_DATE('2023-04-13') + 1 FROM dual;

-- 주어진 문자열을 모두 변환해야 합니다. 일부만 변환할 수 없습니다.
SELECT TO_DATE('2023-04-13 12:23:50', 'YY-MM-DD HH:MI:SS') FROM dual;

SELECT TO_DATE('2023년 04월 13일', 'YYYY"년" MM"월" DD"일"') FROM dual;


--------------------------------------------------------------------------------

-- NULL 형태를 변환하는 함수 NVL(컬럼 혹은 값, 변환할 타겟값)
SELECT
    first_name,
    NVL(commission_pct, 0) AS comm_pct
FROM employees;

-- NULL 형태를 변환하는 함수 NVL2(타겟, null이 아닌 경우, null 경우)
-- 연산 중간에 NULL이 있으면 전체 결과가 NULL이 됩니다!
SELECT
    first_name,
    salary,
    NVL2(
        commission_pct,
        salary + (salary * commission_pct),
        salary
    ) AS 급여
FROM employees;

-- COALESCE(expr1, ...)
-- 전달된 표현식 중 NULL이 아닌 값이 최초로 발견되면 그 값을 리턴

SELECT
    COALESCE(3000, NULL, NULL, 4000)
FROM dual;

-- comm_pct가 null인 애들은 0을 적용, null이 아닌 애들은 자신의 comm_pct를 적용
SELECT
    first_name,
    salary,
    salary + (salary * COALESCE(commission_pct, 0)) AS 급여
FROM employees;


-- DECODE(컬럼 혹은 표현식, 항목1, 결과1, 항목2, 결과2 ... default)
-- 오라클 전용 함수. 동등 비교만 가능.
SELECT
    first_name,
    job_id,
    salary,
    DECODE(
        job_id,
        'IT_PROG', salary * 1.1,
        'FI_MGR', salary * 1.2,
        'AD_VP', salary * 1.3,
        0
    ) AS result
FROM employees;

-- CASE문 WHEN THEN END
-- ANSI 표준 구문
SELECT
    first_name,
    job_id,
    salary,
    (CASE job_id
        WHEN 'IT_PROG' THEN salary*1.1
        WHEN 'FI_MGR' THEN salary*1.2
        WHEN 'AD_VP' THEN salary*1.3
        ELSE 0
    END) AS result
FROM employees;

-- 집합 연산자
-- 서로 다른 쿼리 결과의 행들을 하나로 결합, 비교, 차이를 구할 수 있게 해 주는 연산자
-- UNION(합집합 중복x), UNION ALL(합집합 중복 o), INTERSECT(교집합), MINUS(차집합)
-- 위 아래 column 개수와 데이터 타입이 정확히 일치해야 합니다.

-- UNION -> 중복 데이터를 허용하지 않음. 자동으로 정렬이 일어남 (첫 번째 컬럼 오름차가 default) 
SELECT 
    employee_id, first_name
FROM employees
WHERE hire_date LIKE '04%'
UNION
SELECT 
    employee_id, first_name
FROM employees
WHERE department_id = 20;

-- UNION ALL -> 중복을 허용 
SELECT 
    employee_id, first_name
FROM employees
WHERE hire_date LIKE '04%'
UNION ALL
SELECT 
    employee_id, first_name
FROM employees
WHERE department_id = 20;




SELECT 
    employee_id, first_name
FROM employees
WHERE hire_date LIKE '04%'
INTERSECT
SELECT 
    employee_id, first_name
FROM employees
WHERE department_id = 20;




SELECT 
    employee_id, first_name
FROM employees
WHERE hire_date LIKE '04%'
MINUS
SELECT 
    employee_id, first_name
FROM employees
WHERE department_id = 20;



SELECT 
    employee_id, first_name
FROM employees
WHERE department_id = 20
MINUS
SELECT 
    employee_id, first_name
FROM employees
WHERE hire_date LIKE '04%';

-- 집계함수 AVG, MAX, MIN, SUM, COUNT
-- 여러 행을 묶어서 한 번에 함수를 적용
-- 그룹화를 따로 하지 않으면 그룹은 테이블 전체가 됩니다.
SELECT
    AVG(salary),
    MAX(salary),
    MIN(salary),
    SUM(salary),
    COUNT(salary)
FROM employees;

SELECT COUNT(*) FROM employees; -- 총 행의 데이터 수
SELECT COUNT(first_name) FROM employees;
SELECT COUNT(commission_pct) FROM employees; -- null이 아닌 행의 수  
SELECT COUNT(manager_id) FROM employees; -- null은 카운팅되지 않습니다.


-- 부서별로 그룹화, 집계함수 사용  
SELECT
    department_id,
    AVG(salary),
    COUNT(*)
FROM employees
GROUP BY department_id;

-- 그룹 함수는 단독적으로 사용할 때는 테이블 전체가 그룹의 대상이 되지만 
-- 일반 컬럼과 동시에 출력할 수 없습니다. 일반 컬럼을 그룹화 해야 합니다. 
SELECT
    department_id,
    AVG(salary),
    COUNT(*)
FROM employees; -- 에러  

-- GROUP BY절을 사용할 때, GROUP절에 묶이지 않은 컬럼은 조회할 수 없습니다.
SELECT
    job_id,
    department_id,
    AVG(salary),
    COUNT(*)
FROM employees
GROUP BY department_id;

-- GROUP BY절 2개 이상 사용
SELECT
    job_id,
    department_id,
    AVG(salary),
    COUNT(*)
FROM employees
GROUP BY department_id, job_id;

-- GROUP BY를 통해 그룹화 할 때, 조건을 지정할 경우 HAVING을 사용.
-- WHERE은 일반 조건절. GROUP BY보다 먼저 진행됩니다.
SELECT
    department_id,
    SUM(salary),
    AVG(salary)
FROM employees
GROUP BY department_id
HAVING SUM(salary) > 100000;

-- 부서 아이디가 50 이상인 인원만 그룹화 시키고, 그룹 급여 평균이
-- 5000 이상만 조회 

SELECT
    department_id,
    AVG(salary) AS 평균급여
FROM employees
WHERE department_id >= 50
GROUP BY department_id
HAVING AVG(salary) >= 5000
ORDER BY 평균급여 DESC;

/*
# 조인이란?

- 서로 다른 테이블 간에 설정된 관계가 결합하여
 1개 이상의 테이블에서 데이터를 조회하기 위해서 사용합니다.
 
- SELECT 컬럼리스트 FROM 조인대상이 되는 테이블 (1개 이상)
  WHERE 조인 조건 (오라클 조인 문법)
*/



-- employees 테이블의 부서 id와 일치하는 departments 테이블의 부서 id를 찾아
-- 부서 이름을 조회하자.
SELECT
    e.first_name,
    e.department_id,
    d.department_name
FROM employees e, departments d
WHERE e.department_id = d.department_id;

/*
각각의 테이블에 독립적으로 존재하는 컬럼의 경우에는
테이블 이름을 생략해도 무방합니다. 그러나, 해석의 명확성을 위해
테이블 이름을 작성하셔서 소속을 표현해 주는 것이 바람직합니다.
테이블 이름이 너무 길 시에는 ALIAS를 작성하여 칭합니다.
두 테이블 모두 가지고 있는 컬럼의 경우 반드시 명시해 주셔야 합니다.
*/

-- 3개의 테이블을 이용한 내부 조인 (INNER JOIN)
-- 내부 조인: 조인 조건에 일치하는 행만 반환하는 조인
-- 조인 조건에 일치하지 않는 데이터는 조회 대상에서 제외
SELECT
    e.first_name,
    e.department_id,
    d.department_name,
    j.job_title
FROM employees e, departments d, jobs j
WHERE e.department_id = d.department_id
AND e.job_id = j.job_id;


-- 4개의 테이블 조인
SELECT
    e.first_name,
    e.department_id,
    d.department_name,
    j.job_title,
    loc.city
FROM employees e, departments d, jobs j, locations loc
WHERE e.department_id = d.department_id
AND e.job_id = j.job_id
AND d.location_id = loc.location_id
AND loc.state_province = 'California'; -- 일반 조건은 조인 조건 이후에 작성.


-- 외부 조인 (OUTER JOIN)
/*
상호 테이블간에 일치되는 값으로 연결되는 내부 조인과는 다르게
어느 한 테이블에 공통 값이 없더라도 해당 row들이 조회 결과에
모두 포함되는 조인을 말합니다.
*/
SELECT
    e.first_name,
    d.department_name
FROM employees e, departments d
WHERE e.department_id = d.department_id(+);


-- 외부 조인 진행 시 모든 조건에 (+)를 붙여야 하며
-- 일반 조건에도 (+)를 붙이지 않으면 데이터가 누락되는 현상이 발생.
SELECT
    e.employee_id, e.first_name, e.department_id,
    jh.start_date, jh.end_date, jh.job_id
FROM employees e, job_history jh
WHERE e.employee_id = jh.employee_id(+)
AND jh.department_id(+) = 80;

-- 이너(내부) 조인
SELECT
    e.first_name,
    e.department_id,
    d.department_name
FROM employees e 
JOIN departments d -- JOIN이라고만 써도 INNER JOIN
ON e.department_id = d.department_id
WHERE e.department_id = 50;

-- 아우터(외부) 조인
SELECT
    e.first_name,
    d.department_name
FROM employees e 
LEFT JOIN departments d
ON e.department_id = d.department_id;

-- 풀 아우터 조인(좌측 테이블과 우측 테이블 데이터를 모두 읽어 표현하는 외부 조인) 
-- LEFT + RIGHT JOIN
SELECT
    e.first_name,
    d.department_name
FROM employees e 
FULL JOIN departments d
ON e.department_id = d.department_id;

-- CROSS JOIN은 JOIN 조건을 설정하지 않기 때문에
-- 단순히 모든 컬럼에 대한 JOIN을 수행합니다.
-- 실제로는 거의 사용하지 않습니다.
-- (실행 결과 행의 수: 각 테이블의 행을 곱해주면 됨.) 
SELECT
    *
FROM employees
CROSS JOIN departments;

SELECT * FROM employees, departments;

-- 여러 개 테이블 조인 -> 조인 조건에 사용할 키 값을 찾아
-- 연결해서 쓰면 됩니다.

SELECT
    *
FROM employees e
LEFT JOIN departments d
ON e.department_id = d.department_id
LEFT JOIN locations loc
ON d.location_id = loc.location_id;

-- SELF JOIN이란 동일 테이블 사이의 조인을 말합니다.
-- 동일 테이블 컬럼을 통해 기존의 존재하는 값을 매칭시켜 가져올 때 사용합니다.

-- 각 사원별 매니저의 이름을 조회
SELECT
    e1.employee_id, e1.first_name, e1.manager_id,
    e2.first_name, e2.employee_id
FROM employees e1
LEFT JOIN employees e2
ON e1.manager_id = e2.employee_id;

-- 각 매니저가 당담하는 사원의 명수
-- 매니저 아이디, 매니저 이름, 사원수
SELECT 
    m.employee_id AS manager_id,
    m.first_name AS manager_name,
    COUNT(m.employee_id) AS 사원수 
FROM employees e
JOIN employees m
ON e.manager_id = m.employee_id
GROUP BY m.employee_id, m.first_name;


-- Natural Join
-- 동일한 이름을 갖는 컬럼들에 대해 자동으로 조인조건을 생성하는 기법입니다.
-- 즉, 자동으로 2개 이상의 테이블에서 같은 이름을 가진 컬럼을 찾아 INNER JOIN을 수행합니다.
-- 조인되는 동일 이름의 컬럼은 타입이 같아야 하며,
-- ALIAS나 테이블명을 자동 조인 컬럼 앞에 표기하면 안됩니다.
-- 조회하려는 컬럼에 *을 붙이면, 공통 컬럼은 한 번만 표기됩니다.

SELECT
    e.employee_id, e.first_name,
    department_id, d.department_name    
FROM employees e
NATURAL JOIN departments d;


-- USING JOIN
-- NATURAL JOIN과는 다르게, USING을 사용하면 원하는 컬럼에 대해서만 선택적 조인조건을
-- 부여할 수 있습니다.
-- USING절에서도 조인 컬럼에 대해 ALIAS나 테이블명을 표기하시면 안됩니다.

SELECT
    e.employee_id, e.first_name,
    department_id, d.department_name    
FROM employees e
JOIN departments d USING(department_id);

/*
# 서브쿼리 
: SQL 문장 안에 또다른 SQL을 포함하는 방식.
 여러 개의 질의를 동시에 처리할 수 있습니다.
 WHERE, SELECT, FROM 절에 작성이 가능합니다.

- 서브쿼리의 사용방법은 () 안에 명시함.
 서브쿼리절의 리턴행이 1줄 이하여야 합니다.
- 서브쿼리 절에는 비교할 대상이 하나 반드시 들어가야 합니다.
- 해석할 때는 서브쿼리절 부터 먼저 해석하면 됩니다.
*/

-- 이름이 'Nancy'인 사원보다 급여가 높은 사원을 조회하기

SELECT salary FROM employees
WHERE first_name = 'Nancy';

SELECT first_name FROM employees
WHERE salary > 12008;

-- 서브쿼리를 활용한 문장   
SELECT first_name FROM employees
WHERE salary > (SELECT salary FROM employees
                WHERE first_name = 'Nancy');
                
-- employee_id가 103번인 사람의 job_id랑 동일한 job_id를 가진 사람을 조회.  
SELECT * FROM employees
WHERE job_id = (SELECT job_id FROM employees
                WHERE employee_id = 103);
                
                


-- 다음 문장은 서브쿼리가 리턴하는 행이 여러 개라서 단일 행 연산자를 사용할 수 없습니다.
-- 단일 행 연산자: 주로 비교 연산자 (=, >, <, >=, <=, <>)를 사용하는 경우 하나의 행만 반환해야 합니다.
-- 이런 경우에는 다중 행 연산자를 사용해야 합니다.
SELECT * FROM employees
WHERE job_id = (SELECT job_id FROM employees
                WHERE last_name = 'King'); -- 에러  
                
                
-- 다중 행 연산자 (IN, ANY, ALL, EXIST)

-- IN: 조회된 목록의 어떤 값과 같은지를 비교.
-- ex) salary IN (200, 300, 400)
-- 250 -> false
SELECT * FROM employees
WHERE job_id IN (SELECT job_id FROM employees
                WHERE last_name = 'King');
                
-- first_name이 David인 사람들의 급여와 같은 급여를 받는 사람들을 조회.
SELECT 
    *
FROM employees
WHERE salary IN (SELECT salary FROM employees
                WHERE first_name = 'David');
                

-- ANY, SOME : 값을 서브쿼리에 의해 리턴된 각각의 값과 비교해서
-- 하나라도 만족하면 조회 대상에 포함됩니다.
-- ex) salary > ANY (200, 300, 400)
-- 250 -> true

SELECT 
    *
FROM employees
WHERE salary > ANY (SELECT salary FROM employees
                    WHERE first_name = 'David');




-- ALL: 값을 서브쿼리에 의해 리턴된 각각의 값과 비교해서
-- 전부 다 일치해야 조회대상에 포함됩니다.
-- ex) salary > ALL (200, 300, 400)
-- 250 -> false, 200 보다는 크지만 300, 400보다는 크지 않기 때문에 
SELECT 
    *
FROM employees
WHERE salary > ALL (SELECT salary FROM employees
                    WHERE first_name = 'David');
                    

-- job_history에 존재하는 직원이 employees에도 존재한다면 조회 대상에 포함.
-- 서브쿼리 내에서 jh에 있는 id와 e에 있는 id가 일치할 때마다 1이라는 값을 조회.
-- EXISTS 연산자가 1이 조회가 될때 데이터가 존재한다는 것을 판단하여
-- employees에서 해당 사원의 모든 컬럼을 조회.
                    
-- EXISTS : 서브쿼리가 하나 이상의 행을 반환하면 참으로 간주.  
SELECT * FROM employees e
WHERE EXISTS (SELECT 1 FROM job_history jh
              WHERE e.employee_id = jh.employee_id);
              
              
              
-------------------------------------------------------------------------


-- SELECT 절에 서브쿼리 붙이기.
-- 스칼라 서브쿼리 라고도 칭합니다.
-- 스칼라 서브쿼리 : 실행 결과가 단일 값을 반환하는 서브쿼리.

SELECT
    e.first_name,
    d.department_name
FROM employees e
LEFT JOIN departments d
ON e.department_id = d.department_id
ORDER BY e.first_name;


SELECT
    e.first_name,
    (
        SELECT
            d.department_name
        FROM departments d
        WHERE d.department_id = e.department_id
    ) AS department_name
FROM employees e
ORDER BY e.first_name;

/*
# 스칼라 서브쿼리 vs LEFT JOIN
a. 간단한 상황에서 사용하면 쿼리가 직관적이고 간결합니다.
b. 단일 값을 반환하는 서브쿼리에서 유용.
c. 대량 데이터가 아닌 경우나, 서브쿼리의 복잡도가 낮은 경우 적합.

1. 대량 데이터를 처리하거나, 여러 컬럼을 붙여야 할 때 유리합니다.
2. 여러 테이블을 한 번에 조인해야 할 경우.
3. 다중값 처리 및 중복 데이터가 있는 경우 성능상 좀 더 유리.
*/

-- 각 부서 별 사원수 뽑기 (부서명, 사원수)

SELECT
    d.department_name,
    COUNT(e.employee_id) AS 사원
FROM departments d
LEFT JOIN employees e
ON d.department_id = e.department_id
GROUP BY d.department_name
ORDER BY 사원 DESC;

SELECT
    d.department_name,
    NVL ((
        SELECT
            COUNT(*)
        FROM employees e
        WHERE e.department_id = d.department_id
        GROUP BY department_id
    ), 0) AS 사원
FROM departments d
ORDER BY 사원 DESC;

------------------------------------------------------------------------


-- FROM절 서브쿼리 (인라인 뷰)
-- 특정 테이블 전체가 아닌 SELECT를 통해 일부 데이터를 조회한 것을 가상 테이블로 사용하고 싶을 때.
-- 순번을 정해놓은 조회 자료를 범위를 지정해서 가지고 오는 경우.


/*
가장 안쪽 SELECT 절에서 필요한 테이블 형식(인라인 뷰)을 생성.
바깥쪽 SELECT 절에서 ROWNUM을 붙여서 다시 조회
가장 바깥쪽 SELECT 절에서는 이미 붙어있는 ROWNUM의 범위를 지정해서 조회.

** SQL의 실행 순서
FROM(JOIN) -> WHERE -> GROUP BY -> HAVING -> SELECT -> ORDER BY
*/

SELECT
    *
FROM
    (SELECT
        ROWNUM AS rn, tbl.*
    FROM
        (SELECT 
            employee_id,first_name, salary
        FROM employees
        ORDER BY salary DESC) 
    tbl)
WHERE rn > 30 AND rn <= 40;


SELECT
    first_name, salary,
    tbl.avg_salary
FROM employees e
JOIN (SELECT
    department_id,
    TRUNC(AVG(salary), 0) AS avg_salary
FROM employees
GROUP BY department_id
) tbl
ON e.department_id = tbl.department_id;

-- 부서별 최고 급여를 받는 직원을 조회해주세요.
-- 사원 이름, 급여, 부서 이름 

SELECT
    e.first_name,
    e.salary,
    d.department_name
FROM employees e
JOIN (
SELECT
    department_id,
    MAX (salary) AS max_salary
FROM employees
GROUP BY department_id
) max_sal
ON e.department_id = max_sal.department_id
AND e.salary = max_sal.max_salary
JOIN departments d
ON e.department_id = d.department_id;


SELECT
    e.first_name,
    e.salary,
    d.department_name
FROM employees e
JOIN departments d
ON e.department_id = d.department_id
WHERE e.salary = (
    SELECT
        MAX(salary)
    FROM employees
    WHERE department_id = e.department_id
)
ORDER BY e.salary;

-- INSERT
-- 테이블 구조 확인
DESC departments;

-- INSERT의 첫번째 방법 (모든 컬럼 데이터를 한 번에 지정해서 삽입)

-- 에러 -> 컬럼을 지정하지 않고 값만 주는 경우에는 모든 값을 다줘야 한다.
INSERT INTO departments
VALUES(301, '영업부');

SELECT * FROM departments;

-- INSERT의 두번째 방법 (직접 컬럼을 지정해서 저장, NOT NULL 컬럼 확인!)
INSERT INTO departments
    (department_id, manager_id)
VALUES
    (302, 101); -- 에러
    
ROLLBACK; -- 실행 시점을 다시 뒤로 되돌리는 키워드.

-- 사본 테이블 생성
-- 사본 테이블을 생성할 때 그냥 생성하면 -> 조회된 데이터까지 모두 복사
-- WHERE절에 false(1=2)를 주면 -> 테이블의 구조만 복사되고 데이터는 복사 x
-- 제약조건은 복사되지 않습니다.
CREATE TABLE emps2 AS
(SELECT employee_id, first_name, job_id, hire_date
FROM employees WHERE 1 = 2);

SELECT * FROM emps;
DROP TABLE emps2;

-- INSERT (서브쿼리)
INSERT INTO emps
(SELECT employee_id, first_name, job_id, hire_date
FROM employees WHERE department_id = 50);

-------------------------------------------------------------

-- UPDATE
-- UPDATE 테이블이름 SET 컬럼=값, 컬럼=값 ..... WHERE 누구를 수정할지(조건)
UPDATE emps
SET first_name = '춘식이'; -- 조건 지정 안하면 대상이 테이블 전체가 됨!
ROLLBACK;

UPDATE emps
SET first_name = '춘식이'
WHERE employee_id = 100;


UPDATE emps
SET 
    first_name = '야옹이', 
    job_id = '백수', 
    hire_date = sysdate
WHERE employee_id = 100;

SELECT * FROM emps;

-- UPDATE 서브쿼리
UPDATE emps
SET (job_id, hire_date) =
    (
    SELECT
        job_id, hire_date
    FROM emps
    WHERE employee_id = 100
    )
WHERE employee_id = 101;

-----------------------------------------------------------

-- DELETE
-- DELETE도 WHERE 지정하지 않으면 테이블 전체 행이 대상이 됩니다.
DELETE FROM emps
WHERE employee_id = 101;


-- DELETE (서브쿼리)
DELETE FROM emps
WHERE department_id = (SELECT department_id FROM departments
                        WHERE department_name = 'IT');

-- 오토 커밋 활성화 여부 확인
SHOW AUTOCOMMIT;
-- 오토 커밋 켜기   
SET AUTOCOMMIT ON;
-- 끄기  
SET AUTOCOMMIT OFF;

SELECT * FROM emps;

INSERT INTO emps
VALUES(300, '춘식', 'IT_PROG', sysdate);

DELETE FROM emps WHERE employee_id = 300;

INSERT INTO emps
VALUES(301, '메롱이', '영업부', sysdate);

-- 보류중인 모든 데이터 변경사항을 취소 (폐기)
-- 직전 커밋 단계로 회귀(돌아가기) 및 트랜젝션 종료.  
ROLLBACK;

-- 세이브 포인트 생성
-- 롤백할 포인트를 직접 이름을 붙여서 지정.
-- ANSI 표준 문법은 아니기 때문에 그렇게 권장하지는 않음.  
SAVEPOINT insert_choon;

ROLLBACK TO SAVEPOINT insert_choon;

-- 보류중인 모든 데이터 변경 사항을 영구적으로 적용하면서 트랜젝션 종료.
-- 커밋 후에는 어떠한 방법을 사용하더라도 되돌릴 수 없습니다.    
COMMIT;

/*
- NUMBER(2) -> 정수를 2자리까지 저장할 수 있는 숫자형 타입.
- NUMBER(5, 2) -> 정수부, 실수부를 합친 총 자리수 5자리, 소수점 2자리
- NUMBER -> 괄호를 생략할 시 (38, 0)으로 자동 지정됩니다.
- VARCHAR2(byte) -> 괄호 안에 들어올 문자열의 최대 길이를 지정. (4000byte까지)
- CLOB -> 대용량 텍스트 데이터 타입 (최대 4Gbyte)
- BLOB -> 이진형 대용량 객체 (이미지, 파일 저장 시 사용)
- DATE -> BC 4712년 1월 1일 ~ AD 9999년 12월 31일까지 지정 가능
- 시, 분, 초 지원 가능.
*/



CREATE TABLE dept (
    dept_no NUMBER(2),
    dept_name VARCHAR2(14),
    loca VARCHAR2(15),
    dept_date DATE,
    dept_bouns NUMBER(10)
);

DESC dept;
SELECT * FROM dept;

-- NUMBER와 VARCHAR2의 타입, 길이를 확인.  
INSERT INTO dept 
VALUES (20, '마케팅', '경기', sysdate, 3000000.86);

-- 컬럼 추가
ALTER TABLE dept 
ADD dept_count NUMBER(3);

-- 컬럼명 수정
ALTER TABLE dept
RENAME COLUMN dept_count TO emp_count;

-- 컬럼 속성 변경
-- 만약 변경하고자 하는 컬럼에 데이터가 이미 존재한다면, 그에 맞는 타입으로 
-- 변경해야 합니다. 맞지 않는 타입으로는 변경이 불가합니다. 
ALTER TABLE dept
MODIFY dept_no NUMBER(4);

-- DDL(CREATE, ALTER, TRUNCATE, DROP)은 트랜젝션 대상이 아닙니다.
-- DML(INSERT, UPDATE, DELETE) 이후 DDL을 실행하면 COMMIT이 자동으로 들어감.  
ROLLBACK;

-- 컬럼 삭제
ALTER TABLE dept
DROP COLUMN dept_bouns;

-- 테이블 이름 변경
ALTER TABLE dept
RENAME TO dept2;

SELECT * FROM dept2;

-- 테이블 삭제 (구조는 남겨두고 내부 테이터만 모두 삭제)
TRUNCATE TABLE dept2;

-- 테이블 삭제  
DROP TABLE dept2;

-- 테이블 생성과 제약조건
-- : 테이블에 부적절한 데이터가 입력되는 것을 방지하기 위해 규칙을 설정하는 것.

-- 테이블 열레벨 제약조건 (PRIMARY KEY, UNIQUE, NOT NULL, FOREIGN KEY, CHECK)
-- PRIMARY KEY: 테이블의 고유 식별 컬럼입니다. (주요 키)
-- UNIQUE: 유일한 값을 갖게 하는 컬럼 (중복값 방지)
-- NOT NULL: null을 허용하지 않음. (필수값)
-- FOREIGN KEY: 참조하는 테이블의 PRIMARY KEY를 저장하는 컬럼
-- CHECK: 정의된 형식만 저장되도록 허용.


-- 컬럼 레벨 제약 조건 (컬럼 선언마다 제약조건 지정)
-- 제약 조건 식별자는 생략이 가능합니다. (오라클에서 알아서 이름 지움)
CREATE TABLE dept (
    dept_no NUMBER(2) CONSTRAINT dept_deptno_pk PRIMARY KEY,
    dept_name VARCHAR2(14) NOT NULL CONSTRAINT dept_deptname_uk UNIQUE,
    loca NUMBER(4, 0) CONSTRAINT dept_loca_locid_fk REFERENCES locations(location_id),
    dept_bonus NUMBER(10) CONSTRAINT dept_bonus_ck CHECK(dept_bonus > 100000),
    man_gender VARCHAR2(1) CONSTRAINT dept_gneder_ck CHECK(man_gender IN ('M', 'F'))
);

DROP TABLE dept;


-- 테이블 레벨 제약조건 (모든 열 선언 후 제약조건을 한번에 취하는 방식)
CREATE TABLE dept (
    dept_no NUMBER(2),
    dept_name VARCHAR2(14) NOT NULL,
    loca NUMBER(4),
    dept_bonus NUMBER(10),
    dept_gender VARCHAR2(1),
    
    CONSTRAINT dept2_deptno_pk PRIMARY KEY(dept_no), 
    CONSTRAINT dept2_deptname_uk UNIQUE(dept_name),
    CONSTRAINT dept2_loca_locid_fk FOREIGN KEY(loca) REFERENCES locations(location_id),
    CONSTRAINT dept2_bonus_ck CHECK(dept_bonus > 100000),
    CONSTRAINT dept2_gender_ck CHECK(dept_gender IN('M', 'F'))
);



-- 외래 키 (foreign key)는 부모 테이블(참조 테이블)에 없는 값을 INSERT할 수 없음!
INSERT INTO dept
VALUES (20, 'bb', 2000, 1000000, 'F');

UPDATE dept
SET loca = 4000
WHERE dept_no = 10; -- 실패 (FK 제약조건 위반)  


UPDATE dept
SET dept_no = 20
WHERE dept_no = 10; -- 실패 (PK 위반)

UPDATE dept
SET dept_bonus = 4000
WHERE dept_no = 10; -- 실패 (CHECK 위반)

SELECT * FROM dept;

-- 타 테이블에서 나의 PK를 참조하는 경우에는 삭제가 맘대로 안됩니다.
DELETE FROM locations
WHERE location_id = 1800;


-- 테이블 생성 이후 제약조건 추가 및 변경, 삭제
-- 제약조건은 추가, 삭제만 가능합니다. 변경은 안됩니다.
-- 변경하려면 삭제하고 새로운 내용으로 추가하면 됩니다.

CREATE TABLE dept2 (
    dept_no NUMBER(2),
    dept_name VARCHAR2(14) NOT NULL,
    loca NUMBER(4),
    dept_bonus NUMBER(10),
    dept_gender VARCHAR2(1)
);

-- PK 추가
ALTER TABLE dept2
ADD CONSTRAINT dept2_deptno_pk PRIMARY KEY(dept_no);

-- UNIQUE 추가
ALTER TABLE dept2
ADD CONSTRAINT dept2_deptname_uk UNIQUE(dept_name);

-- FK 추가
ALTER TABLE dept2
ADD CONSTRAINT dept2_loca_locid_fk 
FOREIGN KEY(loca) REFERENCES locations(location_id);

-- CHECK 추가
ALTER TABLE dept2
ADD CONSTRAINT dept2_bonus_ck CHECK(dept_bonus > 10000);

ALTER TABLE dept2
ADD CONSTRAINT dept2_gender_ck CHECK(dept_gender IN('M', 'F'));

-- NOT NULL은 열 수정 형태로 변경합니다.
ALTER TABLE dept2
MODIFY dept_bonus NUMBER(10) NOT NULL;

-- 제약 조건 확인
SELECT * FROM user_constraints
WHERE TABLE_name = 'DEPT';

-- 제약 조건 삭제 (제약 조건 이름으로 -> 이름을 직접 짓지 않았다면 오라클 부여한다.   
ALTER TABLE dept DROP CONSTRAINT dept2_bonus_ck;

/*
view는 제한적인 자료만 보기 위해 사용하는 가상 테이블의 개념입니다.
뷰는 기본 테이블로 유도된 가상 테이블이기 때문에
필요한 컬럼만 저장해 두면 관리가 용이해 집니다.
뷰는 가상테이블로 실제 데이터가 물리적으로 저장된 형태는 아닙니다.
뷰를 통해서 데이터에 접근하면 원본 데이터는 안전하게 보호될 수 있습니다.
*/

SELECT * FROM user_sys_privs;

-- 단순 뷰 : 하나뷰의 테이블을 이용해서 생성한 뷰  
-- 뷰의 컬럼명은 함수 호출문, 연산식 등 가상 표현식이면 안됩니다! 
SELECT
    employee_id,
    first_name || ' ' || last_name,
    job_id,
    salary
FROM employees
WHERE department_id = 60;

CREATE VIEW view_emp AS (
    SELECT
    employee_id,
    first_name || ' ' || last_name AS full_name,
    job_id,
    salary
    FROM employees
    WHERE department_id = 60
);

SELECT * FROM view_emp;

-- 복합 뷰 : 두 개 이상의 테이블을 조인해서 필요한 데이터를 생성한 뷰
-- 복잡한 쿼리를 반복사용하지 않고 빠른 조회를 위해 사용. (생산성 증가)

CREATE VIEW view_emp_dept_job AS (
    SELECT
        e.employee_id,
        e.first_name || ' ' || last_name AS full_name,
        d.department_name,
        j.job_title
    FROM employees e
    LEFT JOIN departments d
    ON e.department_id = d.department_id
    LEFT JOIN jobs j
    ON e.job_id = j.job_id
)
ORDER BY e.employee_id;

SELECT * FROM view_emp_dept_job;

-- 뷰의 수정 (CREATE OR REPLACE)  
-- 동일 이름으로 해당 구문으로 사용하면 데이터가 변경되면서 새롭게 생성되고,
-- 기존에 존재하지 않았다면 새로 CREATE 됩니다.  
CREATE OR REPLACE VIEW view_emp_dept_job AS (
    SELECT
        e.employee_id,
        e.first_name || ' ' || last_name AS full_name,
        d.department_name,
        j.job_title,
        e.salary
    FROM employees e
    LEFT JOIN departments d
    ON e.department_id = d.department_id
    LEFT JOIN jobs j
    ON e.job_id = j.job_id
)
ORDER BY e.employee_id;

SELECT
    job_title,
    AVG(salary) AS avg
FROM view_emp_dept_job
GROUP BY job_title
ORDER BY avg DESC; -- SQL문이 간결해짐.  

-- 뷰 삭제
DROP VIEW view_emp;


/*
VIEW에 INSERT가 일어나는 경우 실제 테이블에도 반영이 됩니다.
그래서 VIEW의 INSERT, UPDATE, DELETE에는 많은 제약 사항이 따릅니다.
원본 테이블이 NOT NULL인 경우 VIEW에 INSERT가 불가능합니다.
VIEW에서 사용하는 컬럼이 가상열인 경우에도 안됩니다.
*/

SELECT * FROM view_emp_dept_job;

-- 가상열이 존재하기 때문에 INSERT 안됨!
INSERT INTO view_emp_dept_job 
VALUES(300, 'test', 'test', 'test', 10000);

-- JOIN된 뷰( 복합 뷰)의 경우에는 한번에 삽입할 수 없습니다.
INSERT INTO view_emp_dept_job 
(employee_id, department_name, job_title, salary)
VALUES(300, 'test', 'test', 'test', 10000);

-- 원본 테이블 컬럼 중 NOT NULL 컬럼이 존재하고, 그 칼럼을 
-- view에서 지목할 수 없다면 INSERT가 불가능합니다.
INSERT INTO view_emp
    (employee_id, job_id, salary)
VALUES(300, 'test', 10000);

DELETE FROM view_emp_dept_job
WHERE employee_id = 107;

ROLLBACK;

-- WITH CHECK OPTION -> 조건 제약 컬럼
-- 뷰를 생성할 때 사용한 조건 컬럼은 뷰를 통해서 변경할 수 없게 해주는 키워드  
CREATE OR REPLACE VIEW view_emp_test AS (
    SELECT
        employee_id,
        first_name,
        last_name,
        email,
        hire_date,
        job_id,
        department_id
    FROM employees
    WHERE department_id = 60
)
WITH CHECK OPTION CONSTRAINT view_emp_test_ck;

SELECT * FROM view_emp_test;

UPDATE view_emp_test
SET department_id = 100
WHERE employee_id = 107;


-- 읽기 전용 뷰 -> SELECT만 허용, DML 연산을 막음
CREATE OR REPLACE VIEW view_emp_test AS (
    SELECT
        employee_id,
        first_name,
        last_name,
        email,
        hire_date,
        job_id,
        department_id
    FROM employees
    WHERE department_id = 60
)
WITH READ ONLY;

-- 시퀀스 (순차적으로 증가, 감소하는 값을 만들어 주는 객체)

CREATE SEQUENCE test_seq
    START WITH 1 -- 시작값 (기본값 증가할 땐 최소값, 감소할 때 최대값)
    INCREMENT BY 1 -- 증감값 (기본값 1, 양수는 증가, 음수는 감소)
    MAXVALUE 10 -- 최대값 (기본값 1027, 감소일 때는 -1)
    MINVALUE 1 -- 최소값 (기본값 증가일 때 1, 감소일 때 -1028)
    NOCACHE -- 캐시 메모리 사용 여부 
    NOCYCLE; -- 순환 여부 (기본 값 NOCYCLE)
    
CREATE TABLE test_tbl (
    test_id NUMBER(2) PRIMARY KEY,
    test_msg VARCHAR2(100)
);

INSERT INTO test_tbl
VALUES(test_seq.NEXTVAL, 'test'); -- INSERT 실행 시 시퀀스의 다음 값 활용. 

SELECT * FROM test_tbl;

SELECT 
    test_seq.CURRVAL
FROM dual;

-- 시퀀스 속성 수정
-- START WITH은 수정이 불가능합니다.
ALTER SEQUENCE test_seq MAXVALUE 9999;
ALTER SEQUENCE test_seq INCREMENT BY -5;

DROP SEQUENCE test_seq;

-- 사용자 계정 확인
SELECT * FROM all_users;

-- 계정 생성 명령
CREATE USER user1 IDENTIFIED BY user1;


/*
DCL: GRANT(권한 부여), REVOKE(권한 회수)

CREATE USER -> 데이터베이스 유저 생성 권한
CREATE SESSION -> 데이터베이스 접속 권한
CREATE TABLE -> 테이블 생성 권한
CREATE VIEW -> 뷰 생성 권한
CREATE SEQUENCE -> 시퀀스 생성 권한
ALTER ANY TABLE -> 어떠한 테이블도 수정할 수 있는 권한
INSERT ANY TABLE -> 어떠한 테이블에도 데이터를 삽입하는 권한.
SELECT ANY TABLE...

SELECT ON [테이블 이름] TO [유저 이름] -> 특정 테이블만 조회할 수 있는 권한.
INSERT ON....
UPDATE ON....

- 관리자에 준하는 권한을 부여하는 구문.
RESOURCE, CONNECT, DBA TO [유저 이름]
*/

GRANT CREATE SESSION TO user1;
GRANT SELECT ON hr.departments TO user1;
GRANT RESOURCE, CONNECT, DBA TO user1;
-- REVOKE FROM -> 권한 회수  
REVOKE RESOURCE, CONNECT, DBA FROM user1;

-- ROLE: 특정 권한의 모음. 일괄적으로 권한을 부여하거나 회수하기 위해 사용.

CREATE ROLE new_emp_role;

GRANT SELECT, UPDATE ON hr.employees TO new_emp_role; 

GRANT new_emp_role TO user1;

-- 계층형 쿼리 
-- START WITH : 계층의 첫 단계를 어디서 시작할 것인지의 대한 조건
-- CONNECT BY PRIOR 자식 = 부모  -> 순방향 탐색
-- CONNECT BY 자식 = PRIOR 부모  -> 역방향 탐색
-- ORDER SIBLINGS BY : 같은 레벨끼리의 정렬을 정함.

SELECT
    employee_id,
    first_name,
    manager_id
FROM employees;

SELECT
    employee_id,
    first_name,
    manager_id,
    LEVEL, -- 계층 깊이를 나타내는 키워드 
    SYS_CONNECT_BY_PATH(first_name, '/') AS 계층구조 
FROM employees
START WITH manager_id IS NULL -- 계층 구조를 최상위 관리자부터 시작한다.
CONNECT BY PRIOR employee_id = manager_id -- 한 직원의 manager_id가 상위 직원의 employee_id와 일치하는 경우 부모 - 자식 관계를 형성하겠다.
AND LEVEL <= 2 -- 특정 깊이까지만 정보를 확인할 수 있음. 
ORDER SIBLINGS BY first_name;

SELECT
    LEVEL,
    LPAD(' ', 2*(LEVEL-1)) || first_name AS 조직인원,
    employee_id,
    manager_id
FROM employees
START WITH employee_id = 107
CONNECT BY employee_id = PRIOR manager_id;

SELECT * FROM employees;

-- 103번 직원의 모든 부하직원 찾기  
SELECT
    LEVEL,
    LPAD(' ', 2*(LEVEL-1)) || first_name AS 조직인원,
    salary
FROM employees
START WITH employee_id = 103
CONNECT BY PRIOR employee_id = manager_id;

-- ROLLUP(arg1, arg2) -> arg1과 arg2로 그룹화. -> 각 그룹별 SUM(salary)
-- -> arg1 그룹의 SUM(salary) -> 마지막에는 전체 SUM(salary)
-- 특정 컬럼들의 단계적 합계를 계산.
-- 부서별 급여 합계
-- 부서와 직무 조합별 급여 합계
-- 전체 급여 합계


SELECT
    department_id,
    job_id,
    SUM(salary) AS total_salary
FROM employees
GROUP BY ROLLUP (department_id, job_id)
ORDER BY department_id;


-- CUBE(arg1, arg2): 모든 가능한 조합을 고려하여 집계.
-- 직무별 급여 합계
-- 부서별 급여 합계
-- 부서와 직무 조합별 급여 합계
-- 전체 급여 합계

SELECT
    department_id,
    job_id,
    SUM(salary) AS total_salary
FROM employees
GROUP BY CUBE (department_id, job_id)
ORDER BY department_id;


-- GROUPING SETS(arg1, arg2): 주어진 그룹 집합에 대해서만 집계
-- 직무별 급여 합계
-- 부서별 급여 합계

SELECT
    department_id,
    job_id,
    SUM(salary) AS total_salary
FROM employees
GROUP BY GROUPING SETS (department_id, job_id)
ORDER BY department_id;

-- GROUPING(): 이 함수가 직접 그룹 집계를 하지는 않음.
-- 결과에서 특정 열이 집계가 되었는지의 여부를 확인하여 값을 임의로 집어 넣을때 사용.
-- ROLLUP, CUBE, GROUPING SETS에서 모두 사용 가능.

SELECT
    CASE GROUPING(department_id) WHEN 1 THEN 0 ELSE department_id END AS dept_id,
    CASE GROUPING(job_id) WHEN 1 THEN 'job_total' ELSE job_id END AS job_id,
    SUM(salary) AS total_salary
FROM employees
GROUP BY CUBE (department_id, job_id);

회고 

1. 전반적인 느낀점 

• SQL은 처음 접해서 처음엔 많이 어려움이 있었지만, 강사님의 도움과 조금씩 복습 덕분에 어느정도 이해 할 수가 있었다.
• 하지만 아직 서브 쿼리 등의 이해가 가지 않는 몇몇 문법을 집중적으로 복습할 필요성을 느꼈다.

2. 좋았던 점

• 데이터 베이스를 조회, 삽입, 삭제, 변경들을 익히고, 직접 테이블을 만들어 커스텀을 할 수 있는 능력을 키울 수 있어서 좋았다.

3. 아쉬웠던 점

• 아직 몇몇 문법들을 이해하지 못했던 점, 알고리즘 문제를 풀 때 위의 자바를 이용해서 풀면 더 쉬웠을 텐데 이용하지 못했던 것이 많이 아쉬웠다.

4. 개선할 점

• 항상 느끼는 점이지만, 수업을 진행하고나면 부족하거나 이해가 가지 않는 것을 채워야 할 것 같다.
• 알고리즘 문제 수를 조금 더 늘려야 겠다는 생각을 하게 됨.

5. 다음주 계획

• 알고리즘 문제 풀기
• 이번에 배운 SQL 복습

1. 배웠던 것

1. 표준 입/출력

자바의 표준 출력은 크게 3가지로 나누어진다.

1. 줄 개행을 포함하지 않는 print();
2. 자동으로 줄 개행 기능을 포함하는 println();
3. 형식 지정 표준 출력 함수 printf();

System.out.print("개행없이 출력해볼까요");
System.out.println(" 개행 기능 포함 출력");
System.out.print("안녕하세요");
System.out.println(" 안녕히 가세요");

/*
개행없이 출력해볼까요 개행 기능 포함 출력
안녕하세요 안녕히 가세요
*/

• 코드를 보면 print()의 경우, 내용을 출력한 후 다음 출력을 위한 커서가 그 자리에 머물게 되어, 다음 문장이 가로로 이어서 붙어서 줄력
• 이와 반대로 println()은 내용 출력한 후, 다음 출력을 위한 커서가 한 줄 아래에 머물게 됨.

• printf()는 서식 문자를 활용하여 먼저 문자열을 완성시키고, 서식 문자에 들어갈 값을 지정해서 출력하는 방식이다.
• printf()는 print()와 마찬가지로 줄 개행 기능이 없어, "\n"과 같이 따로 줄 개행 명령을 내려줘야한다.

/*
		 # 포맷팅 서식 문자 종류
		 %d: 부호가 있는 정수 데이터 (decimal)
		 %f: 실수 데이터 (floation point)
		 %s: 문자열 (String)
		 
		 # 탈출 문자 (escape sequence) -> printf에만 동작하는 게 아니에요.
		 - 반드시 따옴표 내에 위치해야 합니다
		 - 문자열 내에서 특정 명령을 내리고 싶을 때 사용하는 특수 기호입니다.
		 \n: 줄 개행 명령
		 \t: 가로 공백 (스페이스 4칸)
		 \\: 백슬래시 문자를 나타낼 때 사용.
     \': 홑 따옴표를 문자로 출력할 때 사용
     \": 쌍 따옴표를 문자로 출력할 때 사용
		 */
		
		int month = 12;
		int day = 25;
		String anni = "크리스마스";
		
		//12월 25일은 크리스마스 입니다.
		System.out.println(month + "월 " + day + "일은 " + anni + " 입니다.");
		System.out.printf("%d월 %d일은 %s입니다.\n", month, day, anni);

		//실수를 표현하는 서식문자 %f -> 기본 6자리까지 표현.
		//%.[자리수를 지정하는 숫자]f -> 원하는 자리수까지 표현.
		//%라는 문자 자체를 표현할 때는 %% 쓰시면 됩니다.
		double rate = 64.126;
		System.out.printf("합격률은 %.2f%%입니다.", rate);

1 - 1. 표준 입력

• Scanner라는 이름을 가진 객체를 기본적으로 제공해서 입력을 받을 수 있게함.
• Scanner 객체 생성 방법

import java.util.Scanner; // 1. Scanner 클래스의 정보를 import
Scanner sc = new Scanner(System.in); // 2. Scanner 객체를 생성한다.

/*
new Scanner(System.in);
-> 새로운 스캐너 객체를 생성한다. 괄호 안에는 자바의 표준 입력 명령을 전달한다.
그리고 나서 sc라는 변수에 스캐너 객체를 담는다. 그렇다면 sc의 타입은
스캐너를 담고 있으니 타입이 Scanner 겠구나~ 
정도로 해석하면 충분하다.
변수명은 in, input, sc, scan 뭐든 좋다. 이 네 개를 주로 많이 쓴다.
*/

/*
		 3. Scanner의 함수들을 이용하여 데이터를 입력받을 수 있습니다.
		 - next(): 공백이 없는 문자열을 입력 받습니다.
		 - nextLine(): 공백을 포함한 문자를 입력 받습니다.
		 - next + 기본타입이름(): 해당 타입에 맞는 데이터를 입력 받습니다.
		 ex)
		 	nextInt(): 정수 데이터를 입력 받습니다.
		 	nextDouble(): 실수 데이터를 입력 받습니다.
			nextBoolean(): 논리형 데이터를 입력 받습니다.
			nextLong(): 정수(long) 데이터를 입력 받습니다. 

			**char 데이터를 받는 메서드는 따로 없습니다. 한 글자여도 문자열로 받으세요.
*/
		
// 3. Scanner가 제공하는 메서드를 이용해서 입력값을 받기
System.out.print("이름: "); //무엇을 입력할 지 간단한 출력문을 쓰자.
String name = sc.next(); //입력받은 문자열을 next()가 받아서 name에 할당해 준다.
		
System.out.print("나이를 입력하세요: ");
int age = sc.nextInt(); //입력받은 정수를 nextInt()가 받아서 age에 할당해 준다.
		
System.out.println("제 이름은 " + name + "이고, 나이는 " + age + "세 입니다.");
System.out.printf("제 이름은 %s이고, 나이는 %d세 입니다.", name, age);

sc.close(); // Scanner 객체를 반납

• 여기서 헷갈릴 수 있는 next(), nextLine()의 차이점

-  우선 2개 다 String을 받는다는 공통점이 있지만, next()는 공백을 기준으로 공백 전 까지의 문장만을 읽어 들인다.

반대로 nextLine()은 한 줄에 입력된 여러 문장을 공백까지 포함해서 읽을 수 있다.

2. 조건문

- 특정 조건에 따라 별도의 명령을 수행하도록 제어하는 명령문.

2 - 1. if / else if / else

• if 옆에 작성된 괄호 안에 논리형 조건식을 작성, 그리고 그 조건식이 true면 if  안에 있는 코드 블럭을 실행.
• else if의 경우에는 if 뒤에 따라붙어야 하는 조건문으로, 앞의 if 문이 실행되지 않는 조건에서 else if문의 조건이 참이면 else if 안에 있는 코드 블럭을 실행한다.
• else문은 앞에 있는 모든 조건이 false일 때 실행되는 블록. 즉, else if / if문 모두 실행되지 않았을 때 실행.

// if문의 형태
if (조건식) {
    // 괄호 안의 조건이 true일 때, 실행 할 코드
} else if (조건식2) {
    // 위의 if문의 조건식이 false이고, 조건식2가 true일 때 실행 할 코드
} else {
    // 위의 조건식, 조건식2 모두 false일 때 실행할 코드
}

• 만약 첫 번째 조건이 참이고, 이것을 더 세부적으로 조건을 나누고 싶다면 if문 안에 또 다른 if문을 넣을 수 있다. (중첩 if문)

if (조건식1) {
    if (조건식2) {
        // 조건식1과 조건식2가 모두 참일 때 실행할 코드
    }
} else {
    // 조건식1이 거짓일 때 실행할 코드
}

2 - 2. switch, case 문

• switch문은 기준이 되는 변수나 식의 결과에 따라서 여러 개의 case문 중 하나를 선택하여 실행하는 제어문이다.

switch (변수 또는 수식) {
	case 첫번째 값:
        // 첫번째 값이 맞을 경우, 출력되는 코드 
        break;
    case 두번째 값:
        // 두번째 값이 맞을 경우, 출력되는 코드
        break;
    case 세번째 값:
    case 네번째 값:
        // 세번쨰, 네번째 값이 맞을 경우, 출력되는 코드
        break; // switch문을 빠져나가게 해주는 역할, 작성하지 않을 경우 코드가 이어서 진행하게됨.
    default: // 일치하는 case문이 없으면 실행되는 곳 (안써도 무방하다.)
        // 모든 case문이 해당되지 않을 때, 출력되는 코드
        break;
}

• switch문 내부의 변수 또는 수식은 반드시 정수/문자/문자열 타입만 가능. 
• case문 뒤에는 반드시 콜론(:)을 붙인다.

3. 반복문

특정한 조건이나 횟수에 따라서 코드 블럭을 반복적으로 실행시키고 싶을 때 사용하는 문법
여러 곳에 자주쓰이는 형태 중 하나이다.
보통 while / for 키워드를 사용한다.

3 - 1. while 문

// while문의 기본적인 형태

while (조건식) {
	// 실행될 코드
}

• 이 때, 조건식이 true인 동안 반복문이 계속해서 실행된다. (false가 되면 종료)
• 그러므로 무한 반복문을 만들 목적이 아니라면, 따로 변수를 선언하여 반복문의 횟수를 조절해야한다.

// while문 예시

int cnt = 1; // 제어 변수 : 반복문의 횟수를 제어할 변수. (begin)
int total = 0; 

while(cnt <= 5) { // 논리형 조건식 : 반복문의 끝을 지정. (end)
    total += cnt;
    cnt++; // 증감식 : 반복문의 종료를 위해 제어 변수의 값을 조정 (step)
}

System.out.println(total); // 15

• while문을 실행시키기 위한 필수 3요소인 begin, end, step이 있음.
• 만약 이 3요소 중 하나라도 누락될 경우에는 반복문이 이상하게 돌아갈 수 있음.
• while문의 진행 순서.

1. 제어 변수를 선언함. (시작값이 정해짐)
2. while문의 조건식을 검사하여 true면 반복문이 시작. false라면 반복문 종료.
3. while문 블록 내부가 한번 진행되면 다시 조건식을 검사하여 true라면 반복문 계속 진행. false라면 종료.
4. 반복문 내에 증감식을 넣어 제어 변수 값을 조정.

3 - 2. for문

// for문
for (초기화; 조건식; 증감식) {
	// 실행될 코드
}

• for문의 경우, 초기화/ 조건식/ 증감식/ 코드로 구성되어 있음. 즉, while의 3요소가 괄호 안에 한번에 지정되는 것.

// for문의 간단 예제

int total = 0;

for (int i = 0; i <= 10; i++) {
	total += i;
}

System.out.println(total); // 55

• 그럼 어떤 상황에서 while 또는 for을 써야할까?

- 시작과 끝 범위가 확실한 반복의 경우에는 for문을 더 많이 사용.

- 횟수보다는 조건에 따라 반복을 진행할 때는 while을 더 많이 사용.

3 - 3. 반복문 중첩

• 반복문 안에 다른 반복문이 들어간 구조.
• 말 그대로 반복문 자체를 반복해야 하는 경우에 사용하는 구조.

// 반복문 중첩 예시

for(int dan=2; dan<=9; dan++) {
	System.out.println("구구단 " + dan + "단");
	System.out.println("---------------");
	for(int hang=1; hang<=9; hang++) {
		System.out.printf("%d x %d = %d\n"
				, dan, hang, dan*hang);
	}
	
	System.out.println("---------------");	
}

• 반복문 중첩의 진행 순서

1. 바깥쪽 반복문을 우선 실행한다.
2. 안쪽 반복문을 실행한다.
3. 안쪽 반복문이 모두 실행이 되었다면, 다시 바깥쪽 반복문으로 돌아가서 반복을 진행한다.
4. 바깥쪽 반복문이 false가 될 때까지 반복한다.

• 반복문 중첩에서는 조건식 / 증감식 등을 세밀하게 조정해야 한다. 보통 바깥쪽 반복문의 제어 변수가 내부 반복문에 영향을 미치게 된다.
• 따라서 중첩 반복문을 작성할 때, 반복문의 흐름을 정확하게 파악할 수 있어야 한다.

// 중첩 반복문을 이용한 별표 피라미드 만들기



/*
         *
         **
         ***
         ****
         *****
 */
       Scanner scanner = new Scanner(System.in);
        int star = scanner.nextInt();
        for (int i = 1; i <= star; i++) {
            for (int j = 0; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
        };

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


         for (int i = 1; i <= star; i++) {
            // 졀 찍기 전에 공백부터 만드는 for문
            for (int k = star - 1; k >= i; k--) {
                System.out.print(" ");
            }
            // 별찍는 for문
            for (int j = 0; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
        };

        /*
        *****
        ****
        ***
        **
        *
         */
        for (int i = 1; i <= star; i++) {
            // 졀 찍기 전에 공백부터 만드는 for문
            for (int k = 0; k < i - 1; k++) {
                System.out.print(" ");
            }
            // 별찍는 for문
            for (int j = star; j >= i; j--) {
                System.out.print("*");
            }
            System.out.println();
        }

4. 탈출문

프로그램의 실행을 특정 상황에서 강제로 종료시키는 역할을 당담.
자바에서는 break, continue, return 키워드를 사용한다.

4 - 1. break

• 반복문이나 switch문을 빠져 나올 때 주로 사용.
• 반복문에서 break문을 사용하면 해당 키워드가 들어있는 반복문 블록을 빠져 나온다.
• switch문에서 break문을 사용하면, 해당 case문을 탈출.

for (int i = 0; i <= 5; i++) {
	if (i == 3) {
    	break; // i가 3일 때, break문을 만나 반복문을 빠져나오기 떄문에 0부터 2까지만 출력.
    }
    System.out.println(i);
}
System.out.println("\n반복문 종료!");

• label을 사용하면 원하는 특정 반복문까지 한번에 탈출 가능.

4 - 2. 무한 루프

반복 횟수를 정하지 않고, 무한하게 반복하는 구조.
주로 사용자 입력을 받는 프로그램에서 많이 사용된다.

// while문의 무한 루프

while (true) {
	// 반복할 코드
}

// for문의 무한 루프

for (;;) {
	// 반복할 코드
}

• 이러한 무한 루프는 조건식으로는 탈출할 수 없어서, 반드시 특정 조건을 통해 탈출문을 사용하여 루프를 빠져나올 수 있게 해야한다.

4 - 3. continue

continue는 반복문에서 현재 반복을 건너뛰고 다음 반복을 실행하도록 한다.
반복문을 중간에 깨부수고 탈출하는 break와 달리, continue는 지정된 반복 횟수를 다 돌고 종료가 된다.

• for문에서 사용하면 증감식이 실행되고, while문에서는 조건식으로 흐름이 이동된다.

* return문은 메서드에서 값을 반환하고, 메서드를 종료시키는 역할. (후에 말할 메서드에서 언급)

5. 배열

같은 타입의 데이터를 하나의 변수에 저장하는 자료구조이다.
같은 데이터 유형 변수를 여러 개 선언해야 하는 불편함을 줄이기 위해 사용.
자바에서 배열은 고정된 크기로 선언되며, 크기를 변경할 수 없다.
배열은 동종모음 구조이기 때문에, 같은 데이터 타입끼리만 모여있을 수 있다.

// 배열 선언 및 초기화

int[] arr = new int[5];
System.out.println(Arrays.toString(arr)); // [0, 0, 0, 0, 0]

// int데이터 타입에 대한 배열이므로 int형을 제외하고는 배열안에 접근할 수 없다.
arr[0] = 1;
arr[1] = 2;
arr[2] = arr[0];
arr[3] = (int) 3.145;
arr[4] = 100;
// arr[2] = "str"; (x)
// arr[10] = 1500; (x)

System.out.println(Arrays.toString(arr)); // [1, 2, 1, 3, 100]

• 인덱스는 0부터 시작하기 때문에, 마지막 인덱스는 항상 배열의 길이보다 하나 작다.
• 배열변수명.length 프로퍼티를 이용하면 쉽게 배열의 길이를 파악할 수 있음.

System.out.println("arr 배열의 길이: " + arr.length); //5

• 배열 생성 시, 값을 지정하여 초기화할 수 있다.

int[] nums = {1, 2, 3, 4, 5};

• 배열의 사용

// 값을 꺼내고 싶을 때, 인덱스를 사용하면 된다.

int[] nums = {1, 2, 3, 4, 5};
System.out.println(numbers[2]); // 3
System.out.println(numbers[4]); // 5

// 배열의 요소를 반복적으로 처리하기 위해서는 for문을 이용할 수 있음.

for (int i = 0; i < nums.length; i++) {
	System.out.println(i);
} 
/*
1
2
3
4
5
*/

// 배열 내부를 문자열 형태로 확인하고 싶다면 toString()을 사용.

System.out.println(Arrays.toString(numbers)); // [1, 2, 3, 4, 5]

// 배열 변수를 그대로 출력할 경우,해당 주소값이 나온다. (이유는 배열은 객체 타입이기 때문이다!)

System.out.println(numbers); // 알수없는 주소값이 출력.

5 - 1. for - each 문 (향상된 for 문)

• 자바 5부터 추가된 기능으로 배열과 컬렉션에서 사용할 수 있음.
• 인덱스의 사용 없이, 배열 내부 요소를 전체 참조할 수 있게 도와줌.

for (배열 요소를 받을 수 있는 변수 : 배열 또는 컬렉션 이름) {
    // 실행문;
}

// 예시

String[] week = {"월", "화", "수", "목", "금", "토", "일"};

/*
for(int i=0; i<week.length; i++) {
	System.out.println(week[i] + "요일 좋아~!");
}
*/

for(String day : week) {
	System.out.println(day + "요일 좋아~");
}

• 반복문의 인덱스 변수의 선언이 필요없어 코드가 깔끔해지고, 구조적 변화가 없는 한 for문 보다 빠르다는 장점이 있다.
• 하지만, 인덱스 정보를 알 수 없고 범위를 세밀하게 지정할 수 없다. 또한 요소를 삭제할 수 없는 단점이 있다.

5 - 2. 배열의 수정

// 배열 내부의 데이터 수정은 해당 인덱스에 접근하여 값을 밀어넣으면 된다.

String[] foods = {"삼겹살", "족발", "피자", "햄버거"};
foods[0] = "치킨";
foods[2] = "탕수육";

System.out.println(Arrays.toString(foods)); // {"치킨", "족발", "탕수육", "햄버거"}

5 - 3. 배열 인덱스 탐색

Scanner sc = new Scanner(System.in);
System.out.print("탐색할 음식을 입력하세요: ");
String name = sc.next();

// 첫번째 방법
// boolean 타입의 변수를 선언하여 존재 유무를 확인해 준다.
// 찾았으면 true로, 반복문 다 돌릴 때 까지 못찾았으면 false로.
// 반복문이 끝나고 나서 확인해 주자.
boolean flag = false;
for(int i=0; i<foods.length; i++) {
	if(name.equals(foods[i])) {
		System.out.println("탐색 완료!");
		System.out.println("인덱스: " + i + "번");
		flag = true;
		break;
	} 		
}

if(!flag) { //flag == false
	System.out.println("없는 음식입니다.");
}


// 두번째 방법.
// 탐색하지 못한다면 반복문이 끝까지 돌아가면서 i의 값이 배열의 길이와 같아지며
// 반복문의 조건식을 false로 만들면서 탈출하는 것을 이용.
// i가 배열의 길이와 같아졌다면 탐색하지 못했다는 증거.
int i;
for(i=0; i<foods.length; i++) {
	if(name.equals(foods[i]) {
		System.out.println("탐색 완료!");
		System.out.println("인덱스: " + i + "번");
		break;
	}
}

if(i == foods.length) {
		System.out.println("없는 음식입니다.");
}

5 - 4. 배열의 삭제

// 원하는 위치의 값 삭제하기
int[] number = {1, 3, 5, 7, 9, 11};
int targetIndex = 3;

// 타켓 인덱스를 기준으로 뒤에 있는 값을 한 칸씩 땡겨오기 (마지막 데이터 전까지)
for (int i = targetIndex; i < (number.length - 1); i++) {
	number[i] = number[i + 1];
}

// 크기가 하나 작은 배열 선언
int[] temp = new int[number.length - 1];

// 배열 내부 데이터 복사
for (int i = 0; i < temp.length ; i++) {
     temp[i] = number[i];
 }

// 주소값 이전
number = temp; temp = null;

System.out.println(Arrays.toString(number));

// numbers[2] = numbers[3]; // 1, 3, 7, 7, 9, 11
// numbers[3] = numbers[4]; // 1, 3, 7, 9, 9, 11
// numbers[4] = numbers[5]; // 1, 3, 7, 9, 11, 11
// numbers[5] = numbers[6]; (x)

5 - 5. 배열 삽입

// [10 50 66 90 100 150]
int[] arr = {10, 50, 90, 100, 150};
int newNumber = 66;
int targetIndex = 2;

// 50과 90사이에 66을 삽입하고 싶다.

// 1. 사이즈가 1개 큰 새로운 배열을 생성
int[] temp = new int[arr.length + 1];

// 2. 기존 데이터를 새 배열에 복사
for (int i = 0; i < arr.length; i++) {
	temp[i] = arr[i];
}

// 3. 삽입 위치에서 데이터를 뒤로 한 칸씩 이동시키자.
// 이동 순서는 끝에서부터 시작해야 한다.

for (int i = arr.length; i > targetIndex ; i--) {
	temp[i] = temp[i - 1];
}

// 4. 새로운 데이터를 타겟 인덱스에 할당
temp[targetIndex] = newNumber;

        // 5. 주소값 이전
        arr = temp; temp = null;
        System.out.println(Arrays.toString(arr));

5 - 6. 배열 pop

// pop: 배열의 맨 끝 데이터를 삭제하면서 꺼내옴.
int[] nums = {10, 20, 30, 40, 50, 60};

// 1. 기존 배열보다 크기가 1개 작은 배열을 생성
int[] temp = new int[nums.length - 1];

// 2. 원본 배열에서 맨 끝 인덱스를 제외한 나머지 내용 복사
for (int i = 0; i < temp.length ; i++) {
	temp[i] = nums[i];
}

// 3. 삭제값 백업
int removedNumber = nums[nums.length - 1];

// 4. 주소값 이전
nums = temp; temp = null;

System.out.println(Arrays.toString(nums));
System.out.println("삭제된 값은 " + removedNumber + "입니다.");

6. 2차원 배열

• 기본적인 형태

// 3행 4열의 int형 2차원 배열

int[][] arr2d = new int[3][4];

/* {
	{0, 0, 0, 0},
	{0, 0, 0, 0},
	{0, 0, 0, 0}
} */

6 - 1. 2차원 배열의 값 삽입 및 수정

// 2차원 배열에 값 넣기
arr2d[1][2] = 50;
arr2d[2][0] = 70;


// 결과
{
	{0, 0, 0, 0},
	{0, 0, 50, 0},
	{70, 0, 0, 0}
}

6 - 2. 2차원 배열의 반복문

for(int i=0; i<arr2d.length; i++) {
	// i는 지금 작은 배열 덩어리를 지목하는 것.
	for(int j=0; arr2d[i].length; j++) {
		// j는 작은 배열 덩어리 안의 데이터를 지목하는 것.
		System.out.println(arr2d[i][j]);
	}	
}

• 관련 예시

        int[][] score = {
                {79, 80, 99}, // A 학생
                {49, 65, 12}, // B 학생
                {86, 75, 90}, // C 학생
                {100, 34, 89}, // D 학생
        };


        String[] stuName = {"A학생", "B학생", "C학생", "D학생"};
        String[] subName = {"국어", "영어", "수학"};

        /*
         1. 각 학생의 평균을 소수점 첫째 자리까지 출력해 보세요.
         2. 각 과목의 평균을 출력해 보세요.
         3. 반 평균을 출력해 보세요. (모든 학생들의 평균을 더해서 학생수로 나누기)
         */
        double totalAvg = 0.0; // 학생들의 평균점수의 총합.


        int idx = 0; //stuName 배열에서 학생 이름을 지목할 용도
        for (int[] ints : score) {
            int total = 0;
            for (int i : ints) {
                total += i;
            }
            double avg = (double) total / subName.length;
            totalAvg += avg;
            System.out.printf("%s의 평균: %.1f점\n", stuName[idx], avg);
            idx++;
        }

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

        for (int i = 0; i < subName.length; i++) {
            int total = 0;
            for (int j = 0; j < stuName.length ; j++) {
                total += score[j][i];
            }
            double avg = (double) total / subName.length;
            System.out.printf("%s의 평균 점수: %.1f점\n", subName[i], avg);
        }

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


        double classAvg = totalAvg / stuName.length;
        System.out.printf("우리반 평균: %.1f점\n", classAvg);

7. 메서드 (Method)

메서드는 반복되는 코드 블록에 이름을 붙여 놓은 것을 말한다.
반복되는 코드를 줄여주고, 좀 더 구조화를 만들어 코드의 가독성을 높여준다.

// 메서드의 기본적인 구조

[리턴타입] [메서드명](매개변수) {
    // 메서드의 기능 구현
}

1. 리턴 타입 : 메서드가 실행 후 반환하는 데이터 타입을 설정. (반환할 값이 없는 경우에는 void)
2. 메서드명 : 메서드의 이름을 설정. 식별자의 규칙에만 맞게 지어주면 됨.
3. 매개변수 : 메서드를 실행할 때 필요로 하는 값의 데이터 타입과 이름을 설정. 물론 매개변수가 없는 경우에는 비워주면 된다.
4. 메서드의 기능 구현 : 메서드가 수행할 기능을 구현하는 코드 블록.

• 메서드를 선언할 때, 클래스 블록에 선언해야 한다. (메서드 안에서는 메서드를 선언할 수 없음.)
• 코드를 작성하던 public static void main(String[] args)도 메서드이다. 즉, main 안에는 메서드를 선언할 수 없다.

public class Main {

// 메서드 선언 가능

    public static void main(String[] args) {

    }
    
    // 메서드 선언 가능 
}

public class MethodExample1 {

    // 메서드의 선언
    static int calcTotal(int end) {
        int total = 0;
        for (int i = 1; i <= end; i++) {
            total += i;
        }
        return total;
    }

    public static void main(String[] args) {
        int total = calcTotal(10);
        System.out.println(total);
        System.out.println(calcTotal(100));
        System.out.println(calcTotal(200));
        System.out.println(calcTotal(300));
        System.out.println(calcTotal(400));
        System.out.println(calcTotal(500));

• 메서드의 호출은 곧 메서드를 사용하겠다는 것과 같은 말이다.

1. 메서드가 필요로 하는 데이터를 호출부에서 전달하면
2. 그 값을 받아 메서드 내부로 전달하고, 로직이 실행.
3. 실행 결과값을 메서드를 호출한 곳을 다시 반환
4. 변환된 값은 변수에 담아서 저장하거나, 출력하는 등 다양하게 사용.

7 - 1. 매개변수 (parameter)

메서드를 호출할 때, 메서드 실행에 필요한 값들을 메서드 내부로 전달하는 매개체 역할을 하는 것.
어떤 매개체를 전달하느냐에 따라 메서드의 실행 결과는 언제든지 달라질 수 있음.
()안에 미리 개수와 타입을 지정함. 물론 하나도 선언하지 않을 경우에는 () 내부를 비워서 호출

// 일반적인 매개변수 사용 
    
    static int calcRangeTotal(int start, int end) {
        int total = 0;
        for (int i = start; i <= end; i++) {
            total += i;
        }
        return total;
    }
    
        int result = calcRangeTotal(3, 7);
        System.out.println("result = " + result);
        
// 매개변수 없을 경우

    static String selectRandomFood() {
        double rn = Math.random();
        if (rn > 0.66) {
            return "치킨";
        } else if (rn > 0.33) {
            return "족발";
        }
        return "햄버거";
    }
    
        String string = selectRandomFood();
        System.out.println("오늘 점심 뭐먹지??: " + selectRandomFood());
        
// 정수 n개를 전달하면 그 정수들의 평균을 리턴하는 메서드 (매개변수에 배열을 넣어 해결한다.)
    static double calcAverage(int[] nums) {
        int total = 0;
        for (double num : nums) {
            total += num;
        }
        return (double) total / nums.length;
    }
    
        int[] arr = {30, 50, 70, 90, 12, 33};
        double average = calcAverage(arr);
        System.out.println("average = " + average);
        
// 가변 파라미터를 사용한 매개변수 작성
// ...로 나열되어 들어오는 여러개의 값을 배열로 묶어서 메서드 내부로 전달합니다.
    static double calcAverage2(int... nums) {
        int total = 0;
        for (double num : nums) {
            total += num;
        }
        return (double) total / nums.length;
    }
    
        double average2 = calcAverage2(1, 2, 3, 4, 2, 2384, 23423, 435);
        System.out.println("average2 = " + average2);

* 자바는 반드시 매개변수의 개수와 타입에 맞게 인수를 전달해야 한다.

7 - 2. return

반환값이란, 메서드의 실행 결과값을 의미.
여러 개 존재할 수 있는 매개변수와 달리, 반환값은 오직 한 개만 존재해야 한다.
return이라는 키워드를 사용하고, return뒤에 전달할 값을 지정한다.
반환값이 있는 메서드는 호출문 자체가 하나의 값으로 처리될 수 있기 때문에 반환값을 다른 변수에 대입하거나, 다른 메서드의 매개값으로도 처리될 수 있음.

static int add(int n1, int n2) {
	return n1 + n2;
}

/////////////////////////////////////

int r1 = add(3, 8); //int r1 = 11;
int r2 = add(10, 15); //int r2 = 25;

// 리턴값이 있는 메서드는 메서드 호출문이 곧 리턴값으로 처리될 수 있기 때문에, 
// 다른 메서드의 매개값으로도 사용이 가능.

int r3 = add(add(4,6), add(7,8)); // int r3 = add(10, 15) -> int r3 = 25

static int[] operateTotal(int n1, int n2) {
		//return n1 + n2;
		//return n1 - n2; 하나의 메서드가 여러 번 리턴할 수는 없다.

		//여러개의 값 리턴하고 싶으면 배열에 싸서 보내셈.
		return new int[] {add(n1, n2), n1-n2, n1*n2, n1/n2};
}

// void일 경우에는 return을 생략해도 된다.
// 반환값이 없는 void 타입의 메서드는 값이 돌아오지 않기 때문에 
// 실행 결과를 변수에 저장할 수 없으며, 다른 메서드의 매개값으로도 사용이 불가능. (반드시 단독 호출 사용)
// void메서드는 단순히 동작을 지시하는 역할을 수행.

static void multi(int n1, int n2) {
		int result = n1 * n2;
		System.out.printf("%d x %d = %d\n", n1, n2, result);
}

//////////////////////////////////////////////////

//		int r4 = multi(10, 7); (x)
//		System.out.println(multi(10, 7)); (x)
		multi(10, 7);
		multi(add(3,4), add(4,7));
//		add(multi(4,4), multi(5,6)); (x)


// 모든 메서드는 return을 만나면 강제로 메서드가 종료됨.
// 따라서 조건 없이 return문 아래에 코드를 작성할 수 없음.
// void메서드에서는 return키워드를 탈출 기능으로 사용이 가능.

static void divide(int n1, int n2) {
		if(n2 == 0) {
			System.out.println("0으로 나누지 마세요!");
			return;
		}
		int result = n1 / n2;
		System.out.printf("%d / %d = %d\n", n1, n2, result);
	}

8. 객체 지향 프로그래밍

객체란, 데이터와 그 데이터를 처리하는 함수들을 묶어놓은 하나의 독립적인 단위. 
이렇게 하나의 단위로 묶어 놓으면 코드의 가독성이 좋아지고, 유지 보수가 편리하여 대규모 프로그램을 개발할 때 유용함.

//빨간 펜
int redPenPrice = 500;
String redPenColor = "빨강";
String redPenNo = "a001";

//파랑 펜
int bluePenPrice = 800;
String bluePenColor = "파랑";
String bluePenNo = "a002";

//검정 펜
int blackPenPrice = 1000;
String blackPenColor = "검정";
String blackPenNo = "a003";

void redPenWrite() {
	System.out.println("빨간 펜으로 글씨를 씁니다.");
}

void redPenDraw() {
	System.out.println("빨간 펜으로 그림을 그립니다.");
}

void redPenInfo() {
	System.out.println("제품번호: " + redPenNo);
	System.out.println(redPenColor + "색 펜의 가격은 " + redPenPrice + "원 입니다.");
}

////////////////////////////////////////////////////

void bluePenWrite() {
	System.out.println("파랑 펜으로 글씨를 씁니다.");
}

void bluePenDraw() {
	System.out.println("파랑 펜으로 그림을 그립니다.");
}

void bluePenInfo() {
	System.out.println("제품번호: " + bluePenNo);
	System.out.println(bluePenColor + "색 펜의 가격은 " + bluePenPrice + "원 입니다.");
}

• 이 코드는 틀린 것은 없지만, 몇 개의 불편한 점이 있다.

1. 펜의 속성들과 기능들이 동일하지만, 구분을 위해서 일일히 다른 변수 이름을 사용하고, 메서드 이름도 다르게 지정.
2. 지금 현재 펜의 개수가 3개 밖에 안되지만, 계속해서 추가가 된다면 변수와 메서드들이 기하급수적으로 늘어날 것이다.
3. 만약 같은 색상의 펜이 두 개라면, 그 두 펜을 구분하기 위해 또 다른 변수 이름과 메서드 이름으로 똑같은 속성 및 기능으로 표현해야 함.

• 이 불편한 점을 해결하기 위해서는 "설계도"를 만들고 찍어내면 된다!

//객체 설계용 클래스(라이브러리 클래스)는 메인 메서드를 작성하지 않습니다.
public class Pen {
	
	//객체의 속성을 필드(멤버변수)라고 부릅니다.
	String color;
	int price;
	String productNo;
	
	
	//객체의 기능을 메서드라고 합니다.
	void write() {
		System.out.println(color + "색 글을 씁니다.");
	}

	void draw() {
		System.out.println(color + "색 그림을 그립니다.");
	}
	
	void priceInfo() {
		System.out.println("제품번호: " + productNo);
		System.out.println(color + "색 펜의 가격은 " 
							+ price + "원 입니다.");
	}
}

• 이렇게 설계도를 작성했지만, 이것만 가지고는 무엇도 할 수 없다.
• 따라서 실물을 만들기 위해, MainClass를 하나 제작해서 객체를 생성해야한다.

        Pen redpen = new Pen();
        Pen bluepen = new Pen();

        System.out.println("redpen = " + redpen);
        System.out.println("bluepen = " + bluepen);
       
       
        redpen.color = "red";
        redpen.price = 2500;
        bluepen.color = "blue";
        bluepen.price = 600;

        redpen.write();
        redpen.priceInfo();
        bluepen.write();
        bluepen.priceInfo();

9. 필드와 지역변수, 참조값과 문자열 equals()

• 같은 변수이지만, 어디에 선언되었냐에 따라 필드 또는 지역변수라는 이름이 붙게되며 그 둘은 특징에 차이가 있음.

- 선언 위치와 범위

• 필드 : 클래스 내부에 선언, 해당 클래스의 모든 메서드에서 접근이 가능
• 지역 변수 : 메서드나 블록 내부에 선언, 해당 영역 내에서만 접근 가능

- 초기화 여부

• 필드 : 초기값이 지정되지 않으면 기본값으로 자동 초기화
• 지역 변수 : 반드시 초기화가 되어야 한다. 초기화되지 않은 지역 변수는 사용할 수 없음.

- 메모리 할당 위치

• 필드 : 객체가 생성될 때마다 각각의 객체마다 독립적인 메모리 공간에 할당.
• 지역 변수 : 해당 변수가 선언된 블록이 실행될 때마다 스택 메모리에 할당되며, 블록이 종료되면 할당된 메모리가 해체

public class FieldVariable {

    int a; // field

    /*
        - 지역 변수는 반드시 초기화가 되어 있어야 참조가 가능합니다.
        - 필드는 초기화를 하지 않아도 자동으로 각 타입의 기본값으로 초기화됩니다.
        - 매개 변수는 메서드 호출시 강제로 값이 대입되므로 따로 초기화할 필요가 없습니다.
     */
    void m1(int c) { // c: parameter -> 매개변수도 일종의 지역 변수.
        int b = 1; // local variable
        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("c = " + c);
    }

    public static void main(String[] args) {

        FieldVariable fv = new FieldVariable();
        fv.m1(10);

        System.out.println(fv.a);
    }
}

9 - 1. 문자열 동등 비교 equals()

• 먼저 문자열 String은 기본 데이터 타입이 아닌 객체 타입.
• 따라서 두 개의 문자열을 비교할 때는 객체가 가지고 있는 동등성을 비교해야 한다. 이를 위해서는 "==" 대신 equals()메서드를 사용.

String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2); // true

String s1 = "hello";
String s2 = new String("hello");
System.out.println(s1 == s2); // false

• 위의 코드 비교값이 서로 다른 이유

• 기본 타입처럼 문자열을 선언하게 되면 문자열 상수 풀이라는 곳에 저장됨. 
• 그리고나서, 새로운 변수에 기본 타입처럼 문자열을 저장하게 될 때, 기존에 이미 존재하는 문자열을 저장하려고 시도하면, 이미 상수 풀에 존재하는 문자열을 재사용하게 된다.
• 하지만 new String();처럼 문자열을 생성하게 되면, 상수풀에 존재하는 것을 재활용하는 것이 아닌 새로운 문자열 객체를 생성하게 된다. 따라서 주소값이 다르다고 나옴.
• 반면 equals() 메서드는 2개의 객체의 내용이 같은지를 비교한다. 말 그대로 객체들이 가지고 있는 문자열 자체를 비교하게 되는 것.

String s1 = "hello";
String s2 = "hello";
System.out.println(s1.equals(s2)); // true

String s3 = new String("hello");
System.out.println(s1.equals(s3)); //true

10. 생성자

생성자는 객체를 생성하는 역할을 해주는 것.

• 특징

1. 생성자의 이름은 클래스의 이름과 대/소문자까지 완벽하게 동일해야 한다.
2. 객체를 생성할 때, 반드시 호출
3. 일종의 메서드지만, 리턴 타입이 없고 리턴값은 주소값으로 고정되어 있음.
4. 생성자를 하나도 선언하지 않을 경우, 기본 생성자 하나 생성해주기 때문에 생성자 선언 없이 객체 생성이 가능.
5. 객체를 생성하는 기능 뿐만 아니라, 객체 생성과 동시에 해야 할 일 등을 진행할 수 있음.

public class Phone {
    String model;
    String color;
    int price;
    
    // 생성자를 선언하지 않으면 가장 기본 형태의 생성자를 하나 만들어준다.
    Phone() {
    	// 이게 가장 기본 형태의 생성자이다.
        // 클래스와 이름이 동일하고, 리턴 타입이 존재하지 않는다.
    }

    Phone() {
        System.out.println("기본 생성자 호출");
        model = "폴더폰";
        color = "회색";
        price = 200000;
        // 이렇게 기본 생성자에 코드를 추가해줄 수 있다.
    }
    
    
    
         /*
             # 생성자 오버로딩 (중복 선언)

             1. 생성자는 중복해서 여러 개 선언이 가능합니다.
             2. 단, 생성자의 매개변수의 타입, 개수, 순서 중 하나가 달라야
                중복을 인정합니다.
             */
    
        Phone(String pModel) {
        System.out.println("2번 생성자 호출");
        model = pModel;
        color = "while";
        price = 100000;
    }

    Phone(String pModel, String pColor) {
        System.out.println("3번 생성자 호출");
        model = pModel;
        color = pColor;
        price = 120000;
    }

}

• 생성자를 호출함으로써 객체를 생성할 수 있으며, 생성자가 여러 개 존재한다면 원하는 대로 골라서 호출하는 것이 가능하다.

public class Main {
    public static void main(String[] args) {
        Phone basic = new Phone();
        basic.showSpec();

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

        Phone galaxy = new Phone("갤럭시 s25");
        galaxy.showSpec();

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

        Phone iPhone = new Phone("아이폰 16", "스페이스 그레이");
        iPhone.showSpec();
    }
}

* 기본 생성자 없이 매개값을 받는 생성자만 선언해 놓았을 경우에는 그 생성자만을 사용해서 객체를 생성할 수 있음. (기본 생성자를 호출해서 객체를 생성할 수 없음.)

* 이 말은 자바가 생성자를 자동으로 선언해주는 경우는 생성자를 단 하나도 선언하지 않았을 경우뿐이다.

11. 패키지

비슷한 성격을 가진 자바 클래스나 인터페이스들을 모아 놓은 자바의 디렉토리이다.

• 특징

1. 패키지를 만들어서 클래스에 배치하면, 클래스 최 상단에 패키지 구문이 포함.
2. 패키지 이름은 소문자로 지어주는 것이 관례.
3. 상위 패키지와 하위 패키지를 구분할 때는 .(dot)을 사용.
4. 패키지 이름을 정할 때는 식별자 규칙이 적용됨.

//패키지 내에 클래스를 생성하면 클래스 최상단에 패키지 선언문이 추가된다.
package fruit;

public class Apple {

	public Apple() {
		System.out.println("생과일 사과 입니다.");
	}

}

package fruit;

public class Banana {
}

package fruit;

public class Grape {
}

fruit라는 3개의 클래스를 선언

package syrup;

public class Apple {
	public Apple() {
		System.out.println("사과 시럽 입니다.");
	}
}

// 이미 Apple이라는 클래스가 존재하지만, 패키지가 서로 다르기 때문에 
// 동일한 이름으로 클래스를 만들어도 구분이 된다.

package test;

//패키지 외부에 있는 클래스는 import 선언을 통해 정보를 불러 와야 사용이 가능하다. 
//import fruit.Apple;
//import fruit.Banana;
//import fruit.Grape;

//fruit 패키지 내의 모든 클래스를 import 하겠다는 선언문.
import fruit.*;

public class Test {

    public static void main(String[] args) {

				//패키지가 다르고 이름이 동일한 클래스의 객체를 생성할 때는
				//패키지 풀 경로를 모두 써 주어야 구분이 된다.
        Apple apple = new Apple();
				syrup.Apple a2 = new syrup.Apple();				

        new Banana();
        new Grape();

				//import 선언을 하지 않으면 패키지 경로를 모두 작성해야 한다.
				//java 패키지 내의 util이라는 패키지 내에 있는 Scanner 클래스.
        new java.util.Scanner(System.in);

    }
}

12. this

현재 객체를 참조하는 키워드로, 클래스 내에서 자기 자신의 인스턴스 변수를 참조할 때 사용.
이 키워드를 사용하면, 메서드 내에서 로컬 변수와 인스턴스 변수를 구분할 수 있음.

public class Player {

    String name; // 닉네임
    int level; // 레벨
    int hp;    // 체력

    // 생성자
    Player() {
        System.out.println("1번 생성자 호출!");
	      name = "이름없음";
	      level = 1;
        hp = 50;
    }
		
		Player(String name) {
        System.out.println("2번 생성자 호출!");
	      name = name; //문제가 발생하는 코드
	      level = 1;
        hp = 50;
    }
		
	......

}

///////////////////////////////////////////////////////////////////

Player p2 = new Player("플레이어2");
System.out.println(p2.name); // null!;

• 위 코드에서 값이 제대로 전달되지 못한 이유는 필드의 name과 생성자의 매개변수 name이 이름이 동일하기 때문이다. (둘 다 생성자내에서 매개변수를 우선시 여겨, 코드가 이상해진다.)
• 따라서 매개변수 name과 필드 name을 구분할 수 있게 this를 사용하면 된다.

Player(String name) {
    System.out.println("2번 생성자 호출!");
    this.name = name; //this가 가지는 주소값은 이 생성자를 부른 객체의 주소값이 된다.
    level = 1;
    hp = 50;
}
///////////////////////////////////////////////////////////////////

Player p2 = new Player("플레이어2");
System.out.println(p2.name); // 플레이어2;

Player p3 = new Player("플레이어3");
System.out.println(p3.name); // 플레이어3;

• this는 생성자나 메서드를 호출한 그 객체의 주소값과 동일한 주소값을 갖게 된다.

12 - 1. this() 를 이용하여 생성자 호출하기

• this를 사용하면 같은 클래스 내의 다른 생성자를 호출할 수 있다.

Player() {
    System.out.println("1번 생성자 호출!");
    name = "이름없음";
    level = 1;
    hp = 50;
}

Player(String name) {
    System.out.println("2번 생성자 호출!");
    this.name = name;
    level = 1;
    hp = 50;
}

• 여기에서 level을 1로, hp를 50으로 초기화 해주는 것은 두 생성자가 동일하다.
• 나중에 멤버 변수 또는 생성자 수가 많아지면, 그만큼 중복이 많아져 쓸데없이 코드가 길어진다. 그러므로 this()로 내 다른 중복 생성자를 불러 주는 것이 좋다.

Player() {
    System.out.println("1번 생성자 호출!");
    name = "이름없음";
    level = 1;
    hp = 50;
}

Player(String name) {
		this();
    System.out.println("2번 생성자 호출!");
    this.name = name;
}

Player(String name, int hp) {
		this(name); //name을 매개값으로 받는 생성자 호출!
    System.out.println("3번 생성자 호출!");
		this.hp = hp;
}

//////////////////////////////////////////////////////////////////

Player p1 = new Player("플레이어1");
System.out.println(p1.name); // 플레이어1
System.out.println(p1.level); // 1
System.out.println(p1.hp); // 50

* 자신의 다른 생성자를 호출하는 코드는 반드시 생성자의 최상단에 위치해야 한다.

* 생성자 또는 메서드 내에서 필드값을 참조할 때, 기본적으로 "this."이 생략되어 있다.

13. 접근 제한자

클래스/필드/메서드/생성자에 대한 접근 권한을 제한하는 키워드

• 접근 제한자의 종류

1. public : 어떤 클래스에서든 접근 가능한 최대한의 범위. 다른 패키지에서도 접근이 가능. 즉, 접근 제한 자체가 없는 경우이다.
2. protected : 같은 패키지에서는 모든 클래스에서 접근 가능. 다른 패키지의 경우 상속받은 자식 클래스에서만 접근 가능.
3. default (아무런 접근 제한자를 사용하지 않음) : 같은 패키지 내에서만 접근이 가능하고, 다른 패키지에서는 접근이 불가능하다.
4. private : 같은 클래스 내에서만 접근 가능. 다른 클래스에선 접근할 수 없다. (가장 폐쇄적인 제한자)

• 접근 제한자를 사용하여, 클래스/변수/메서드 등의 멤버에 대한 접근 범위를 제한함으로써 코드의 안정성을 높일 수 있음.
• 사용자가 알 필요 없는, 또는 알아서는 안되는 정보들은 숨겨주거나 변경할 수 없어야 한다.

* class의 경우, public / default 제한자만 들어갈 수 있음. (private과 protected는 사용 불가능)

14. 정보 은닉과 캡슐화

14 - 1. 정보 은닉

객체의 상태를 숨기고, 외부에서 접근할 수 없도록 보호하는 것을 의미.
정보 은닉을 사용하지 않으면, 객체 필드에 불필요한 값이나 문제가 발생할 수 있는 값들이 들어오는 것을 막을 수 없음.

public class MyBirth {
    int year;
    int month;
    int day;

    void birthInfo() {
        System.out.printf("내 생일은 %d년 %d월 %d일 입니다.\n"
                , this.year, this.month, this.day);
    }


}

public class Main {

    public static void main(String[] args) {

        MyBirth birth = new MyBirth();
        birth.year = 200051;
        birth.month = -394;
        birth.day = 13444;

        birth.birthInfo();

    }
}

• 위 코드는 정보 은닉이 구현되어 있지 않다. 그래서 생일 년/월/일에 정해진 범위를 넘어서는 숫자, 심지어는 음수를 넣어도 코드가 동작한다. 이러한 것을 막기 위해 정보 은닉이 필수적이다.

public class MyBirth {

    // 외부에서 변수의 직접 접근할 수 없도록 필드에 private 제한을 붙임.
    private int year;
    private int month;
    private int day;
    
        public void setYear(int year) {
        if (year < 1900 || year > 2025) {
            return;
        }
        this.year = year;
    }


    public void setMonth(int month) {
        if (month < 1 || month > 12) {
            System.out.println("잘못된 접근입니다.");
            return;
        }
        this.month = month;
    }

    public void setDay(int day) {
        if (day < 1 || day > 31) {
            System.out.println("잘못된 접근입니다.");
        } else {
            if (this.month == 0) {
                System.out.println("일자를 입력하기 위해서는 월 입력이 선행되어야합니다.");
                return;
            }
            if (!isValidateMonth(day)) {
                System.out.println("월에 따른 일자가 올바르지 않습니다.");
                return;
            } else {
                this.day = day;
            }
        }
    }

    void birthInfo() {
        if (year == 0 || month == 0 || day == 0) {
            System.out.println("날짜 필드 중에 초기화되지 않은 데이터가 있습니다.");
            return;
        }
        System.out.printf("내 생일은 %d년 %d월 %d일 입니다.\n", this.year, this.month, this.day);
    }


    public int getYear() {
        return year;
    }

    public int getMonth() {
        return month;
    }

    public int getDay() {
        return day;
    }
    
    // 각 월에 적합한 일자가 세팅되어 있는지를 판별하는 메서드
    private boolean isValidateMonth(int day) {
        switch (this.month) {
            case 2:
                if (day > 28) return false;
            case 4, 6, 9, 11:
                if (day > 30) return false;
            default:
                return true;
        }
    }

• 모든 필드를 private으로 지정하여 외부로부터의 접근을 막아, 정보를 보호할 수 있지만, 데이터 접근 자체가 힘들어진다.
• 따라서 데이터의 유효성을 검증할 수 있는 제어문이 포함된 메서드를 이용하여 데이터의 접근을 허용하도록 설계하는데, 이 때 사용되는 것이 getter / setter 메서드라고 부른다.
• setter 메서드는 숨겨진 변수에 값을 저장하기 위한 메서드로 내부에 데이터 유효성 검증 로직을 작성하여 적절한 데이터만 저장시킨다. (메서드 이름은 일반적으로 set + 필드이름으로 설정.)
• getter 메서드는 숨겨진 변수의 값을 참조할 때 사용하는 메서드로, setter메서드와 마찬가지로 public 제한을 두어 외부에 공개함. (일반적으로 get + 필드이름으로 설정.)

* boolean 타입 필드의 getter 메서드는 get이 아닌, is로 시작하는 것이 관례이다.

    public boolean isYear() {
        return year;
    }

14 - 2. 캡슐화

객체의 상태와 동작을 하나의 단위로 묶어서 구현하는 것.
즉, 하나의 목적을 이루기 위해 관련 있는 모든 것들을 하나의 캡슐에 담아 두는 것을 의미함.

// 시동 거는 기능
public void engineStart() {
    System.out.println("시동 버튼을 눌렀습니다.");
    System.out.println("시동이 걸렸습니다.");
}


// 엔진에 연료가 주입되는 기능
private void injectGasoline() {
    System.out.println("연료가 엔진에 주입됩니다.");
}
// 엔진오일이 주입되는 기능
private void injectOil() {
    System.out.println("엔진 오일이 순환합니다.");
}
// 실린더가 움직이는 기능
private void moveCylinder() {
    if (start) {
        System.out.println("실린더가 움직입니다.");
    } else {
        System.out.println("차가 고장났습니다.");
    }
}

// 시동 거는 기능
public void engineStart() {
    System.out.println("시동버튼을 눌렀습니다.");
    injectOil();
    injectGasoline();
    this.start = true;
    moveCylinder();
    System.out.println("시동이 걸렸습니다.");
}

• 캡슐화를 통해 사용자 쪽에서 좀 더 간결한 문법으로 객체를 동작시킬 수 있는 편의성이 있다.
• 또한, 내부 로직이 변경되더라도 외부 코드에는 영향을 미치지 않도록 설계되기 때문에 유지 보수의 편의성이 증가한다.

15. 상속

부모 클래스가 가진 속성과 기능을 자식 클래스가 물려받는 것.

• 위 코드는 불편한 점이 몇 가지가 존재한다.
• 각각 클래스는 다르지만 가지고 있는 속성과 기능이 서로 비슷한 것을 찾아볼 수 있음.
• 이 상황에서 동물 클래스를 더 추가한다면 클래스를 더 작성하기가 힘듬.

• 이것은 위의 코드를 상속화해서 만든 것이다.
• 부모 클래스인 Animal 클래스는 기존 Dog / Cat / Monkey / Dolphin이 가지고 있는 속성 및 기능을 모두 모아놓은 클래스로 작성.
• 그리고 나머지 동물 클래스가 Animal 클래스를 상속받는 형식으로 구축
• 이렇게 작성하면 중복되는 속성 및 기능을 일일히 작성할 필요가 없으며 각각이 가지는 고유한 속성들만을 클래스에 추가하여 개념 확장가능.

15 - 1. 상속 정리

• 단일 상속 만을 지원한다. (부모는 한명이어야 한다.)

* 왜 다중 상속은 되지 않는가? 

(death of diamond)

위 그림에서 B, C 클래스는 A의 클래스를 상속받는 자식 클래스이다. 

그리고 D클래스는 B, C 클래스에게 상속받는다. 

이 때, B, C  클래스에 존재하는 A클래스를 중복으로 상속받게 되어 오류가 발생할 수 있다.

• 어떤 클래스가 다른 클래스로부터 상속을 받아 만들어지면 새롭게 만들어진 클래스를 자식 클래스라고 부르며, 필드와 메서드를 물려준 클래스는 부모 클래스라고 부른다.
• 상속을 하면 부모 클래스의 필드와 메서드가 자식 클래스에게 상속, 단 부모 클래스의 생성자는 상속이 되지 않음.
• 부모의 private 멤버는 상속 대상에서 제외

15 - 2. 오버라이딩 (overriding)

• 부모 클래스로부터 상속 받은 메서드를 자식 클래스에서 행위를 바꾸거나 보완하기 위해 다시 정의해서 사용하는 것.
• 부모 클래서에서 어떠한 용도로 사용하던 메서드를 자식 클래스에서 다른 용도로 사용할 때, 필요함.

• 오버라이딩의 규칙

1. 부모가 물려주는 메서드와 이름이 동일.
2. 부모가 물려주는 메서드와 매개 변수 선언이 동일.
3. 부모가 물려주는 메서드롸 리턴 타입이 같아야 함.
4. 접근 제한자는 같거나 더 넓어야 함.

15 - 3. super

상속 받고 있는 부모 객체를 지목할 때 사용하는 키워드이다.
이 키워드를 통해 부모의 필드 & 메서드를 지목할 수 있으며, 부모의 생성자를 호출하는 것 또한 가능.

//부모 클래스
public class Person {
		String name;
		int age;

		public Person() {}

		public Person(String name) {
			this.name = name;
		}

		String info() {
		return "이름: " + name + ", 나이: " + age;
		}
}

//////////////////////////////////////////////////////

public class Student extends Person {
	
		String studentId;

		public Student(String name, String studentId) {
			super(name);
			this.studentId = studentId;
		}
		
		@override
		String info() {
			return super.info() + "학번: " + studentId;
		}

		void study() {
				System.out.println("공부를 합니다.");
		}
}

• 위 코드에서 부모가 물려준 메서드인 info에 Student가 가지는 고유한 속성인 studentId 정보만 추가해주는 식으로 오버라이딩 진행
• 그렇기 때문에, 완전히 뜯어 고치는 것이 아닌, 부모 메서드 기반으로 자식의 고유 속성만 추가해줄려고 함.
• 그래서 super.info()를 통해 부모의 메서드를 가져왔고, 리턴된 문자열에 studentId만 추가.
• 생성자의 경우, 자식 클래스의 생성자는 name / studentId를 받고 있는 모습.
• 자식 생성자 내에서 name과 studentId를 초기화 할 수도 있지만, 자식 생성자는 부모 생성자를 호출 해야 객체를 생성할 수 있기 때문에 부모의 생성자를 불러 초기화를 하는 모습. (super(name)을 사용)

* 자식 클래스의 생성자에는 항상 super()가 기본적으로 들어 있음. (기본적으로 컴파일러가 super()을 삽입해주기 때문에)

* 기본적으로 자식 객체는 부모 객체가 우선적으로 생성 되어야 함.

* 그렇기 때문에 super()를 생략하더라도 자식 객체가 생성이 되지만, 직접 super키워드를 사용하여 부모 생성자를 골라서 호출할 수 있음.

16. static

public class MyClass {
		public int a; //인스턴스 필드
    public static int b; //정적 필드
}

• 먼저 클래스에 인스턴스 필드와 정적 필드 하나를 작성 해본다.

Count c1 = new Count();

c1.a += 5;
c1.b += 5;

System.out.println("인스턴스 변수 c1.a: " + c1.a); //5
System.out.println("정적 변수 c1.b: " + c1.b); //5

• 처음에는 서로 같은 값이 나오는 것을 볼 수 있지만,

Count c2 = new Count();
		
c2.a += 7;
c2.b += 7;

System.out.println("인스턴스 변수 c2.a: " + c2.a); //7
System.out.println("정적 변수 c2.b: " + c2.b); //12

• 나중에는 서로 다른 값이 나온 것을 볼 수 있다.
• 객체의 필드는 각 객체마다 고유하게 가지고 있는 값이다. 이런 이유로 객체를 생성할 때마다 그 객체들 내에 a라는 필드가 각각 존재하기 때문에 값이 다 다르다.
• 반면 정적 변수는 객체마다 생성되는 것이 아닌, 따로 생성되어서 모든 객체가 공유하는 전역 변수로서 동작하기 때문에 값이 누적됨.
• 그렇기 때문에 일반 필드를 부르는 것처럼 static 필드를 부르는 것은 혼란을 줄 수 있어, static을 부르는 방식으로 불러야 한다.

public class Count {
	
	public int a; //인스턴스 변수
	public static int b; //정적 변수
	
	//일반 메서드
	public int method1() {
		return this.a + Count.b;
	}
	
	//static 메서드
	public static int method2() {
		//this.a = 10; (x)
		Count ccc = new Count();
		return ccc.a + Count.b;
	}

}

• 인스턴스 메서드 안에는 정적 변수와 인스턴스 변수, 모두를 사용할 수 있음.
• 반면 정적 메서드 내부에서는 static이 붙은 변수나 메서드만 사용 가능.
• 나타낼 주소값이 없기 때문에 this는 사용할 수 없음.
• static 블록 내부에서 non-static 멤버를 사용할려면 반드시 객체를 생성해서 주소값을 통해 참조해야 한다.

* 우리가 평소에 사용하는 main 메서드도 정적 메서드이다. 

• static은 모든 객체가 공유해도 문제가 없는 필드나 메서드에 붙임.

17. final

17 - 1. final 필드

public class Person {
	
	final String nation; //에러
	String name;
	int age;

}

• 클래스를 선언할 때 final 필드를 선언하고, 그냥 가만히 있으면 에러 발생. (반드시 초기화를 해서 마지막 값을 지정해주어야 함.)

public class Person {
	
	final String nation = "대한민국"; 
	String name;
	int age;

}

public class Person {
	
	final String nation = "대한민국"; 
	final String name;
	int age;

	//생성자를 이용해서 초기화.
	public Person(String name) {
		this.name = name;
	}

}

• final 필드에 직접 초기화 하는 방식 뿐만 아니라, 객체 생성 시 동시 초기화 할 수 있도록 생성자에 필드 초기화 로직을 작성할 수 있음.

public class Main {
	
	Person p = new Person("김철수");
	p.nation = "미국"; //에러
	p.name = "김마이클"; //에러
}

17 - 2. final method

• final이 붙은 메서드는 오버라이딩을 막는다.

public class Parent {

	void method1() {}
	void method2() {}
	final void method3() {}

}

public class Child extends Parent {

	@Override
	void method1() {
		// TODO Auto-generated method stub
		super.method1();
	}

	@Override
	void method2() {
		// TODO Auto-generated method stub
		super.method2();
	}

//	void method3() {
//		System.out.println("오버라이딩 해야지~");
//	} (x) final 메서드는 오버라이딩을 막습니다. (주는 대로 써라~)

}

15 - 3. final class

• 클래스 선언 시, final을 사용하면 그 클래스는 상속이 불가능.

public final class Parent {
	...
}

• 상속 자체가 막히며 코드 에러가 발생함.
• final 클래스는 자식 클래스를 가질 수 없고, 오직 외부에서 직접 객체 생성을 통해서만 사용할 수 있음.

15 - 4. 상수

고정된 불변의 값.
모든 객체가 해당 값을 공유할 수 있는 전역성을 가져야 하고, 동시에 값이 변하지 않는 불변성을 가져야 함.
-> static 과 final의 성질을 둘 다 갖고 있어야함.

public class Earth {
	static final double RADIUS = 6400;
	
	static final double SURFACE_AREA;
	
	static {
		SURFACE_AREA = RADIUS * RADIUS * Math.PI * 4;
	}
}

• 상수는 다른 일반 변수와의 차이를 위해 모든 글자를 대문자로 선언.
• 만약 뛰어쓰기를 할려면, _를 이용하여 연결해준다.

16. 다형성

하나의 객체가 여러가지 타입으로 사용되는 것을 의미.
상속을 전제 조건으로 함. 
다형성을 위해, 자바는 자식 클래스가 부모 클래스의 타입을 가질 수 있도록 허용함.

class A {}
class B extends A {}
class C extends A {}
class D extends B {}
class E extends C {}

public class Basic {
	//다형성을 적용하지 않았을 때
	A a = new A();
	B b = new B();
	C c = new C();
	D d = new D();
	E e = new E();

	//다형성을 적용했을 때
	A v1 = new B(); //클래스 타입 B -> A타입으로 자동 형 변환(promotion)
	A v2 = new C();
	A v3 = new D();
	A v4 = new E();
}

• 다형성이 없을 때는 참조 변수의 타입을 객체에 맞게 작성해 주어야 한다.
• 하지만 다형성이 적용이 되었다면, 최상위 부모인 A 타입에 모두 객체의 주소값이 저장될 수 있음.

16 - 1 . 다형성의 이점

Dog dog = new Dog();
Cat cat = new Cat();
Duck duck = new Duck();

Animal[] animals = {dog, cat, duck};

• 각자 다른 3개의 자식 객체를 하나의 배열에 넣고 싶다.
• 배열은 동종 모음 구조이기 때문에 같은 타입 끼리만 배열에 모여 있을 수가 있는데 배열을 부모 타입으로 선언했더니, 모든 자식의 객체가 하나의 배열로 모여있어 쉽게 관리할 수 있음.

//매개변수에 다형성이 적용되어 있지 않다면
//메서드 오버로딩을 통해 일일히 구현 해 주어야함.
public void makeSound(Dog dog) {...}

public void makeSound(Cat cat) {...}

public void makeSound(Duck duck) {...}

////////////////////////////////////////////////////////////////

//매개변수에 다형성을 준 경우
public void makeSound(Animal animal) {
	animal.sound(); //dog, cat, duck 모두 sound() 호출 가능.
}

• 만약 매개변수에 다형성을 사용하지 않는다면, 일일히 타입이 다른 메서드를 선언해야 한다.
• 하지만 다형성을 적용함으로써 굳이 여러 개의 메서드를 선언할 필요 없이 하나의 메서드 만으로 여러 개의 객체를 받아 처리할 수 있음.

public Dog returnDog() {...}

public Cat returnCat() {...}

public Duck returnDuck() {...}

//////////////////////////////////

public Animal returnAnimal(String name) {
	if(name.equals("강아지")) {
		return new Dog();
	} else if(name.equals("고양이")) {
		return new Cat();
	} else if(name.equals("꽥꽥이")) {
		return new Duck();
	}
}

• 다형성을 리턴 타입에 적용하여, 해당 부모 타입에 맞는 모든 자식 객체가 리턴 될 수 있음.

16 - 2. 타입 캐스팅

public class Parent {
	public int n1;

	void method1() {...}
	void method2() {...}
}

public class Child extends Parent {
	public int n2;

	@override
	void method2() {...}
	void method3() {...}
}

//////////////////////////////////////////////////////////////////////

public class Main {
	Parent p = new Child();
	p.n1 = 1;
	//p.n2 = 2; (x)
	
	p.method1();
	p.method2();
	//p.method3(); (x)
}

• 위 코드에서 부모가 물려준 것들과 자식이 오버라이드 한 메서드까지는 정상적으로 호출이 되었지만, 자식 고유의 속성 및 기능을 사용하지 못하는 모습을 볼 수 있음.
• 이러한 이유는 부모의 정보로는 자식이 어떻게 개념을 확장 했는지에 대한 정보를 얻을 수 없기 때문이다.
• 그래서 부모타입의 변수를 자식 타입으로 형변환을 진행해야 함.

Child c = (Child) p;
c.n2 = 2;
c.method3(); //주소값을 자식 타입으로 내리니까 속성 및 기능 사용 가능.

16 - 3. instanceOf 

public void sayHello(Animal ani) {
	if(ani instanceof Dog) {
		System.out.println("강아지가 꼬리를 흔들어요.");
	} else if(ani instanceof Cat) {
		System.out.println("고양이가 나를 못 본척 해요");
	} else if(ani instanceof Duck) {
		System.out.println("오리가 꽉꽉 울어요.");
	}
}

• 위 메서드는 매개변수에 다형성이 적용되어 있음.
• 하지만 어떤 객체냐에 따라 다른 인사법을 가지고 있기 때문에, 객체 구분이 필요함.
• 이 때, instanceof 키워드를 통해, 해당 객체가 어떤 타입을 가지고 있는 지를 물어 볼 수 있음.

17. 추상 클래스 & 추상 메서드

17 - 1. 추상 메서드

메서드 선언만 되어있고 메서드의 바디가 없는 메서드.
즉, 틀만 구축하고 알맹이가 없는 껍데기 메서드이다.
추상 메서드는 추상 클래스에서만 선언할 수 있음.

17 - 2. 추상 클래스

추상 메서드가 하나 이상 포함되어 있는 클래스.
미완성 된 메서드를 포함되었기 때문에 스스로의 객체를 생성할 수 없다.
반드시 추상 클래스를 상속받아 추상 메서드를 구현한 자식 클래스를 통해 생성해서 사용해야 함.

• 추상 개념을 사용하는 이유

1. 다형성 구현 목적이 뚜렷해 진다. (자식 클래스 쪽에서 구체적인 구현을 담당하게 함으로써 유지보수성을 더 높일 수 있음.)
2. 코드 디자인 패턴 적용 (강제화를 시킬 수 있는 성격으로 틀에 잡힌 코드 패턴을 강제하기 쉬움.)
3. 코드 재사용성을 통한 객체지향적 프로그래밍

18. 인터페이스

구현하고자 하는 클래스에 동일한 목적 하에 동일한 기능을 수행하게끔 강제하는 클래스의 틀 역할을 하는 것.

18 - 1. 인터페이스의 문법

public interface Animal {
		//int i;  (x)
		//public Animal() {} (x)
		public static final String name = "Animal";
		void move();
}

public interface Mammals {
	void feeding();
}

public interface Bird extends Animal {
	void fly();
}

• 인터페이스는 추상 메서드 밖에 가질 수 없음.
• 애초에 객체를 생성하기 위한 개념이 아니기 때문에 어떠한 데이터도 저장할 수 없음.
• 생성자는 선언될 수 없고, 메서드 또한 실체가 없는 추상 메서드만 선언 가능.
• 단, 상수는 선언 가능 (static 메서드도 선언할 수 있음.)
• 인터페이스들 끼리 상속이 가능할 뿐만 아니라, 다중 상속도 가능. (껍데기들끼리 물려주는 것이기 때문에)

18 - 2. 구현

• 구현의 키워드는 상속의 키워드인 extends가 다르게, implementsfmf 사용.
• 인터페이스가 가지고 있는 추상 메서드를 반드시 구현해야함.
• 인터페이스는 동시에 여러 개 구현할 수 있음.
• 다형성에서 클래스 타입들 보다 훨씬 유연하게 동작.
• 구현 클래스는 자신이 구현한 인터페이스 타입을 모두 가질 수 있음.

18 - 3. 인터페이스와 추상 클래스의 차이

• 인터 페이스는 추상 클래스보다 더 추상화 된 개념.

1. 추상 클래스는 추상 메서드와 일반 메서드 둘 다 가질수 있는 반면에, 인터페이스는 추상 메서드와 상수 필드만을 가질 수 있음.
2. 인터페이스는 다중 상속이 가능하여, 여러 개의 인터페이스를 구현하는 것이 가능.

• 인터페이스는 동일한 구현 및 동일한 동작을 강제하는데 초점이 맞춰져 있다.
• 즉, 인터페이스는 다형성과 유연성을 제공하는 데 주로 사용하고, 추상 클래스는 코드의 재사용성과 확장성을 고려할 때 사용한다.

• 전반적인 느낀 점 (일주일 동안 한 일)

- 2월 4주차에는 본격적인 자바의 문법에 대해 배웠다. 부트캠프에 들어오기 전 자바 문법을 조금 공부해서 그런지, 수업을 따라오는 것에는 문제가 없었다. 하지만 수업을 계속 들어보니 이해가 가지 않은 부분 또는 처음 봤던 부분들이 계속해서 보여, 내가 공부한 지식에 더 디테일한 부분을 보충해야겠다고 생각했다.

• 좋았던 점 (좋았거나 내가 잘했던 점)

- 마치 구멍을 메꾸는 것처럼, 수업을 통해 내 빈약했던 자바 지식을 채울 수 있어서 매우 좋았다.

또한 이미 알던 내용이더라도 한 번 더 복습할 수 있는 계기가 되어서 좋았다.

• 아쉬웠던 점

- 아직 모르는 개념들이 있어서 조금 더 보충이 필요할 것 같다. (다형성, this() 등등....)

물론 이와 관련된 알고리즘 문제의 접근도 아직 힘든 건 덤.

• 개선할 점

- 자바에서 모르는 부분이나 지식을 좀 더 보충하기.

• 다음 주 계획

- 본격적인 알고리즘 풀이 시작

- 어학 공부 슬슬 시작하기.

- 지난번에 수업했던 git/git_hub 그리고 자바 복습

2025년 2월 18일, 첫 수업부터 금요일까지 배운 내용과 중요한 점/새로 알게된 점 그외의 것을 적어보도록 하겠다.

 배운 내용

1. Git

Git은 소프트웨어 개발에서 사용되는 DVCS(클라이언트가 서버의 파일을 복제함으로 네트워크에 접근할 수 없는 상황일지라도 개발을 계속 진행할 수 있는 것) 중 하나로, 소스 코드 관리에 주로 사용되고 있음.

- 다른 개발자와의 협업을 하거나, 코드의 안정성 유지, 배포 관리, 코드 리뷰 및 추척이 가능하다는 특징이 있음.

- 또한, 인터넷 연결을 해야 동작하는 GitHub와 달리 Git은 오프라인 상태에서도 사용이 가능함.

•  명령어

2. Git Repository

Git Repository는 git에 의해 관리되는 프로젝트 디렉터리.
이 안에는 프로젝트의 모든 파일, 각 파일의 수정 이력을 담은 정보가 포함되어 있음.

이 것은 프로젝트의 상태를 특정 시점으로 되돌리거나 다른 브랜치로 전환하는 등의 기능을 수행함.

(쉽게 설명하면, 게임할 때 세이브를 하는 그런 느낌이라고 보면 될 것 같다.)

• 요소

1. Working Directory : 현재 작업 중인 프로젝트의 파일들이 위치하는 디렉토리.
2. Staging Area (Index) : commit하기 위한 파일을 저장하는 영역 (add 명령어를 이용), 이 영역을 통해, 원하는 파일만 커밋할 수 있음.
3. Repository : git의 메타데이터와 객체 데이터베이스를 저장하는 디렉토리. (commit 명령어를 이용)

• Local Repository 생성하기

$ git init

코드 실행 시, 작업 중인 디렉토리에 Git 레포지토리를 생성.

(숨김 파일로 처리되어 있음, 이 파일을 보기 위해서는 Mac 기준으로 Shift + command + .을 이용해 볼 수 있음.)

또한, 명령어 뒤에 디렉토리 이름을 추가하면 해당 이름의 새 디렉터리를 생성 후 새로운 Git 레포지토리 생성

이 명령어는 최초 1번만 입력해야하고, git init을 했던 폴더에 하위 폴더에 또 다시 생성하지 않도록 주의를 요해야 한다.

• Git Repository 상태 확인 

$ git status

• 변경된 파일 또는 파일들을 Index 영역에 추가

$ git add filename

* 만약 디렉터리의 모든 변경사항을 Index 영역에 추가하고 싶을 경우에는 아래 코드를 사용하면 된다.

$ git add .

• Index 영역에 추가된 변경 사항들을 커밋 (이 때, 변경사항에 대한 설명을 담은 메시지를 함께 작성해주어야 함.

$ git commit -m "커밋 메시지"

•   가장 최근에 올린 커밋의 메시지를 수정 

$ git commit --amend or $ git commit -m "수정할 메시지 입력"

• 커밋을 생성한 후에 추가로 커밋에 포함시키려는 파일을 넣기 (이 때, 해당 파일은 스테이징 상태에 있어야 한다.)

$ git add <커밋에 추가할려는 파일>
$ git commit --amend

3. Git ignore

.gitignore 파일은 Git에서 특정 파일 또는 디렉토리를 버전 관리에서 제외할 때 사용한다.
주로 개인 정보가 담겨있는 파일들을 지정하고 제외시킨다.

- 사용 방법

.gitignore 파일에서 사용할 수 있는 패턴

• 주의사항

- .gitignore파일은 이미 커밋된 파일에는 영향을 미치지 않기 때문에 처음부터 만들어야 한다.

3. Branch

브랜치(Branch)란, 코드의 특정 버전을 가리키는 포인터와 같은 것.

• 브랜치를 사용하면 동일한 소스코드에 대해 동시에 여러가지 작업을 수행할 수 있고, "main"브랜치의 안정성을 유지하면서, 다른 브랜치에서는 실험적인 변경 또는 새로운 기능을 추가할 수 있어 필수적인 요소이다.

• HEAD

Git의 HEAD는 현재 작업 중인 커밋을 가리키는 포인터. 다른 말로, "현재 Git이 어디를 바라보고 있는지"로 표현할 수 있다. 기본적으로 HEAD는 항상 작업트리의 최상단/ 가장 최근의 커밋을 가리킴.

• 기능

1. 어떤 커밋이 현재 작업 중인지를 식별하는 기능
2. 새로운 커밋이 생성될 때, HEAD는 자동으로 새 커밋을 가리킴.
3. HEAD는 상대 참조를 이용하여 커밋 트리를 쉽게 탐색할 수 있게 함.

• 관련 명령어

• 브랜치 이동하기

$ git switch <이동하고자하는 브랜치 이름>

• 나의 모든 브랜치 목록 보기

$ git branch

• 브랜치 생성하기

$ git branch <생성하고자하는 브랜치 이름>

• 새로운 브랜치를 생성하면서, 즉시 이동하기

$ git switch -c <브랜치 이름>

• 브랜치 삭제 (브랜치가 이미 병합되어있을 때.)

$ git branch -d branch_name

• 만약 병합이 아닌 브랜치를 강제로 삭제하고 싶다면, 아래 코드를 이용.

$ git branch -D Branch_name

• 원격 브랜치 삭제

$ git push origin --delete branch_name

• 현재 브랜치 이름 변경

$ git branch -m new_branch_name

• 다른 브랜치 이름 변경

$ git branch -m old_branch_name new_branch_name

3. Merge

Metge란, 여러 브랜치에 분산된 코드 변경 사항을 하나의 브랜치로 합치는 과정을 말한다.

• 기능 브랜치 병합(3-way merge) : 두 브랜치가 공통 조상에서 다르게 발전한 경우에 사용하는 병합 전략. 단, 충돌이 발생하는 경우, 사용자가 직접 해결해야 하는 복잡한 상황이 발생할 수 있음.

• 빠른 포워드 병합(fast-forward merge) : 하나의 브랜치에서만 변경 사항이 있고, 다른 브랜치는 변경되지 않은 경우에 발생. 이 경우 git은 단순히 브랜치 포인터를 앞으로 이동. Git의 강력한 기능 중 하나로, 복잡한 병합 작업 없이 브랜치를 간결하게 병합할 수 있음.

• Conflict

충돌은 2개 이상의 변경 사항이 merge과정에서 서로 충돌할 때 발생하는 문제.
주로 여러 사람이 동시에 동일한 파일의 같은 부분을 변경했을 때, 자주 발생함.

• 이러한 충돌은 git 스스로 해결할 수 없으므로, 사용자에게 직접 해결을 요청함.

• Git Conflict Marker

만약 충돌이 발생할 경우, git은 Conflict marker를 사용하여, 사용자에게 어디에 문제가 발생했는지 알려줌.

• 예시

<<<<<<< HEAD // 현재 브랜치의 변경 사항이 시작하는 지점
The quick brown fox...
======= // 다른 브랜치의 변경 사항이 시작하는 지점
The quick blue fox...
>>>>>>> new_branch // 다른 브랜치의 변경 사항이 끝나는 지점

• 해결 방법

1. git status 명령어를 이용하여 충돌이 발생한 파일 확인.
2. 충돌이 발생한 파일을 열고 충돌 마커를 찾는다.
3. 각 충돌에 대해 어떤 변경 사항을 유지할지 결정하고 수정한다. 그 후에 충돌 마커를 모두 제거.
4. 파일을 저장하고 스테이징 후, 커밋한다.

4. Git diff

diff는 작업 트리와 Index 영역 사이의 차이를 보여주거나, 두 커밋 사이의 차이를 보여주는 명령어이다.
주로 코드 리뷰, 디버깅, 병합 충돌 해결 등의 다양한 상황에서 사용할 수 있다.

• 작업 디렉토리와 index영역 사이의 차이점을 보고 싶다면 아래 코드를 이용하면 된다.

$ git diff

• 작업 디렉토리와 마지막 커밋 사이의 차이점을 보고 싶을 때.

$ git diff HEAD

• 이번에는 작업 디렉토리가 아닌, index영역과 가장 최근 커밋 사이의 차이점을 보고 싶을 때.

$ git diff --staged <filename>

• 2개의 브랜치 간에 발생한 변경 사항을 확인 또는 커밋

$ git diff branch1..branch2 // 2개의 브랜치 간에 발생한 변경 사항 확인
$ git diff commit1..commit2 // 2개의 커밋 간에 발생한 변경 사항 확인

5. Git Stash

stash란, git에서 제공하는 일시적인 작업 저장소이다. 이를 사용하면 아직 완료되지 않은 변경 사항을 일시적으로 저장이 가능하고, 나중에 다시 불러와 작업을 이어갈 수 있음.

• 주요 기능

1. 현재 브랜치에서 작업하던 중 다른 브랜치로 전환해야할 때 stash를 사용함으로써, 브랜치의 작업 상태를 저장하고 깨끗한 작업 디렉토리로 다른 브랜치로 이동할 수 있음.
2. 코드 변경 사항이 문제를 일으키고 있는지 확인하기 위해, stash를 사용하여 변경사항을 일시적으로 제거하고 코드의 이전 상태를 테스트할 수 있음.
3. 중요하지 않거나, 아직 커밋하고 싶지 않은 변경 사항을 일시적으로 보관하고 필요시, 다시 불러올 수 있음.

• 관련 명령어

• 변경 사항을 새로운 stash로 저장 (작업 디렉토리는 이전 커밋 상태로 되돌림.)

$ git stash
$ git stash save "원하는 메시지를 포함시킬 수 있음."

• 가장 최근의 stash를 적용하고, 해당 stash를 삭제.

$ git stash pop

• 가장 최근의 stash를 적용. (pop과 달리, stash는 그대로 유지되기 때문에 동일한 stash를 여러번 적용하고 싶을 때 유용함.)

$ git stash apply

• stash 스택을 보고 싶을 때.

$ git stash list

• 만약 여러개의 stash가 존재할 때, 원하는 것을 선택해서 부르기.

$ git stash apply stash@{원하는 id}

• stash 스택에서 하나의 stash 제거. (기본적으로 가장 최근의 stash 제거 또는 id를 명시해서 선택 삭제가 가능함.)

$ git stash drop // 최근의 stash 삭제
$ git stash drop stash@{1} // 원하는 stash 삭제

• stash 스택에 있는 모든 stash를 제거.

$ git stash clear

6. Detached HEAD

특정 브랜치가 아닌 커밋에 직접 체크아웃한 상태를 나타내는 말.

• 기능

1. 단순히 HEAD를 분리시킨 상태로 이전 커밋의 파일들을 돌아볼 수 있음.
2. git switch -c <new_branch> 명령어를 이용하여, 현재 커밋을 기반으로 새 브랜치를 생성할 수 있음.
3. git stash를 사용하여 변경 사항을 저장한 다음, 브랜치로 체크 아웃할 수 있음. 이후에 해당 변경 사항을 다시 불러와 작업 가능

* 주의할 점은 Detached HEAD 상태에서의 변경 사항은 참조되지 않는 커밋이 되고, 시간이 지나면 git의 GC에 의해 제거될 수 있으므로, 작업 내용을 유지할려면 적절한 브랜치에 체크인 하는 것이 중요.

• 관련 명령어

$ git checkout 해당커밋의해시 // 해당 커밋으로 HEAD가 이동
$ git switch <branch_name> or git switch - // 단순히 둘러보기만 하고 원래 브랜치로 되돌아가기
$ git switch -c <branch_name> // HEAD가 분리된 상태로 새 브랜치로 출발하기
$ git checkout HEAD~Number // 현재 HEAD에서 N 단계 이전의 커밋으로 체크아웃
$ git switch -c <new_branch> HEAD~N // 현재 HEAD의 N 단계 이전 커밋으로 새 브랜치를 생성하고 체크아웃

7. restore

작업 디렉토리나 인덱스의 변경 사항을 특정 커밋의 상태로 되돌리는데 사용되는 명령어.
예기치 않게 수정한 파일을 원래 상태로 되돌리거나, 커밋하지 않은 변경 사항을 제거하는데 사용.

• 관련 명령어

$ git restore --staged <file> // 스테이징한 파일을 언스테이징하기.
$ git restore <file> // 작업 디렉토리의 파일을 복원
$ git restore --source <commit or branch> <file> // 지정된 커밋 또는 브랜치의 상태로 파일 복원

8.  reset

현재 HEAD를 특정 커밋으로 이동시키는데 사용되는 명령어. 
주로 이전의 상태로 되돌리고 싶을 때 사용됨.

• 관련 명령어

$ git reset commit // 현재 브랜치의 HEAD가 지정된 커밋으로 이동. (지정된 커밋 이후 모든 커밋은 현재 브랜치에서 보이지 않게됨.)
$ git reset --hard commit-hash // 영구적으로 해당 브랜치에서 커밋을 제거하는 강력한 명령어
$ git reset --hard ORIG_HEAD // reset를 잘못 실행 시, 취소할 수 있는 명령어

8.  revert

git에서 특정 커밋을 취소하는 데 사용되는 명령어.
단순히 이전 상태로 되돌리는 것이 아닌, 취소하려는 커밋의 변경 사항을 반대로 적용하는 커밋을 생성.
(히스토리를 유지하면서 변경 사항을 되돌리기 때문에, 공동 작업에서 유용한 명령어이다.

• 관련 명령어

$ git revert commit_hash // 주의할 점은 내가 취소하고 싶은 커밋의 해시를 적는 것.

9.  git hub

Git을 사용하는 프로젝트를 지원하는 웹 기반 호스팅 서비스.
즉, 코드를 온라인으로 저장하고 관리하며, 여러 사람이 동시에 작업을 할 수 있다.

• 주요 특징 및 기능

1. 코드를 클라우드에 저장하고 언제든지 접근이 가능하다. 또한, 다른 사용자와 코드 공유를 할 수 있음.
2. 프로젝트의 과거 시점 또는 변경 사항을 비교할 수 있음.
3. 코드를 공유하고 다른 사용자와 협업을 진행할 수 있음.
4. 버그 추적, 기능 개발, 작업 할당, 프로젝트 진행 상황 관리 가능.
5. 다양한 개발 도구와 연동이되고, 사용자 정의 스크립트 또는 앱을 통해 기능 확장이 가능.

• 관련 명령어

• 원격 저장소 푸시 (원격 저장소는 인터넷 또는 네트워크에 위치한 저장소로 로컬 저장소의 변경사항을 원격 저장소로 푸시할 수 있다.)

$ git push 별칭 로컬저장소의_브랜치이름

• git clone (원격 저장소의 내용을 복제하여 로컬에 새로운 디렉토리를 생성하는 것)

$ git clone <저장소 주소>

• 원격 저장소를 추가

$ git remote add 별칭 원격저장소_주소 // 보통 별칭은 origin으로 설정함.

• 원격 저장소 삭제

$ git remote remove 별칭

• 원격 저장소 별칭 변경

$ git remote rename 기존별칭 새별칭

• 원격 저장소의 정보 확인

$ git remote show 별칭

• 추가된 원격 저장소의 목록 확인

$ git remote -v

• 원격 저장소에 있는 모든 브랜치가 목록으로 출력

$ git branch -r

• 브랜치 확인하기

$ git branch -a

9.  git fetch, git pull

원격 저장소에서 정보를 가져오는 명령어들. 

• 관련 명령어

1. fetch (원격 저장소의 변경 사항을 로컬로 가져오는 명령어, 원격 저장소의 변경 내역을 확인할 수 있음. 병합 X)

$ git fetch remote-name

2. pull (fetch와 달리, 원격 저장소의 변경 사항을 다운로드하고, 현재 브랜치에 병합시킴.)

$ git pull remote-name branch-name

* pull을 실행하면 충돌이 발생할 수도 있는데, 수동으로 확인하고 충돌을 해결하면된다.

10.  Collaborator

git hub에서 프로젝트는 repository형태로 관리되는데, repository의 소유자 또는 관리자는 다른 git hub 사용자를 Collaborator로 초대할 수 있음. 즉, collaborator는 해당 프로젝트에 기여하는 사람들을 말함.

• 권한

1. collaborator는 소유자와 동일하게 저장소에 직접 푸시할 수 있음.
2. 저장소의 이슈를 열고 닫을 수 있음. (이슈는 프로젝트의 오류 보고/기능 추가 요청/개선 사항을 관리하는 것에 유용함.)
3. collaborator는 다른 사람들이 제출한 코드 변경사항을 검토 및 결정하는 풀 리퀘스트를 수락하거나 거절할 수 있음.
4.  

11.  README.md

GitHub repositiry의 시작점. 이 파일 안에는 일반적으로 프로젝트에 대한 정보와 사용 방법을 소개하는데 사용.
보통 Markdown이라는 경량 마크업 언어로 작성됨.

12.  Pull Request (PR)

개발자가 자신이 작업한 브랜치를 원격 저장소의 타켓 브랜치와 병합하는 것을 제안할 때 사용하는 기능.

• merge하는 방식

1. Create a merge commit : 일반 merge와 동일. git history에서 해당 PR에 대해 상세하게 알 수 있지만, 프로젝트의 규모가 커질수록 히스토리를 알아보기가 힘들어진다.
2. Rebase merge : Merge할 branch의 커밋 내역들을 그대로 옮기는 것. 히스토리를 깔끔하게 볼 수 있지만, 여러개의 커밋을 rebase merge를 했는데 충돌이 발생한다면 병합하려는 모든 커밋에서 충돌이 발생함.
3. squash merge : rebase하되, 병합할 커밋들을 하나의 커밋으로 뭉친다. 브랜치를 깔끔하게 유지하면서 자잘한 커밋을 제거 및 의미있는 커밋만으로 히스토리를 이룰 수 있는 장점이 있다.

13.  Fork

다른 사람의 원격 저장소를 자신의 깃허브 계정으로 복제하는 것.

• 특징

1. 프로젝트를 자신의 계정으로 가져와서 새로운 기능을 추가하거나 버그를 수정할 수 있음.
2. 자신이 수정한 내용을 원본 저장소에 반영해달라고 PR을 보낼 수 있음.

14. JAVA

1995년 발표된 객체지향 프로그래밍 언어

• 특징

1. 개발자 친화적인 언어로 개발자가 반드시 필요하지 않다고 생각한 부분은 스스로 처리한다.
2. 숫자, 문자, 논리형 등의 기본 타입을 제외하고는 객체로 이루어진 객체 지향적 언어이다.
3. 컴파일 언어이면서, 인터프리터 언어이다.
4. 문법이 엄격해서 안전하다.

• 주석 (Comment)

- 프로그램 소스코드에 프로그래머의 의견 또는 설명을 적기 위해 사용하는 것.

- 프로그램 수행에 영향을 미치지 않기 때문에, 어디에든 작성이 가능함.

- 예시

public class Main {
    public static void main(String[] args) {
        
        //한줄 주석(라인 주석)
        /*
              블록 주석입니다.
              블록 내의 모든 텍스트가 주석으로 처리됨.
        */
    }
}

• 변수 (Variable)

• 데이터가 저장되는 곳에 이름을 붙여 놓은 것.
• 자주 사용할 값 또는 복잡한 연산의 결과값 또는 사용자의 입력값 등등의 내가 따로 보관해 두었다가 나중에 꺼내에 사용하고 싶은 값들을 담아 놓는 공간.
• 이 때, 변수에는 값을 하나 당 하나밖에 넣지 못한다. 만약 이미 값을 가지는 변수에 새로운 값을 할당 시, 기존 값이 밀려나감.

// 변수 선언 (타입 지정)
int number;

// 변수의 초기화
number = 100;

System.out.println(number); //70

// 위 두 가지 과정(선언과 초기화)을 동시에
int number = 100;
number = 20; // 값 변경 시, 기존 값 소멸
System.out.println(number); // 20

// 대입 연산자 기준 좌측이 영역, 우측이 값
int num = number * 40;

String name = "이순신"; //문자열 타입 String
//String nick = 5555; (x) 타입에 맞는 값을 할당하기.

• 자바 식별자

// 1. 식별자는 대/소문자를 철저하게 구분한다.
        int age = 35;
        // int age = 40; (x)
        int Age = 40;

        // 2. 식별자는 숫자로만 이루어지거나 시작하면 안됨
        //int 700 = 365; (x)
        //int 7number = 7; (x)

        int number7 = 7;
        int num7ber = 7;

        //3. 식별자에 공백 못들어간다.

        //int my Birth Day = 19901202; (x)
        int mybirthday = 19901202;
        int myBirthDay = 19901202; //camel case

        //4. 식별자는 특수기호는 $,_뿐이다.
        // 사용을 권장하지는 않습니다. 이미 사용하기로 된 곳이 있음
        String $hello_ = "안녕";

        //5. 키워드는 식별자로 사용할 수 없음
        //키워드는 이미 어떤 기능을 내포하고 있는 단어

        //String class = "8반"; (x)
        String Class = "8반"; // 권장하지 않음
        String classNumber = "8반";

        //6. 한글이나 한자같은 식별자는 문법적으로 허용하나, 권장하지는 않음.
        int 숫자 = 10;
        int sagwa = 20; // 권장하지 않음

• 자바의 정수형 데이터 타입

1. byte : 1byte 크기의 정수형.
2. short : 2byte 크기의 정수형.
3. int : 4byte 크기의 정수형.
4. long : 8byte 크기의 정수형.

byte b = 127;
short s = 32767;
int i = 2147483647;
long l = 2147483648L; //정수형 기본 타입이 int 이기 때문에 뒤에 L을 붙여 long으로 표현.

• 자바의 실수형 데이터 타입

1. float : 4byte의 실수형이며, 소수점 이하 7자리까지 표현이 가능.
2. double : 8byte의 실수형, 소수점 이하 15자리까지 표현이 가능.

float f = 1.234567F; //실수 리터럴이 double이기 때문에 F를 붙여 float으로 인식.
double d = 1.234567;

• 자바의 논리형 데이터 타입

• boolean : 1bit의 크기를 가지고, true/false 이외에는 어떠한 값을 가지지 못한다.

boolean b1 = true;
boolean b2 = false;

//boolean b3 = True; (x) 
//boolean b4 = False; (x)
//boolean b5 = 0; (x) -> 타 언어는 이러한 논리해석을 허용하지만 자바는 허용 x

• 자바의 문자형 데이터 타입

1. char : 단일 문자를 표현할 수 있는 데이터 타입으로 홀따음표(' ')안에 문자를 한 개만 넣어서 표현. (2 byte 크기)

char c1 = 'A'; //단일문자 A를 저장하라 했지만 실제 컴퓨터는 A를 저장하지 못함.
char c2 = 65;  //그래서 이렇게 유니코드 문자표의 번호를 저장함.

//출력 결과는 동일한 것을 확인할 수 있음.
System.out.println(c1); //A
System.out.println(c2); //A

* String : 단일 문자들이 쭉 나열되어 있는 형태. 쌍 따옴표(" ")를 통해 여러 문자들을 한번에 묶을 수 있다. 여기서 주의할 점은 String은 기본 데이터 타입이 아닌, 클래스 타입이다.

String s1 = "my dream ";
String s2 = "is a programmer";
System.out.println(s1);
System.out.println(s2);

System.out.println(s1 + s2); //my dream is a programmer

//문자열과 다른 데이터 타입 간의 연산
//결과는 무조건 문자열의 덧셈 연산과 같습니다.
System.out.println("-------------------------------");

System.out.println(100 + 100); //200
System.out.println("100" + "100"); // "100100"
System.out.println("100" + 100); // "100100"
System.out.println(3.14 + "hi"); "3.14hi"

int month = 10;
int day = 13;

//내 생일은 10월 13일 입니다.
System.out.println("내 생일은 " + month + "월 " + day + "일 입니다.");

• 형 변환

1. 자동 형 변환

• 큰 데이터 타입에 작은 데이터 타입 값이 들어갈 때는 자동으로 형 변환이 발생. (값의 손실이 없기 때문에)

//자동 형변환 대상의 공통점: 작은 쪽이 큰 쪽에 맞춰져서 연산이 진행됨.
//받아주는 쪽의 타입이 표현할 수 있는 범위가 훨씬 크기 때문에 연산 결과에 문제가 없음.

byte b = 10;
int i = b; //타입 불일치! b의 타입을 int로 자동 형 변환해서 연산을 진행.
System.out.println(i);

char c = 'A';
int j = c; //c의 타입을 int로 변환하면서 c가 가진 'A'가 문자표 번호 65로 변환됨.
System.out.println("A의 문자 번호: " + j);

int k = 500;
double d = k; //k의 타입을 double로 변환하면서 소수점을 표현할 수 있게 값이 변환됨.
System.out.println(d);

//서로 타입이 다른 기본 데이터의 연산 시에는 
//데이터 타입이 큰 쪽에 작은 쪽이 맞춰져서 
//자동으로 형 변환이 진행된 뒤에 연산이 진행됨.
char c = 'B';
int i = 2;
int intResult = c + i; //char가 int로 자동 형 변환됨. int 변수에는 그냥 들어간다.
char charResult = (char) (c + i); //결과가 int인데 char로 들어가려 하니 명시적 형 변환 진행.
System.out.println(intResult);
System.out.println(charResult);

2. 명시적 형 변환

• 자동 형 변환과는 다른 상황. 크기가 큰 데이터 타입을 작은 타입으로 내려야하기 위해서는 강제 변환을 해야한다.
• 괄호 안에 변환하고자 하는 타입을 작성해야함. ex) int num = (int) num2;
• 변환하는 과정에서 overflow 또는 값 손실이 발생할 수 있어, 신중하게 결정해야함.

//값의 손실이 따로 없는 경우. 72는 int와 char 둘 다 표현 가능한 범위이기 때문.
int i = 72;
char c = (char) i; //i의 타입이 c보다 크다. 자동으로 진행 안됨. 명시적 형 변환 진행!
System.out.println("72의 문자값: " + c);

//값의 손실이 발생하는 경우. int는 소수점을 표현할 수 없다. 
double d = 4.98765;
int j = (int) d; //d의 타입이 j보다 크기 때문에 명시적 형 변환 진행. 이 과정에서 소수점 탈락.
System.out.println(j);

//값이 박살나는 경우
int k = 1000;
byte b = (byte) k; //int를 byte로 변환. 
System.out.println(b); //값이 박살남. 1000은 byte가 표현할 수 있는 범위가 아니다.

//명시적 형 변환이 꼭 필요한 경우는 아니지만 일부러 해 주는 경우
int k = 10;
// k / 4의 결과는 int이기 때문에 소수점 표현이 불가. 
//그래서 k의 타입을 일부러 double로 변환하여 double의 연산을 진행.
//4를 4.0으로 표현해도 좋다. 실수의 기본 타입은 double이기 때문에 double의 연산을 진행.
double d = (double) k / 4; 
System.out.println(d);

• 연산자

변수에 값을 변경하거나 대입하는 등의 작업을 수행해 주는 여러가지 기호들

• 연산자의 종류

• 단항 연산자 : 피 연산자가 하나인 연산자.
• 부호 연산자 : 부호를 표현하는 연산자 ex) +1, -43
• 형 변환 연산자 : 타입을 변환하는 연산자 ex) (int) num
• 증감 연산자 : 변수의 값을 1씩 증가 혹은 1씩 감소시킬 때 사용하는 연산자, 주로 단독으로 많이 사용.

int num1 = 7, num2 = 7;
int result1 = --num1 + 4; //앞에 붙으면 전위 연산. 선 증감 후 연산
int result2 = num2-- + 4; //뒤에 붙으면 후위 연산. 선 연산 후 증감

System.out.println(result1); //10, num1을 먼저 감소시키고 +4를 진행
System.out.println(result2); //11, +4를 먼저 진행하고 num2를 감소시킴

• 논리 반전 연산자 : 단순히 논리값을 반전시킬 때 사용.

boolean flag = false;

System.out.println(!flag); //true

• 이항 연산자 : 피 연산자가 2개인 연산

int a = 5;
int b = 5;

b =+ 3; // b = +3; -> 이건 대입 연산이 아니에요!!! 순서 잘 지키기
System.out.println(b);

a += 3; //a = a + 3 -> 기존의 a에 3을 더한 값을 새롭게 대입하겠다.
System.out.println(a);

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

a -= 4; //4 -> 기존의 a에 4를 뺀 값을 대입해서 저장하겠다.
System.out.println(a);

a *= 6; //24 -> 기존의 a에 6를 곱한 값을 대입해서 저장하겠다.
System.out.println(a);

a /= 5; //4 -> 기존의 a를 5로 나누고 그 몫을 대입해서 저장하겠다.
System.out.println(a);

a %= 3; //1 -> 기존의 a를 3으로 나누고 그 나머지를 대입해서 저장하겠다.
System.out.println(a);

• 산술 연산자 : +, -, /, %, * 등의 연산자. 어떠한 수든 0으로 나누면 에러 발생.
• 대입 연산자 : =을 기준으로 좌항은 영역, 우항은 값의 의미. 대입 연산자에 산술 연산자가 결합된 복합 대입 연산자 (+=, -=, /=, %=)가 있는데, 이것은 기존 값에 누적해서 연산한 값을 대입할 때 사용.
• 비교 연산자 : <, <=, >, >=, ==, !=의 두 값을 비교하는 연산자. 결과는 항상 논리형 타입인 true/false이 출력.

int x = 10, y = 20;
System.out.println(x != y); //true

• 논리 연산자 : &, &&, |, || 등이 있고, 좌항과 우항의 논리값을 연산하여 하나의 논리값을 도출한다.

/*
             # 논리 연산자 (&, &&, |, ||)
             - 좌항과 우항의 논리값을 연산하여 하나의 논리값을 도출합니다.
             1. &, &&: 양쪽 항의 논리값이 모두 true일 경우에만 true가 도출됩니다.
             2. |, ||: 양쪽 항의 논리값 중 한 쪽만 true여도 true를 도출합니다.
             &&, || -> 단축 평가 연산 (short circuit operation)
             - 좌항의 연산 결과가 전체 연산 결과에 영향을 미칠 경우
              우항의 연산을 진행하지 않습니다.
*/
        
int x = 10, y = 20;

System.out.println(x > 10 && (y / 0 == 10)); //false
System.out.println(x > 10 || y < 30); //true

// 우항에 무조건 에러가 나는 식을 작성 -> 좌항에서 전체 결과가 결정되면 우항을 실행하지 않음.
System.out.println(x > 10 && (y / 0 == 10));

• 삼항 연산자 : 피 연산자를 3개 가지는 연산자. 형태는 (논리형 조건식) ? 반환값1(true시 출력) : 반환값2(false시 출력)

int x = 10, y = 20;
		
String result = (x > y ? "x는 y보다 큽니다." : "x는 y보다 작습니다.");
System.out.println(result); // x는 y보다 작습니다.

전반적인 느낀 점 (일주일 동안 한 일)

- 부트캠프에 들어가기전, "수업에 잘 따라올 수 있을까?"라는 막연한 걱정이 있었다.

하지만 강사님의 디테일한 진행과 수업으로 걱정은 싹 사라졌고, 할 수 있다는 자신감이 생겼다.

또한 git/github 및 java 맛보기 느낌으로 배웠는데, 생각보다 괜찮았다.

반면, 항상 느끼는 거지만 강남 출퇴근 시간대는 지옥이다. (그래도 예전에 다녔던 직장도 강남이라 그런지, 아직은 버틸만 하다. 아직은....)

좋았던 점 (좋았거나 내가 잘했던 점)

- git/gitub에 대해 배우고, 이와 관련된 간단한 프로젝트를 수행함으로써, 어떻게 개발자들이 git을 이용하는지 또는 협업할 때 어떻게 하는지에 대한 윤곽이 잡혔다. 이를 바탕으로 앞으로의 협업이나 토이 프로젝트를 진행 시에 많은 도움이 될 것 같아 좋았다.

아쉬웠던 점

- 개념과 이론을 숙지했는데 불구하고 조별과제 진행 시, 머리가 하얘졌다. (머리로는 알겠는데, 몸이 따라주지 않는 느낌이랄까..?)

 개선할 점

- 손에 익히기 위해 계속해서 연습 또 연습!!

(+ 체력관리를 위해 운동 빈도를 늘리는 것도 덤!)

 다음주 계획

- 자바 언어를 활용하여 알고리즘 문제 풀기

- git/github 친해지기