메서드란?

수학의 함수처럼 필요한 기능을 미리 정의해두고 필요할 때마다 호출해서 사용하는 함수의 한 종류

//메서드의 정의
public static int add(int a, int b) { 
    System.out.println(a + "+" + b + " 연산 수행"); 
    int sum = a + b;
    return sum;
}

위와 같은 메서드를 만들면 a+b를 수행하는 함수를 만들 수 있다

메서드 호출

int sum1 = add(5, 10); //add라는 메서드를 숫자 5,10을 전달하면서 호출한다. 
int sum1 = 15; //add(5, 10)이 실행된다. 실행 결과는 반환 값은 15이다.
//sum1에 15 값이 저장된다.

메서드를 호출할 때는 다음과 같이 메서드에 넘기는 값과 매개변수(파라미터)의 타입이 맞아야 한다. 물론 넘기는 값과 매개변수(파라미터)의 순서와 갯수도 맞아야 한다.

호출: call("hello", 20)
메서드 정의: int call(String str, int age)

인수(Argument)

여기서 "hello" , 20 처럼 넘기는 값을 영어로 Argument(아규먼트), 한글로 인수 또는 인자라 한다. 실무에서는 아규먼트, 인수, 인자라는 용어를 모두 사용한다.

매개변수(Parameter)

메서드를 정의할 때 선언한 변수인 String str , int age 를 매개변수, 파라미터라 한다. 메서드를 호출할 때 인수를 넘기면, 그 인수가 매개변수에 대입된다. 실무에서는 매개변수, 파라미터 용어를 모두 사용한다.

매개변수가 없거나 반환 타입이 없는 경우

package method;

 public class Method2 {
     public static void main(String[] args) {
        printHeader();
        System.out.println("프로그램이 동작합니다.");
        printFooter();
    }

    public static void printHeader() {
        System.out.println("= 프로그램을 시작합니다 =");
        return; //void의 경우 생략 가능 
        }
    public static void printFooter() { 
        System.out.println("= 프로그램을 종료합니다 =");
    } 
}

printHeader() , printFooter() 메서드는 매개변수가 없고, 반환 타입도 없다.

• 매개변수가 없는 경우
  • 선언: public static void printHeader() 와 같이 매개변수를 비워두고 정의하면 된다.
  • 호출: printHeader(); 와 같이 인수를 비워두고 호출하면 된다.
    • 반환 타입이 없는 경우
  • 선언: public static void printHeader() 와 같이 반환 타입을 void 로 정의하면 된다.
  • 호출: printHeader(); 와 같이 반환 타입이 없으므로 메서드만 호출하고 반환 값을 받지 않으면 된다.
  • String str = printHeader(); 반환 타입이 void 이기 때문에 이렇게 반환 값을 받으면 컴 파일 오류가 발생한다.

void와 return 생략

모든 메서드는 항상 return 을 호출해야 한다. 그런데 반환 타입 void 의 경우에는 예외로 printFooter() 와 같 이 생략해도 된다. 자바가 반환 타입이 없는 경우에는 return 을 마지막줄에 넣어준다. 참고로 return 을 만나면 해 당 메서드는 종료된다.

반환 타입이 있는 경우

반환 타입이 있으면 반드시 값을 반환해야 한다. 반환 타입이 있는 메서드는 반드시 return 을 사용해서 값을 반환해야 한다.

package method;

public class MethodReturn1 {
    public static void main(String[] args) {
        boolean result = odd(2);
        System.out.println(result);
    }
    public static boolean odd(int i) {
        if (i % 2 == 1) {
            return true;
        }
        /*else {
            return false;
         } //이렇게 해야지 오류가 발생하지 않는다. 
         */ 
    } 
}

이 코드에서 if 조건이 만족할 때는 true 가 반환되지만, 조건을 만족하지 않으면 어떻게 될까? 조건을 만족하지 않 은 경우에는 return 문이 실행되지 않는다. 따라서 이 코드를 실행하면 return 문을 누락했다는 다음과 같은 컴파일 오류가 발생한다. java: missing return statement else문을 통해 return이 수행되어서 오류가 해결된다

• return 문을 만나면 그 즉시 해당 메서드를 빠져나간다.

메서드 호출과 값 전달

자바는 항상 변수의 값을 복사해서 대입한다.

package method;

public class MethodValue1 {
    public static void main(String[] args) {
        int num1 = 5;
        System.out.println("1. changeNumber 호출 전, num1: " + num1); 
        changeNumber(num1);
        System.out.println("4. changeNumber 호출 후, num1: " + num1);
    }

    public static void changeNumber(int num2) { 
        System.out.println("2. changeNumber 변경 전, num2: " + num2); 
        num2 = num2 * 2;
        System.out.println("3. changeNumber 변경 후, num2: " + num2);
    } 
}

실행 결과

1. changeNumber 호출 전, num1: 5 
2. changeNumber 변경 전, num2: 5 
3. changeNumber 변경 후, num2: 10 
4. changeNumber 호출 후, num1: 5

결과적으로 매개변수 num2 의 값만 10으로 변경되고 num1 의 값은 변경되지 않고 기존 값인 5로 유지된다. 자바는 항 상 값을 복사해서 전달하기 때문에 num2 의 값을 바꾸더라도 num1 에는 영향을 주지 않는다.

메서드와 형변환

명시적 형변환

package method;

public class MethodCasting1 {
    public static void main(String[] args) {
        double number = 1.5;
        // printNumber(number); //double을 int에 대입하므로 컴파일 오류.
        printNumber((int) number); //명시적 형변환을 사용하여 double을 int로 변환
    }

    public static void printNumber(int n){
        System.out.println("숫자: " + n);
    }
}

메서드를 호출하는데 인자와 매개변수의 타입이 맞지 않다면 아래와 같은 오류가 발생한다. java: incompatible types: possible lossy conversion from double to int

오류나는 원인

printNumber(number) //number는 1.5 실수
printNumber(1.5) //메서드를 호출하기 전에 number 변수의 값을 읽음
void printNumber(int n=1.5) //int형 매개변수 n에 double형 실수인 1.5를 대입 시도, 컴파일 오
류

오류해결을 위해서는 명시적 형변환을 사용해야 한다.

printNumber((int) number); // 명시적 형변환을 사용해 double을 int로 변환 
printNumber(1); // (double) 1.5 -> (int) 1로 변환
void printNumber(int n=1) //int형 파라미터 변수 n에 int형 1을 대입

자동 형변환

int < long < double 메서드를 호출할 때 매개변수에 값을 전달하는 것도 결국 변수에 값을 대입하는 것이다. 따라서 앞서 배운 자동 형변환이 그대로 적용된다.

package method;

public class MethodCasting2 {
    public static void main(String[] args) {
        int number = 100;
        printNumber(number);
    }

    public static void printNumber(double n){
        System.out.println("숫자: " + n);
    }
}

double형 매개변수에 int를 전달하는 것은 아무런 무리없이 작동한다.

다음과 같이 자동 형변환이 동작한다.

printNumber(number); // number는 int형 100 printNumber(100); //메서드를 호출하기 전에 number 변수의 값을 읽음
void printNumber(double n=100) //double형 파라미터 변수 n에 int형 값 100을 대입
void printNumber(double n=(double) 100) //double이 더 큰 숫자 범위이므로 자동 형변환 적용
void printNumber(double n=100.0) //자동 형변환 완료

메서드를 호출할 때는 전달하는 인수의 타입과 매개변수의 타입이 맞아야 한다. 단 타입이 달라도 자동 형변환이 가능한 경우에는 호출할 수 있다.

메서드 오버로딩

메서드 오버로딩이란?

이름이 같고 매개변수가 다른 메서드를 여러개 정의하는 것으로 오버로딩은 번역하면 과적인데, 과하게 물건을 담았다는 뜻이다. 같은 이름의 메서드를 여러개 정의했다고 이해하면 된다

오버로딩 성공

add(int a, int b)
add(int a, int b, int c)
add(double a, double b)

오버로딩 실패

int add(int a, int b)
double add(int a, int b)

메서드 시그니처(method signature)

메서드 시그니처 = 메서드 이름 + 매개변수 타입(순서) 메서드 시그니처는 자바에서 메서드를 구분할 수 있는 고유한 식별자나 서명을 뜻한다. 메서드 시그니처는 메서드의 이 름과 매개변수 타입(순서 포함)으로 구성되어 있다. 쉽게 이야기해서 메서드를 구분할 수 있는 기준이다. 자바 입장에서 는 각각의 메서드를 고유하게 구분할 수 있어야한다. 그래야 어떤 메서드를 호출 할 지 결정할 수 있다. 따라서 메서드 오버로딩에서 설명한 것 처럼 메서드 이름이 같아도 메서드 시그니처가 다르면 다른 메서드로 간주한다. 반환 타입은 시그니처에 포함되지 않는다. 방금 오버로딩이 실패한 두 메서드를 보자. 두 메서드는 add(int a, int b) 로 메서드 시그니처가 같다. 따라서 메서드의 구분이 불가능하므로 컴파일 오류가 발생한다.

본인의 타입에 최대한 맞는 메서드를 찾아서 실행하고, 그래도 없으면 형 변환 가능한 타입의 메서드를 찾아서 실행한다.

배열이 필요한 이유? 같은 타입의 변수를 하나로 묶어서 사용이 가능하기 때문 배열은 하나의 변수에 여러 데이터를 정리정돈해서 담아두기 위한 자료 구조로, 이를 통해 여러 정보를 효율적으로 다룰 수 있기 때문에 필요하다.

• 중복해서 변수를 선언하지 않아도 되고, 메모리 절약이 가능하다.
• 코딩 코드를 줄일 수 있다.

배열은 같은 타입의 변수를 사용하기 편하게 하나로 묶어둔 것이다.

1. 배열 변수의 선언

int[] foods;

• 배열을 사용하려면 int[] foods; 와 같이 배열 변수를 선언해야 한다.
• 일반적인 변수와 차이점은 int[] 처럼 타입 다음에 대괄호( [] )가 들어간다는 점이다.
• 배열 변수를 선언한다고해서 아직 사용할 수 있는 배열이 만들어진 것은 아니다!
  • int a 에는 정수를, double b 에는 실수를 담을 수 있다. -int[] foods 와 같은 배열 변수에는 배열을 담을 수 있다. (배열 변수에는 10, 20 같은 값이 아니라 배열이라는 것을 담을 수 있다)

2. 배열 생성

foods = new int[5]

• 배열을 사용하려면 배열을 생성해야 한다.
• new int[5] 라고 입력하면 오른쪽 그림과 같이 총 5개의 int 형 변수가 만들어진다.
• new 는 새로 생성한다는 뜻이고, int[5] 는 int 형 변수 5개라는 뜻이다. 따라서 int 형 변수 5개를 다룰 수 있는 배열을 새로 만든다는 뜻이다.
• 배열을 사용하면 여러개의 변수를 생성하는 과정을 한번에 깔끔하게 처리할 수 있다.

배열의 초기화

자바는 지역변수와는 다르게 생성하면 자동으로 초기화를 해준다.

• new int[5] 라고 하면 총 5개의 int 형 변수가 만들어진다. 자바는 배열을 생성할 때 그 내부값을 자동으로 초기화한다.
• 숫자는 0 , boolean 은 false , String 은 null (없다는 뜻이다.)로 초기화 된다.

  3. 배열 참조값 보관

  foods = x001; //배열 참조값 보관

  배열의 크기만큼 메모리를 확보한다.

• new int[5] 로 배열을 생성하면 배열의 크기만큼 메모리를 확보한다. => int형은 4byte니까 4byte * 5 -> 20byte 확보
• 배열을 생성하고 나면 자바는 메모리 어딘가에 있는 이 배열에 접근할 수 있는 참조값(주소값)( x001 )을 반환한다.
• 앞서 선언한 배열 변수인 int[] foods 에 생성된 배열의 참조값( x001 )을 보관한다.
• int[] foods 변수는 new int[5] 로 생성한 배열의 참조값을 가지고 있다.

4. 배열 사용

(1) 인덱스

배열은 변수와 사용법이 비슷한데, 차이점이 있다면 [] 사이에 숫자 번호를 넣어주면 된다. 배열의 위치를 나타내는 숫자를 인덱스(index)라 한다.

//변수 값 대입 
foods[0] = 90; 
foods[1] = 80;

//변수 값 사용
System.out.println("음식1 점수: " + foods[0]);
System.out.println("음식2 점수: " + foods[1]);

⚠️ 중요 배열은 0부터 시작한다

new int[5] 와 같이 5개의 요소를 가지는 int 형 배열을 만들었다면 인덱스는 0,1,2,3,4 가 존재한다.

(2) 배열에 값 대입

배열에 값을 대입하든 배열의 값을 사용하든 간에 일반적인 변수와 사용법은 같다. 추가로 [] 를 통해 인덱스만 넣으면 된다.

foods[1] = 80; //1. 배열에 값을 대입
x001[1] = 80; //2. 변수에 있는 참조값을 통해 실제 배열에 접근. 인덱스를 사용해서 해당 위치의 요소에 접근, 값 대입

(3) 배열 값 읽기

배열을 사용하면 이렇게 참조값을 통해서 실제 배열에 접근하고 인덱스를 통해서 원하는 요소를 찾는다.

//1. 변수 값 읽기
System.out.println("음식1 점수: " + foods[0]);
//2. 변수에 있는 참조값을 통해 실제 배열에 접근. 인덱스를 사용해서 해당 위치의 요소에 접근
System.out.println("음식1 점수: " + x001[0]);
//3. 배열의 값을 읽어옴
System.out.println("음식1 점수: " + 90); ```

5. 배열 리팩토링

리펙토링(Refactoring)은 기존의 코드 기능은 유지하면서 내부 구조를 개선하여 가독성을 높이고, 유지보수를 용이하게 하는 과정을 뜻한다. 이는 중복을 제거하고, 복잡성을 줄이며, 이해하기 쉬운 코드로 만들기 위해 수행된다. 즉, 코드를 개선하는 것을 뜻함

변경 전 코드

 //변수 값 사용
        System.out.println("학생1 점수 " + students[0]);
        System.out.println("학생2 점수 " + students[1]);
        System.out.println("학생3 점수 " + students[2]);
        System.out.println("학생4 점수 " + students[3]);
        System.out.println("학생5 점수 " + students[4]);

위의 코드는 변수명이 students 로 같기 때문에 숫자가 반복되는 부분을 리팩토링 할 수 있다.

변경 후 코드

        //for문 사용
        for (int i = 0; i < 5 ; i++) {
            System.out.println("학생" + (i+1)+ " 점수 " + students[i]);
        }

반복문을 사용해서 배열을 통해 값을 사용하는 부분을 변경했다.

배열은 {}만 사용해서 생성과 동시에 편리하게 초기화 하는 기능을 제공한다.

  int[] students;
  students = new int[]{90, 80, 70, 60, 50}; //배열 생성과 초기화

students = new int[5];로 표현한 부분을 students = new int[]{90, 80, 70, 60, 50};게 적음으로서 배열의 생성과 초기화가 한번에 가능하다

int[] students = {90, 80, 70, 60, 50}; //배열 생성과 초기화

이렇게 적으면 배열의 생성과 초기화를 더 간략히 적을 수 있다.

아래처럼은 안 된다. 변수의 선언과 동시에 적어야함

int[] students; 
students = {90, 80, 70, 60, 50}; 

6. 2차원 배열

2차원 배열은 하나의 차원이 추가되어 있는 배열로, 행과 열로 구성된다. 2차원 배열은 int[][] arr = new int[2][3] 와 같이 선언하고 생성한다. arr[1][2] 와 같이 사용하는데, 먼저 행 번호를 찾고, 그 다음에 열 번호를 찾으면 된다. 행은 영어로 row(로우), 열은 영어로 column(컬럼)이라 한다.

arr[행][열] , arr[row][column]

아래의 방법으로 쉽게 선언이 가능하다

        int[][] arr = new int[][]{
            {1, 2, 3},
            {4, 5, 6}
        }; //행2, 열3

2차원 배열의 초기화

2차원 배열은 {{1, 2, 3},{4, 5, 6}} 괄호를 하나 더 묶어서 초기화한다. {{},{}} 를 생각해보면 arr 배열은 {} , {} 2개의 배열 요소를 가진다.

사용자의 입력을 받을 수 있는 자바의 내장 라이브러리 클래스

package scannner;

import java.util.Scanner;

public class Scanner1 {

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

        System.out.println("문자열을 입력하세요:");
        String str = scanner.nextLine(); //입력을 String으로 가져온다.
        System.out.println("입력한 문자열: " + str);

        System.out.println("정수를 입력하세요:");
        int intValue = scanner.nextInt();
        System.out.println("입력한 정수: " + intValue);

        System.out.print("실수를 입력하세요:");
        double doubleValue = scanner.nextDouble(); // 입력을 double로 가져옵니다.
        System.out.println("입력한 실수: " + doubleValue);

    }

}

1. Scanner scanner = new Scanner(System.in);

   Scanner 기능을 사용하기 위해 new를 사용해서 Scanner를 만든다 Scanner는 System.in을 사용해서 사용자의 입력을 편리하게 받도록 도와줌 Scanner scanner 코드는 scanner 변수를 선언하는 것이다. 이제부터 scanner 변수를 통해서 scanner를 사용할 수 있다.

2. scanner.nextLine()

   엔터를 입력할 때까지 문자를 가져온다.

3. scanner.nextInt()

   입력을 int형으로 가져온다.

4. scanner.nextDouble()

   입력을 double형으로 가져온다.

주의

• 타입이 다르면 오류가 발생한다. int형으로 입력받았다고 선언한건 int형으로만 입력을 받을 수 있다.
• 우리가 엔터 키를 치면 ( \n )이라는 문자를 남기는 것이다.

지역 변수는 이름 그대로 특정 지역에서만 사용할 수 있는 변수라는 뜻이다. 그 특정 지역을 벗어나면 사용할 수 없다. 여기서 말하는 지역이 바로 변수가 선언된 코드 블록({} )이다. 지역 변수는 자신이 선언된 코드 블록({} ) 안에서만 생존하고, 자신이 선언된 코드 블록을 벗어나면 제거된다.

스코프란 변수가 접근 가능한 범위이고, 지역 변수는 본인의 코드 블록 안에서만 생존한다. 하지만 자시느이 코드 블록을 벗어나면 제거되기 때문에 접근할 수 없다.

스코프가 존재하는 이유?

package scope;

public class Scope3_1 {
    public static void main(String[] args) {
        int m =10;
        int temp =0;
        if(m>0){
            temp= m+2;
            System.out.println("temp =" + temp);
        }
        System.out.println("m = " + m);
    }
}

위의 코드는 좋은 예라고 할 수 없다. temp 변수는 if문 안에서만 사용이 되는데 전역으로 설정하게 되면 사용범위가 넓어지기 때문이다.

• 비효율적인 메모리 사용:temp 는 if 코드 블록에서만 필요하지만, main() 코드 블록이 종료될 때 까지 메모리에 유지된다. 따라서 불필요한 메모리가 낭비된다. 만약 if 코드 블록 안에 temp 를 선언했다면 자바를 구현하는곳에서 if 코드 블록의 종료 시점에 이 변수를 메모리에서 제거해서 더 효율적으로 메모리를 사용할 수 있다.

• 코드 복잡성 증가: 좋은 코드는 군더더기 없는 단순한 코드이다. temp 는 if 코드 블록에서만 필요하고, 여기서만 사용하면 된다. 만약 if 코드 블록 안에 temp 를 선언했다면 if 가 끝나고 나면temp 를 전혀 생각하지 않아도 된다. 머리 속에서 생각할 변수를 하나 줄일 수 있다. 그런데 지금 작성한 코드는 if 코드 블록이 끝나도main() 어디서나 temp 를 여전히 접근할 수 있다. 누군가 이 코드를 유지보수 할 때 m 은 물론이고 temp 까지 계속 신경써야 한다. 스코프가 불필요하게 넓은 것이다. 지금은 코드가 매우 단순해서 이해하는데 어려움이 없겠 지만 실무에서는 코드가 매우 복잡한 경우가 많다.

2. 자동형변환

자바는 기본적으로 같은 타입에만 값을 대입할 수 있다.

• 작은 범위에서 큰 범위로는 당연히 값을 넣을 수 있다.
• • 예) int long double
• 큰 범위에서 작은 범위는 다음과 같은 문제가 발생할 수 있다.
• • 소수점 버림 오버플로우

하지만 결국 대입하는 형(타입)을 맞추어야 하기 때문에 개념적으로는 다음과 같이 동작한다.

 //intValue = 10
 doubleValue = intValue
doubleValue = (double) intValue //형 맞추기
doubleValue = (double) 10 //변수 값 읽기
doubleValue = 10.0 //형변환 

이렇게 앞에 (double) 과 같이 적어주면 int 형이 double 형으로 형이 변한다. 이렇게 형이 변경되는 것을 형변환 이라 한다. 작은 범위 숫자 타입에서 큰 범위 숫자 타입으로의 대입은 개발자가 이렇게 직접 형변환을 하지 않아도 된다. 이런 과정 이 자동으로 일어나기 때문에 자동 형변환, 또는 묵시적 형변환이라 한다.

3. 명시적 형변환

큰 범위에서 작은 범위 대입은 명시적 형변환이 필요하다

java: incompatible types: possible lossy conversion from double to int라는 오류 발생

직접 (int) 형을 넣어주면서 형변환을 할 수 있지만 이 경우 숫자가 손실되는 문제가 발생할 수 있다. 하지만 만약 이런 위험을 개발자가 직접 감수하고도 값을 대입하고 싶다면 데이터 타입을 강제로 변경할 수 있다.

이것을 형(타입)을 바꾼다고 해서 형변환이라 한다. 영어로는 캐스팅이라 한다. 그리고 개발자가 직접 형변환 코드를 입 력한다고 해서 명시적 형변환이라 한다.

형변환시 발생하는 오버플로우

형변환을 할 때 작은 숫자가 표현할 수 있는 범위를 넘어서게 됐을 때 발생하는 문제 int 형은 2147483647L까지 표현할 수 있기 때문에 2147483648L 를 표현할 수 있는 방법이 없다. 이렇게 기존 범위를 초과해서 표현하게 되면 전혀 다른 숫자가 표현되는데, 이런 현상을 오버플로우라 한다.

• 보통 오버플로우가 발생하면 마치 시계가 한바퀴 돈 것 처럼 다시 처음부터 시작한다.
• 중요한 것은 오버플로우가 발생하는 것 자체가 문제. 오버플로우가 발생했을 때 결과가 어떻게 되는지 계산하는데 시간을 쓰지 말고 오버플로우 자체가 발생하지 않도록 막아야 한다. 이 경우 단순히 대입하는 변수(intValue )의타입을 int long 으로 변경해서 사이즈를 늘리면 오버플로우 문제가 해결된다.

계산과 형변환

1. 같은 타입끼리의 계산은 같은 타입의 결과를 낸다. int + int 는 int 를, double + double 은 double 의 결과가 나온다.
2. 서로 다른 타입의 계산은 큰 범위로 자동 형변환이 일어난다. int + long 은 long + long 으로 자동 형변환이 일어난다. int + double 은 double + double 로 자동 형변환이 일어난다.

1.while

while문은 조건에 따라 코드를 반복해서 실행할 때 사용한다.

while (조건식) { // 코드
}

• 조건식을 확인한다. 참이면 코드 블럭을 실행하고, 거짓이면 while문을 벗어난다.
• 조건식이 참이면 코드 블럭을 실행한다. 이후에 코드 블럭이 끝나면 다시 조건식 검사로 돌아가서 조건식을 검사 한다.(무한 반복)

잘 작성된 코드란?

변경 상황이 발생했을 때 변경해야 하는 부분이 적을수록 좋은 코드라고 할 수 있다.

2.do-while

do-while 문은 while 문과 비슷하지만, 조건에 상관없이 무조건 한 번은 코드를 실행한다. do-while 문은 최초 한번은 코드 블럭을 꼭 실행해야 하는 경우에 사용하면 된다.

package loop;

public class Dowhile2 {
    public static void main(String[] args) {
        int i =10;
        do {
        // 최소 1번 출력한다
            System.out.println("현재 숫자는 :" +i);
            i++;
        } while(i < 3);
    }
}

위는 i<3이라는 조건에 맞지 않지만 현재 숫자는 10이라는 출력이 1번 나오게 된다

++break, continue

break 와 continue 는 반복문에서 사용할 수 있는 키워드다.

• break 는 반복문을 즉시 종료하고 나간다. continue 는 반복문의 나머지 부분을 건너뛰고 다음 반복으로 진행하는 데 사용된다.
• while , do-while , for 와 같은 모든 반복문에서 사용할 수 있다.

break

while(조건식) { 
    코드1;
    break;//즉시 while문 종료로 이동한다.
    코드2; 
}
//while문 종료 

break 를 만나면 코드2 가 실행되지 않고 while문이 종료된다.

continue

while(조건식) { 
    코드1;
    continue;//즉시 조건식으로 이동한다.
    코드2; 
}

continue 를 만나면 코드2 가 실행되지 않고 다시 조건식으로 이동한다. 조건식이 참이면 while 문을 실행한다.

3.for

for문도 while문과 같은 반복문이고, 코드를 반복 실행하는 역할을 한다. for문은 주로 반복 횟수가 정해져 있을 때 사용한다.

• for (; ; ) 를 보면 조건식이 없다. for문은 조건이 없으면 무한 반복한다.

for (1.초기식; 2.조건식; 4.증감식) { 
    // 3.코드
}

1. 초기식이 실행된다.주로 반복 횟수와 관련된 변수를 선언하고 초기화 할 때 사용한다. 초기식은 딱 1번 사 용된다.
2. 조건식을 검증한다. 참이면 코드를 실행하고, 거짓이면 for문을 빠져나간다.
3. 코드를 실행한다.
4. 코드가 종료되면 증감식을 실행한다. 주로 초기식에 넣은 반복 횟수와 관련된 변수의 값을 증가할 때 사용한 다.
5. 다시 2. 조건식 부터 시작한다. (무한 반복)

for vs while

코드를 비교해보자

//for
package loop;
 public class For2 {
     public static void main(String[] args) {
         int sum = 0;
         int endNum = 3;
         for (int i = 1; i <= endNum; i++) {
             sum = sum + i;
             System.out.println("i=" + i + " sum=" + sum);
         }
    } 
}

//while
 package loop;
 public class While2_3 {
     public static void main(String[] args) {
         int sum = 0;
         int i = 1;
         int endNum = 3;
         while (i <= endNum) {
             sum = sum + i;
             System.out.println("i=" + i + " sum=" + sum);
i++; }
} }

둘을 비교했을 때 for문이 더 깔끔하다는 느낌을 받을 것이다. for문은 초기화, 조건 검사, 반복 후 작업 등이 규칙적으로 한 줄에 모두 들어 있어 코드를 이해하기 더 쉽다. 특히 반복을 위해 값이 증가하는 카운터 변수를 다른 부분과 명확 하게 구분할 수 있다.

정리하면 for문이 없이 while문으로 모든 반복을 다를 수 있다. 하지만 카운터 변수가 명확하거나, 반복 횟수가 정해진 경우에는 for문을 사용하는 것이 구조적으로 더 깔끔하고, 유지보수 하기 좋다.

4. for-each(향상된 for문)

향상된 for문은 배열에서 자주 쓰이는 개념으로 각각의 요소를 탐색한다. for-each문이라고도 많이 부른다.

for (변수 : 배열 또는 컬렉션) {
// 배열 또는 컬렉션의 요소를 순회하면서 수행할 작업
}

• for-each문 내부에 인덱스랑 종료 조건이 숨겨져있어서 편안하게 쓸 수 있다.
• 향상된 for문은 배열의 인덱스를 사용하지 않고, 종료 조건을 주지 않아도 된다. 단순히 해당 배열을 처음부터 끝 까지 탐색한다.
• : 의 오른쪽에 numbers 와 같이 탐색할 배열을 선택하고, : 의 왼쪽에 int number 와 같이 반복할 때 마다 찾은 값을 저장할 변수를 선언한다. 그러면 배열의 값을 하나씩 꺼내서 왼쪽에 있는 number 에 담고 for문을 수행한다. for문의 끝에 가면 다음 값을 꺼내서 number 에 담고 for문을 반복 수행한다. numbers 배열의 끝에 도 달해서 더 값이 없으면 for문이 완전히 종료된다.
• 향상된 for문은 배열의 인덱스를 사용하지 않고도 배열의 요소를 순회할 수 있기 때문에 코드가 간결하고 가독성 이 좋다.

for-each를 사용할 수 없는 경우

증가하는 index값이 필요한 경우 index를 출력해야 하는 경우는 사용이 불가능하다.

특정 조건이 참인지 확인하고, 그 조건이 참(True)일 경우 특정 코드 블록을 실행한다

2. ELSE문

else 문은 if 문에서 만족하는 조건이 없을 때 실행하는 코드를 제공한다.

3. ELSE IF문

앞선 if 문의 조건이 거짓일 때 다음 조건을 검사한다. 만약앞선 if 문이참이라면 else if 를실행 하지 않는다.

• If문의 단점인 1. 불필요한 조건 검사, 2. 코드 효율성을 개선할 수 있다.
• 불필요한 조건 검사: 이미 조건을 만족해도 불필요한 다음 조건을 계속 검사한다.
• 코드 효율성: 조건을 중복 체크 이런 코드에 else if 를 사용하면 불필요한 조건 검사를 피하고 코드의 효율성을 향상시킬 수 있다.

if문과 If-else문의 차이점

• if문은 조건이 맞다면 모든 if문이 실행되어야 할 때 사용한다.
• 여러 조건중에 하나만 만족해도 된다면 else if문을 사용한다.

코드 간략하게 만들기 {} 중괄호 생략

실행하는 문장이 하나라면 한줄로 줄이기가 가능

if(true) System.out.println("코드 실행됌");


```java
if (false) 
    System.out.println("if문에서 실행됨"); 
    System.out.println("if문에서 실행 안됨");

위 문장은 "if문에서 실행 안됨" 만 출력된다. 만약 둘다 if 문 안에 포함하려면 {} 를 사용해야 한다.

4.Switch문

switch 문은 조건식에 해당하는 특정 값으로 실행할 코드를 선택한다.

• 조건식의 결과 값이 어떤 case 의 값과 일치하면 해당 case 의 코드를 실행한다.
• break 문은 현재 실행 중인 코드를 끝내고 switch 문을 빠져나가게 하는 역할을 한다.
• 만약 break 문이 없으면, 일치하는 case 이후의 모든 case 코드들이 순서대로 실행된다.
• default 는 조건식의 결과값이 모든 case 의 값과 일치하지 않을 때 실행된다. if 문의 else 와 같다. default 구문은 선택이다.
• if , else-if , else 구조와 동일하다.

package cond;

public class Switch2 {
    public static void main(String[] args) {
        //grade 1:1000, 2:2000, 3:3000, 나머지: 500
        int grade = 2;
        int coupon;
        switch (grade) {
            case 1:
                coupon = 1000;
                break;
            case 2:
                coupon = 2000;
                break;
            case 3:
                coupon = 3000;
                break;
            default:
                coupon = 500;
        }
        System.out.println("발급받은 쿠폰 " + coupon); }
}

break문이 없다면?

조건에 충족하는 라인부터 break를 만나기 전까지 계속 실행하게 된다. 없다면 끝까지 실행한다

5. 새로운 Switch문

-> 를 사용한다.

• 선택된 데이터를 반환할 수 있다.

package cond;

public class Switch3 {
    public static void main(String[] args) {
        //grade 1:1000, 2:2000, 3:3000, 나머지 500
        int grade = 2;

        int coupon = switch (grade) {
            case 1 -> 1000;
            case 2 -> 2000;
            case 3 -> 3000;
            default -> 500;
        };
        System.out.println("발급받은 쿠폰 " + coupon);
    }
}

If vs Switch 차이는?

• switch 문의조건식을넣는부분을잘보면 x > 10 과 같은 참거짓의 결과가 나오는 조건이 아니라, 단순히 값만 넣을 수 있다.
• switch 문은 조건식이 특정 case 와 같은지만 체크할 수 있다. 쉽게 이야기해서 값이 같은지 확인하는 연산만 가능하다. (문자도 가능)
• 반면에 if 문은 참거짓의 결과가 나오는 조건식을 자유롭게 적을 수 있다.예) x > 10 , x == 10
• 정리하자면 swtich 문 없이 if 문만 사용해도 된다. 하지만 특정 값에 따라 코드를 실행할 때는 switch 문을 사용하면 if 문보다 간결한 코드를 작성할 수 있다.

6. 삼항 연산자

(조건) ? 참_표현식 : 거짓_표현식

단순히 참과 거짓에 따라서 특정 값을 구하는 경우 삼항 연산자 또는 조건 연산자라고 불리는 ?: 연산자를 사용 할 수 있다.

• 삼항 연산자는 항이 3개라는 뜻이다. 조건 , 참_표현식 , 거짓_표현식 이렇게 항이 3개이다. 자바에서 유일하게 항 이 3개인 연산자여서 삼항 연산자라 한다. 또는 특정 조건에 따라 결과가 나오기 때문에 조건 연산자라고도 한다.
• 조건에 만족하면 참_표현식 이 실행되고, 조건에 만족하지 않으면 거짓_표현식 이 실행된다. 앞의 if , else 문 과 유사하다.
• if 문 처럼 코드 블럭을 넣을 수 있는 것이 아니라 단순한 표현식만 넣을 수 있다.

//바꾸기 전 코드
package cond;

public class CondOp1 {
    public static void main(String[] args) {
        int age = 18;
        String status;
        if(age > 18) {
            status = "성인";
        } else {
            status = "미성년자";
        }
        System.out.println("age = " + age + " status = " + status);
    }
}

//바꾼 후 코드
package cond;

public class CondOp2 {
    public static void main(String[] args) {
        int age = 18;
        String status = (age >=18) ? "성인" : "미성년자";
        System.out.println("age = " + age + " status = " + status);
    }
}

자바는 다음과 같은 연산자 우선순위가 있다. 높은 것에서 낮은 순으로 적었다. 처음에 나오는 괄호 () 가 우선순위가 가 장 높고, 마지막의 대입 연산자( = )가 우선순위가 가장 낮다.

1. 괄호 ()
2. 단항 연산자 (예: ++ , -- , ! , ~ , new , (type) )
3. 산술 연산자 (* , / , % 우선,그다음에 + , - )
4. Shift 연산자 ( << , >> , >>> )
5. 비교 연산자 ( < , <= , > , >= , instanceof )
6. 등식 연산자 (== , != )
7. 비트 연산자 (& ,^ ,| )
8. 논리 연산자 (&& , || )
9. 삼항 연산자 (?: )
10. 대입 연산자 (= , += , -= , *= , /= , %= 등등)

연산자 우선순위는 애매하면 괄호()사용해주기!

2. 산술연산자

산술 연산자는 주로 숫자를 계산하는 데 사용된다. 우리가 이미 잘 알고 있는 수학 연산을 수행한다. + , - , * , / , % (나머지연산자)

package operator;

public class Operator1 {
    public static void main(String[] args) {
        //변수 초기화
        int a = 5;
        int b =2;

        //덧셈
        int sum = a+b;
        System.out.println("a + b = " + sum);

        //뺄셈
        int diff = a-b;
        System.out.println("a - b = " + diff);

        //곱셈
        int multi = a * b;
        System.out.println("a * b = " + multi);

        //나눗셈
        int div = a / b;
        System.out.println("a / b = " + div);

        //나머지
        int mod  = a % b;
        System.out.println("a % b = " + mod);
    }
}

3. 문자열 더하기

자바는 특별하게 문자열에도 + 연산자를 사용할 수 있다. 문자열에 + 연산자를 사용하면 두 문자를 연결할 수 있다.

• 문자와 숫자를 더하면 숫자를 문자열로 변경한 다음에 서로 더한다

package operator;

public class Operator2 {

    public static void main(String[] args) {
        //문자열과 문자열 더하기1
        String result1 = "hello " + "world"; System.out.println(result1);
        //문자열과 문자열 더하기2
        String s1 = "string1"; String s2 = "string2"; String result2 = s1 + s2; System.out.println(result2);
        //문자열과 숫자 더하기1
        String result3 = "a + b = " + 10; System.out.println(result3);
        //문자열과 숫자 더하기2
        int num = 20;
        String str = "a + b = "; String result4 = str + num; System.out.println(result4);
    }
}

4. 증감(증가 및 감소) 연산자

증감 연산자는 ++ 와 -- 로 표현되며, 이들은 변수의 값을 1만큼 증가시키거나 감소시킨다.

package operator;

public class OperatorAdd1 {
    public static void main(String[] args) {
        int a = 0;

        a = a + 1;
        System.out.println("a = " + a); //1
        a = a + 1;
        System.out.println("a = " + a); //2

        //증감 연산자
        ++a;
        System.out.println("a = " + a); //3
        ++a;
        System.out.println("a = " + a); //4
    }
}

전위, 후위 증감 연산자

증감 연산자는 피연산자 앞에 두거나 뒤에 둘 수 있으며, 연산자의 위치에 따라 연산이 수행되는 시점이 달라진다.

• ++a : 증감 연산자를 피연산자 앞에 둘 수 있다. 이것을 앞에 있다고 해서 전위(Prefix) 증감 연산자라 한다.
• a++ : 증감 연산자를 피연산자 뒤에 둘 수 있다. 이것을 뒤에 있다고 해서 후위(Postfix) 증감 연산자라 한다.

package operator;

public class OperatorAdd2 {
    public static void main(String[] args) {
        //전위 증감 연산자 사용 예
        int a = 1;
        int b = 0;

        b = ++a; //a의 값을 먼저 증가시키고, 그 결과를 b에 대입
        System.out.println("a = " + a + ", b = " + b);

        //후위 증감 연산자 사용 예
        a = 1;
        b = 0;

        b = a++;//a의 현재 값을 b에 먼저 대입하고, 그 후 a값을 증가시킴
        System.out.println("a = " + a + ", b = " + b); //결과 a=2, b=1


    }
}

5. 비교연산자

비교 연산자는 두 값을 비교하는 데 사용한다. 비교 연산자는 주로 뒤에서 설명하는 조건문과 함께 사용한다. == , != , > , < , >= , <= 비교 연산자를 사용하면 참( true ) 또는 거짓( false )이라는 결과가 나온다. 참 거짓은 boolean 형을 사용한다.

package operator;

public class Comp1 {
    public static void main(String[] args) {
        int a = 2;
        int b = 3;


        System.out.println(a == b); //false. a는 b와 같지 않다
        System.out.println(a != b); // true. a는 b랑 다르다
        System.out.println(a > b); // false a는 b보다 크지 않다
        System.out.println(a < b); //true. a는 b보다 작다
        System.out.println(a >= b); //false. a는 b보다 크거나 같지 않다.
        System.out.println(a <= b); //true. a는 b보다 작거나 같다.

        //결과를 boolean 변수에 담기
        boolean result = a == b; //a == b: false 
        System.out.println(result); //false

    }
}

6. 문자열 비교

문자열이 같은지 비교할 때는 == 이 아니라 .equals() 메서드를 사용해야 한다. == 를 사용하면 성공할 때도 있지만 실패할 때도 있다.

package operator;

public class Comp2 {
    public static void main(String[] args) {
        String str1 = "문자열1"; 
        String str2 = "문자열2";
        boolean result1 = "hello".equals("hello"); //리터럴 비교
        boolean result2 = str1.equals("문자열1");//문자열 변수, 리터럴 비교
        boolean result3 = str1.equals(str2);//문자열 변수 비교
        System.out.println("result1 = " + result1);
        System.out.println("result2 = " + result2);
        System.out.println("result3 = " + result3);

    }
}

7. 논리 연산자

논리 연산자는 boolean 형인 true , false 를 비교하는데 사용한다. && (그리고) : 두 피연산자가 모두 참이면 참을 반환, 둘중 하나라도 거짓이면 거짓을 반환 || (또는) : 두 피연산자 중 하나라도 참이면 참을 반환, 둘다 거짓이면 거짓을 반환 ! (부정) : 피연산자의 논리적 부정을 반환. 즉, 참이면 거짓을, 거짓이면 참을 반환

package operator;

public class Logical1 {
    public static void main(String[] args) {
        System.out.println("&&: AND 연산");
        System.out.println(true && true); //true
        System.out.println(true && false);//false
        System.out.println(false && false);//false

        System.out.println("||: OR 연산");
        System.out.println(true || true); //true
        System.out.println(true || false);//true
        System.out.println(false || false);//false

        System.out.println("! 연산");
        System.out.println(!true); //false
        System.out.println(!false); //true

        System.out.println("변수 활용");
        boolean a = true;
        boolean b = false;
        System.out.println(a && b); // false
        System.out.println(a || b); // true
        System.out.println(!a); // false
        System.out.println(!b); // true
    }
}

8. 대입연산자

대입 연산자( = )는 값을 변수에 할당하는 연산자다. 이 연산자를 사용하면 변수에 값을 할당할 수 있다. 종류는 = , += , -= , *= , /= , %= 가 있다.

package operator;

public class Assign1 {
    public static void main(String[] args) {
        int a=5; //5
        a+=3; //8(5+3): a=a+3
        a-=2; //6(8-2): a=a-2
        a*=4; //24(6*4):a=a*4
        a/=3; //8(24/3):a=a/3
        a%=5; //3(8%5):a=a%5
        System.out.println(a);
    }
}

9. 삼항 연산자

조건식은 참 또는 거짓을 평가하는 표현식입니다. 표현식1은 조건식이 참일 경우에 변수에 할당되는 값 또는 표현식입니다. 표현식2는 조건식이 거짓일 경우에 변수에 할당되는 값 또는 표현식입니다. 변수 = (조건식) ? 표현식1 : 표현식2;

int x = 10;
int y = 20;

int max = (x > y) ? x : y;

System.out.println("최댓값은: " + max);

데이터를 저장하고 참조하기 위한 메모리 공간의 이름

• 변수는 프로그램에서 사용되는 데이터를 임시로 저장하거나 처리 결과를 저장하는 데에 사용된다.
• 변수는 프로그램의 실행 동안 값이 여러 번 변경될 수 있다.

2. 변수의 선언

변수를 선언하면 컴퓨터의 메모리 공간을 확보해서 데이터를 저장할 수 잇다. 그리고 변수의 이름을 통해서 해당 메모리 공간에 접근할 수 있다. 쉽게 이야기해서 데이터를 보관할 수 있는 공간을 만들고, 그곳에 이름을 부여한다.

package variable;

public class Var4 {
    public static void main(String[] args){
    int a;
    int b;

    int c,d;
    }
}

3. 변수 초기화

아무것도 없는 변수에 최초로 값을 넣는 것 int a를 선언하고 a=20을 넣는것이 변수 초기화이다 변수는 무조건 초기화를 해야한다. 만약 초기화를 하지 않고 출력을 하게 되면 java: variable a might not have been initialized 이라는 에러가 출력된다.-> 컴파일 자체가 안된다

컴퓨터에서 메모리는 여러 시스템이 함께 사용하는 공간인데, 변수 선언 = 공간차지, 기존에 어떤 값이 있었는지 아무도 모르는데 그냥 출력하게 되면 이상한 값이 출력될 수 있다.

4. 변수의 기본 데이터 타입

(1) 정수형 (byte, int, short, long)

• byte: 8비트 부호 있는 정수 (-128 ~ 127)
• short: 16비트 부호 있는 정수 (-32,768 ~ 32,767)
• int: 32비트 부호 있는 정수 (-2^31 ~ 2^31-1)
• long: 64비트 부호 있는 정수 (-2^63 ~ 2^63-1)

byte b = 120;
short s = 30000;
int i = 123456;
long l = 123456789L; // L 또는 l을 붙여야 함

(2) 실수형 (float, double)

• float: 32비트 부동소수점 (유효 자릿수 7자리)
• double: 64비트 부동소수점 (유효 자릿수 15자리)

float f = 3.14f; // f 또는 F를 붙여야 함
double d = 3.14;

(3) 문자형 (char)

• char: 16비트 유니코드 문자

  char c = 'A';

(4) 논리형 (boolean)

• boolean: 참(true) 또는 거짓(false)

  boolean flag = true;

4. 변수의 참조 데이터 타입

(1) 클래스 타입:

객체를 생성하는 클래스에 따라 다양한 형태의 데이터를 저장할 수 있음.

String str = "Hello, World!";

(2) 배열 타입:

같은 타입의 여러 값을 저장하는 자료구조

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

(3) 인터페이스 타입:

다른 클래스에서 구현할 메소드를 정의하는데 사용

interface MyInterface {
    void myMethod();
}

(4) 기타 참조 타입:

기본적인 데이터 타입 외에도 다양한 라이브러리 클래스 등이 있음.

• 자바에서 문자열은 기본 데이터 타입이 아니지만 매우 흔하게 사용되며, String 클래스를 사용하여 표현

다음 타입은 실무에서 거의 사용하지 않는다. byte : 표현 길이가 너무 작다. 또 자바는 기본으로 4byte( int )를 효율적으로 계산하도록 설계되어 있다. int 를 사용하자. byte 타입을 직접 선언하고 여기에 숫자 값을 대입해서 계산하는 일은 거의 없다. 대신에 파일을 바이트 단위로 다루기 때문에 파일 전송, 파일 복사 등에 주로 사용된다. short : 표현 길이가 너무 작다. 또 자바는 기본으로 4byte( int )를 효율적으로 계산하도록 설계되어 있다. int 를 사용하자 float : 표현 길이와 정밀도가 낮다. 실수형은 double 을 사용하자. char : 문자 하나를 표현하는 일은 거의 없다. 문자 하나를 표현할 때도 문자열을 사용할 수 있다. 예를 들어 String a = "b" 와 같이 사용하면 된다.

자주 사용하는 타입 실무에서 자주 사용하는 타입은 다음과 같다. 정수- int , long :자바는정수에기본으로 int 를사용한다.만약20억이넘을것같으면 long 을쓰면된 다. 파일을 다룰 때는 byte 를 사용한다. 실수 - double : 실수는 고민하지 말고 double 을 쓰면 된다. 불린형 - boolean : true , false 참 거짓을 표현한다. 이후 조건문에서 자주 사용된다. 문자열 - String : 문자를 다룰 때는 문자 하나든 문자열이든 모두 String 을 사용하는 것이 편리하다.

1. 워크스페이스 (work space)

하나의 프로그램 단위

• 규모가 큰(기능이 많은) 프로그램은 여러 실행파일(프로젝트)로 이루어질 수 있음
• 가장 상위 폴더로 생성됨

2. 프로젝트 (Project)

하나의 실행파일 단위

• 하나의 실행 파일을 생성하기 위한 단위라고 할 수 있음
• 워크스페이스의 하위 폴더로 생성됨

3. 패키지(package)

자바 파일을 구분하기 위한 폴더로 이해하기

• 처음에 package variable; 선언이 필요하다 -> 소속확인
• 단순히 파일 시스템의 폴더 기능만 하는 것이 아니라 클래스의 일부분
• 클래스 이름이 동일해도 패키지가 다르면 다른 클래스로 인식한다.
• 패키지 내부에 패키지를 둘 수도 있다.
• 패키지와 클래스는 도트(.)를 사용해서 표시

  package 사용 예시

  package com.example.myproject;
  //상위패키지.하위패키지.클래스
  

### 4. 클래스 (class)
>실제로 작성된 가장 하위의 소스코드 파일

- 클래스는 객체 지향 프로그래밍에서 객체를 생성하기 위한 설계도 또는 템플릿
- 자바에서 대부분의 코드는 클래스 내에 작성되며, 클래스는 필드(변수)와 메서드(함수)로 구성됩니다.
- 클래스는 객체를 생성하여 사용하는데, 객체는 클래스의 인스턴스입니다.
- 비슷한 유형의 메소드(함수)와 변수를 모아놓은 소스코드
- 클래스가 속한 마지막 패키지의 폴더에 저장됨
- 클래스의 파일명은 클래스의 이름과 동일해야 함


#### class 사용 예시
```java
public class MyClass {
    // 필드(변수)와 메서드(함수) 정의
}

5. 메소드 (Method)

클래스에 정의 되어 있는 함수

• 하나의 클래스에서 다른 클래스의 함수를 실행할 때 실제로 이 메소드를 실행하는 것
• 패키지A.패키지B.클래스C.메소드(arguments)의 형태로 불러와서 실행함

메소드 예시

public class Calculator {
    public int add(int num1, int num2) {
        return num1 + num2;
    }
}

-> add라는 메소드는 다른 패키지에서 불러올 수 있다

package com.example.otherpackage;

// 다른 패키지에서 Calculator 클래스를 임포트
import com.example.math.Calculator;

public class AnotherClass {
    public static void main(String[] args) {
        // Calculator 클래스의 객체 생성
        Calculator calculator = new Calculator();

        // add 메소드 호출
        int result = calculator.add(5, 3);

        // 결과 출력
        System.out.println("Addition result: " + result);
    }
}

6. Module (모듈):

모듈은 Java 9부터 도입된 개념인데, 패키지보다 더 큰 단위의 코드 조직

• 모듈은 관련된 패키지와 리소스를 그룹화하고, 다른 모듈과의 의존성을 명시적으로 정의한다.
• 모듈을 사용하면 코드를 더 모듈화하고, 의존성을 관리하며, 시스템을 더 간결하게 유지할 수 있습니다.

  모듈 사용 예시

  module com.example.mymodule {
    // 모듈 정의
  }

7. Import (임포트)

임포트는 다른 패키지나 클래스의 사용을 선언하는 것이다.

• 클래스에서 다른 패키지의 클래스나 모듈의 클래스를 사용하려면, 해당 클래스를 임포트해야 한다.
• 임포트 문은 코드의 가장 상단에 위치하며, 필요한 패키지나 클래스를 명시한다.

import 사용 예시

import com.example.otherpackage.OtherClass;

자바 표준 스펙과 구현

자바 표준 스펙이란? 자바는 이렇게 만들어야 한다는 설계도이며, 문서이다.

• 이 표준 스펙을 기반으로 자바를 만든다.
• 자바 표준 스펙은 자바 커뮤니티 프로세스(JCP)를 통해 관리된다.
• -> "이렇게 만들어야 돼"라고 적힌 문서임

자바 구현이란? 여러 회사에서 자바 표준 스펙에 맞춰서 실제 작동하는 자바 프로그램을 개발하는 것.

• 표준 스펙을 가지고 여러 회사에서 자바를 만든다고 생각하면 된다.
• 각 회사에 맞는 최적화 프로그램이 있다.ex)Oracle open JDK...
• 각 회사들은 대부분 다양한 운영체제 버전의 자바도 함께 제공한다.
• ->오라클JDK면 맥용, 윈도우용 리눅스용 등등이 제공된다는 뜻

표준스펙과 구현의 이점은 ?

자바 구현들은 모두 표준 스펙에 맞도록 개발되어 있다. 따라서 오라클 Open JDK를 사용하다가 Amazon Corretto 자바로 변경해도 대부분 문제 없이 동작한다.

2. 자바의 컴파일과 실행

자바 프로그램은 컴파일과 실행 단계를 거친다

Java의 경우 컴파일(Compile)이라는 개념이 있다. Python과 같은 언어는 컴파일 언어와 다르게 인터프리터 언어로 별도의 컴파일 과정이 없이 소스 코드를 한줄 한줄 읽어가면서 실행을 하게 되지만, 자바의 경우 컴퓨터가 읽기 전에 컴파일을 한 후 컴퓨터가 이해를 한다.

1. 개발자가 소스코드를 만든다. ex) Hello.java
2. 자바 컴파일러를 사용해서 소스 코드를 컴파일한다
   • 자바가 제공하는 javac라는 프로그램 사용
     • .java -> .class 파일이 생성
   • 자바 소스코드를 byte코드로 변환하여 자바 가상 머신에서 더 빠르게 실행될 수 있게 최적화하고 문법 오류 검출
3. 자바 프로그램 실행
   • 자바가 제공하는 java라는 프로그램 사용
   • 자바 가상머신(JVM)이 실행되면서 프로그램이 작동한다.

3.자바의 호환성

일반적인 프로그램은 다른 운영체제에서 실행이 불가능

• ex) 윈도우 프로그램은 MAC이나 리눅스에서 작동하지 않고 각 운영체제에 맞는 프로그램을 따로 개발해야 함
• ->윈도우 프로그램은 윈도우 OS가 사용하는 명령어들로 구성되어 있기 때문

자바는 자바가 설치 된 모든 OS와 호환이 가능하다

• 특정 OS에 맞추어 개발을 하지 않아도 된다. 호환성은 자바가 해결한다.
• 컴파일된 자바 파일은 모든 자바 보한경에서 실행 가능하다
• 윈도우 자바는 윈도우 OS가 사용하는 명령어들로 구성되어 있다. MAC이나 리눅스 자바도 본인의 OS가 사용하 는 명령어들로 구성되어 있다. 개발자는 각 OS에 맞도록 자바를 설치하기만 하면 된다.

psvm 엔터

system.out.println -> sout

sout 엔터

for 구문 생성 -> fori

for-each 구문 생성 -> iter

이전 클래스 열기 commad + e + enter

코드 실행 control + option + R

현재 코드 실행 control + R

코드 디버깅 control + option + D

현재 코드 디버깅 control + D

한줄 복사 command + D

한번에 이름 바꾸기 Rename shift + f6

현재 구문 완성 shift + command + enter

코드 자동 정렬 command + option + L

한줄 선택 option + ↑ or ↓

전체 검색 shift 2번

아무거나 실행 control 2번

한줄 주석 // command + /

//로 시삭해서 이 기호 이후의 모든 텍스트는 주석으로 처리 된다.

여러줄 주석 /* */

/*로 시작하고 */로 끝나면 이 사이 모든 텍스트는 주석으로 처리된다.

크레인 작동 시 인형이 집어지지 않는 경우는 없으나 만약 인형이 없는 곳에서 크레인을 작동시키는 경우에는 아무런 일도 일어나지 않습니다. 또한 바구니는 모든 인형이 들어갈 수 있을 만큼 충분히 크다고 가정합니다. (그림에서는 화면표시 제약으로 5칸만으로 표현하였음)

게임 화면의 격자의 상태가 담긴 2차원 배열 board와 인형을 집기 위해 크레인을 작동시킨 위치가 담긴 배열 moves가 매개변수로 주어질 때, 크레인을 모두 작동시킨 후 터트려져 사라진 인형의 개수를 return 하도록 solution 함수를 완성해주세요.

[제한사항] board 배열은 2차원 배열로 크기는 "5 x 5" 이상 "30 x 30" 이하입니다. board의 각 칸에는 0 이상 100 이하인 정수가 담겨있습니다. 0은 빈 칸을 나타냅니다. 1 ~ 100의 각 숫자는 각기 다른 인형의 모양을 의미하며 같은 숫자는 같은 모양의 인형을 나타냅니다. moves 배열의 크기는 1 이상 1,000 이하입니다. moves 배열 각 원소들의 값은 1 이상이며 board 배열의 가로 크기 이하인 자연수입니다.

입출력 예

나의코드

function solution(board, moves) {
    let answer = 0;
    let stack = [];

    moves.forEach(pnt=>{
        for(let i =0; i<board.length; i++){
            if(board[i][pnt-1] != 0){
               let tmp = board[i][pnt-1]
               board[i][pnt-1] = 0;
                if(tmp==stack[stack.length-1]){
                    stack.pop()
                    answer+=2
                } else stack.push(tmp)
                break;
            }
        }
    }); return answer
}

문자열 s의 각 알파벳을 index만큼 뒤의 알파벳으로 바꿔줍니다. index만큼의 뒤의 알파벳이 z를 넘어갈 경우 다시 a로 돌아갑니다. skip에 있는 알파벳은 제외하고 건너뜁니다. 예를 들어 s = "aukks", skip = "wbqd", index = 5일 때, a에서 5만큼 뒤에 있는 알파벳은 f지만 [b, c, d, e, f]에서 'b'와 'd'는 skip에 포함되므로 세지 않습니다. 따라서 'b', 'd'를 제외하고 'a'에서 5만큼 뒤에 있는 알파벳은 [c, e, f, g, h] 순서에 의해 'h'가 됩니다. 나머지 "ukks" 또한 위 규칙대로 바꾸면 "appy"가 되며 결과는 "happy"가 됩니다.

두 문자열 s와 skip, 그리고 자연수 index가 매개변수로 주어질 때 위 규칙대로 s를 변환한 결과를 return하도록 solution 함수를 완성해주세요.

나의 코드

function solution(s, skip, index) {
  const alphabet = 'abcdefghijklmnopqrstuvwxyz';
  const skipSet = new Set(skip.split(''));

  const getNextChar = (char, idx) => {
    let nextChar = char;
    let steps = 0;

    while (steps < idx) {
      nextChar = alphabet[(alphabet.indexOf(nextChar) + 1) % 26];

      if (!skipSet.has(nextChar)) {
        steps++;
      }
    }

    return nextChar;
  }

  let result = '';
  for (const char of s) {
    result += getNextChar(char, index);
  }

  return result;
}

예를 들어, 상수의 앞에 쌓이는 재료의 순서가 [야채, 빵, 빵, 야채, 고기, 빵, 야채, 고기, 빵]일 때, 상수는 여섯 번째 재료가 쌓였을 때, 세 번째 재료부터 여섯 번째 재료를 이용하여 햄버거를 포장하고, 아홉 번째 재료가 쌓였을 때, 두 번째 재료와 일곱 번째 재료부터 아홉 번째 재료를 이용하여 햄버거를 포장합니다. 즉, 2개의 햄버거를 포장하게 됩니다.

상수에게 전해지는 재료의 정보를 나타내는 정수 배열 ingredient가 주어졌을 때, 상수가 포장하는 햄버거의 개수를 return 하도록 solution 함수를 완성하시오.

제한사항

• 1 ≤ ingredient의 길이 ≤ 1,000,000
• ingredient의 원소는 1, 2, 3 중 하나의 값이며, 순서대로 빵, 야채, 고기를 의미합니다. 입출력 예

나의코드

function solution(ingredient) {
    let answer = 0
    let stack = []
    ingredient.forEach((inner)=>{
        stack.push(inner)
        const sLength = stack.length
        if(stack[sLength-4] === 1 && stack[sLength-3] === 2 &&  stack[sLength-2] === 3 && stack[sLength-1] === 1){
            for(let i=0;i<4;i++){
                stack.pop()
            }
            answer++
         } 
    })
    return answer
}

처음에 테스트케이스 2개 풀려서 잘 짠줄 알았는데 [1,2,3,1,2,3,1,1]경우에 처음 1,2,3,1이 splice로 삭제되면 결과값이 1개밖에 출력되지 않는 경우가 생긴다.

다른 사람의 코드

function solution(ingredient) {
    let stk = [];
    let count = 0;
    for (let i = 0; i < ingredient.length; i++) {
        stk.push(ingredient[i]);
        if (
            stk[stk.length-1] === 1 &&
            stk[stk.length-2] === 3 &&
            stk[stk.length-3] === 2 &&
            stk[stk.length-4] === 1
        ) {
            count++;
            stk.splice(-4);
        }
    }
    return count;
}

다른 사람의 코드2

function solution(ingredient) {
    let count = 0;

    for (let i = 0; i < ingredient.length; i++) {
        if (ingredient.slice(i, i + 4).join('') === '1231') {
            count++;
            ingredient.splice(i, 4);
            i -= 3;
        }
    }

    return count;
}

idx를 어떻게 돌리면 되나 항상 생각만 했었는데 이런 방법이 있었구나 근데 만약 인덱스가 0인 상태면 [-3]으로가서 맨 뒤 3번째 부터 비교가 되는건가??

선수들의 이름이 1등부터 현재 등수 순서대로 담긴 문자열 배열 players와 해설진이 부른 이름을 담은 문자열 배열 callings가 매개변수로 주어질 때, 경주가 끝났을 때 선수들의 이름을 1등부터 등수 순서대로 배열에 담아 return 하는 solution 함수를 완성해주세요.

나의 코드

function solution(players, callings) {
    let rank = 0
    let temp 
    for (let x of callings){
        rank = players.indexOf(x)
        temp = players[rank-1]
        players[rank-1] = players[rank]
        players[rank] = temp
    } return players
}

시간초과

나의 코드2

function solution(players, callings) {
    let rank = 0
    let temp = players
    for (let x of callings){
        rank = temp.indexOf(x)
        let front = temp.slice(0,rank-1)
        let back = temp.slice(rank+1,players.length)
        let reverse = temp.slice(rank-1,rank+1).reverse()
        temp = front.concat(reverse).concat(back)
    } return temp
}

시간초과

나의 코드3 (통과)

function solution(players, callings) {
  const pPs = {}; //playerPositions

  for (let index = 0; index < players.length; index++) {
    pPs[players[index]] = index;
  }

  for (const calledPlayer of callings) {
    const cPosition = pPs[calledPlayer]; //currentPosition
    if (cPosition !== 0) {
      const overtakenPlayer = players[cPosition - 1];
      players[cPosition] = players[cPosition - 1];
      players[cPosition - 1] = calledPlayer;
      pPs[calledPlayer] = cPosition - 1;
      pPs[overtakenPlayer] = cPosition;
    }
  }

  return players;
}

각 기사는 자신의 기사 번호의 약수 개수에 해당하는 공격력을 가진 무기를 구매하려 합니다. 단, 이웃나라와의 협약에 의해 공격력의 제한수치를 정하고, 제한수치보다 큰 공격력을 가진 무기를 구매해야 하는 기사는 협약기관에서 정한 공격력을 가지는 무기를 구매해야 합니다.

예를 들어, 15번으로 지정된 기사단원은 15의 약수가 1, 3, 5, 15로 4개 이므로, 공격력이 4인 무기를 구매합니다. 만약, 이웃나라와의 협약으로 정해진 공격력의 제한수치가 3이고 제한수치를 초과한 기사가 사용할 무기의 공격력이 2라면, 15번으로 지정된 기사단원은 무기점에서 공격력이 2인 무기를 구매합니다. 무기를 만들 때, 무기의 공격력 1당 1kg의 철이 필요합니다. 그래서 무기점에서 무기를 모두 만들기 위해 필요한 철의 무게를 미리 계산하려 합니다.

기사단원의 수를 나타내는 정수 number와 이웃나라와 협약으로 정해진 공격력의 제한수치를 나타내는 정수 limit와 제한수치를 초과한 기사가 사용할 무기의 공격력을 나타내는 정수 power가 주어졌을 때, 무기점의 주인이 무기를 모두 만들기 위해 필요한 철의 무게를 return 하는 solution 함수를 완성하시오.

나의 코드

function solution(number, limit, power) {
    let stack = Array.from({length:number}, (v,i)=>i+1); 
    let temp = []
    let result = 0
    for (let j of stack){
        let count = 1;
        for (let i =0; i<=parseInt(j/2);i++){
            if(j%i ==0) count ++;
        } temp.push(count)
    } for(let m of temp){
        m<=limit ? result+=m : result+=power
    }return result
}
//약수 개수에 해당하는 공격력을 가진 무기를 구매
// 공격력의 제한 수치(limit)
// 만약 limit보다 큰 공격력이라면 협약기관에서 정한 공격력 가지는 무기 구매해야함

시간 초과

나의 코드2

function solution(number, limit, power) {
    //number까지 숫자 배열 생성
    let stack = Array.from({length:number}, (v,i)=> i+1);
    let divisor = []


    //stack의 약수개수 구하기
    for (let n of stack){
        let count = 0
        for (let i = 1; i <= Math.sqrt(n); i++) { //바뀐부분
            if (n % i === 0) {
                count++;
                if (n / i !== i) {
                    count++;
                }
            }
        } divisor.push(count);
    }  return divisor.reduce((acc,cur) => {
        if(cur <= limit) {
            return acc+cur
        }
        else return power + acc 
    } ,0)
}

제곱근으로 약수를 구해줘서 시간복잡도 개선

다른 사람의 코드

function solution(number, limit, power) {
    var answer = 0;
    for (let n = 1; n <= number; n++)
    {
        let count = 0;
        for (let j = 1; j * j <= n; j++)
        {
            if (j * j == n) count++;
            else if (n % j == 0) count += 2;
        }
        if (count > limit) count = power;
        answer += count;
    }
    return answer;
}

먼저 첫 글자를 읽습니다. 이 글자를 x라고 합시다. 이제 이 문자열을 왼쪽에서 오른쪽으로 읽어나가면서, x와 x가 아닌 다른 글자들이 나온 횟수를 각각 셉니다. 처음으로 두 횟수가 같아지는 순간 멈추고, 지금까지 읽은 문자열을 분리합니다. s에서 분리한 문자열을 빼고 남은 부분에 대해서 이 과정을 반복합니다. 남은 부분이 없다면 종료합니다. 만약 두 횟수가 다른 상태에서 더 이상 읽을 글자가 없다면, 역시 지금까지 읽은 문자열을 분리하고, 종료합니다. 문자열 s가 매개변수로 주어질 때, 위 과정과 같이 문자열들로 분해하고, 분해한 문자열의 개수를 return 하는 함수 solution을 완성하세요.

나의 코드

function solution(s) {
    let x = []
    let notX =[]
    let answer = 0;
    for(let i=0; i<s.length;i++){
        if(x.length == 0) { //초기화 됐을 때
            x.push(s[i]) 
            if(x.length == notX.length || s.length-1 ==i) {
                answer++;
                x = [], notX = []
            }
        }
        else {
            if(s[i] == x[0]) x.push(s[i])
            else notX.push(s[i])
            if(x.length == notX.length||s.length-1 ==i) {
                answer++;
                x = [], notX = []
            }
        }
    } return answer
}

다른 사람의 코드

function solution(s, count=0) {
    if(!s) return count
    let [first, ...rest] = s.split("")
    let countSame = 1
    let countInSame = 0
    let i=0
    for(; i<rest.length; i++){
        if(rest[i] === first) countSame++
        else countInSame++
        if(countSame === countInSame) break
    }
    return solution(rest.slice(i+1).join(""), count+1)
}

가독성은 좋은데, 시간 복잡도가 오래 걸림

다른 사람의 코드2

function solution(s) {
    let answer = 0;
    let current;
    let count = 0;

    for(let i = 0; i < s.length; i++) {
        if(count === 0) {
            answer++;
            current = s[i]
            count = 1
        } else {
            if(current !== s[i]) count--;
            else count++;
        }
    }

    return answer;
}

아 이렇게 풀면되는구나? 스택에 넣어서 생각했다니 괜히 더 복잡해졌다

예를 들어, X = 3403이고 Y = 13203이라면, X와 Y의 짝꿍은 X와 Y에서 공통으로 나타나는 3, 0, 3으로 만들 수 있는 가장 큰 정수인 330입니다. 다른 예시로 X = 5525이고 Y = 1255이면 X와 Y의 짝꿍은 X와 Y에서 공통으로 나타나는 2, 5, 5로 만들 수 있는 가장 큰 정수인 552입니다(X에는 5가 3개, Y에는 5가 2개 나타나므로 남는 5 한 개는 짝 지을 수 없습니다.) 두 정수 X, Y가 주어졌을 때, X, Y의 짝꿍을 return하는 solution 함수를 완성해주세요.

제한사항 3 ≤ X, Y의 길이(자릿수) ≤ 3,000,000입니다. X, Y는 0으로 시작하지 않습니다. X, Y의 짝꿍은 상당히 큰 정수일 수 있으므로, 문자열로 반환합니다.

나의 코드

// 처음에 테케 11~15 시간초과함
function solution(X, Y) {
    let x = X.split('').sort((a,b)=>b-a)
    let y = Y.split('').sort((a,b)=>b-a)
    let temp = ''
    for(let i=0;i<x.length;i++){
        for(let j=0;j<y.length;j++){
            if(x[i] == y[j]){
                temp+=y[j]
                y= y.slice(j+1)
                break;
            }
        }
    } 
    if(temp.length == 0) return "-1" 
    if (temp.split('').every((a) => a === "0")) return "0";
    return temp
}

//시간복잡도 개선

function solution(X, Y) {
  const countX = countDigits(X);
  const countY = countDigits(Y);

  let commonDigits = '';

  for (let i = 0; i < 10; i++) {
    const minCount = Math.min(countX[i], countY[i]);
    if (minCount > 0) {
      commonDigits += String(i).repeat(minCount);
    }
  }

  if (commonDigits.length === 0) {
    return '-1';
  } else if (commonDigits.split('').every((digit) => digit === '0')) {
    return '0';
  } else {
    return commonDigits.split('').sort((a, b) => b - a).join('');
  }
}

function countDigits(number) {
  const count = Array(10).fill(0);
  for (let digit of number) {
    count[Number(digit)]++;
  }
  return count;
}

넓은 벽 전체에 페인트를 새로 칠하는 대신, 구역을 나누어 일부만 페인트를 새로 칠 함으로써 예산을 아끼려 합니다. 이를 위해 벽을 1미터 길이의 구역 n개로 나누고, 각 구역에 왼쪽부터 순서대로 1번부터 n번까지 번호를 붙였습니다. 그리고 페인트를 다시 칠해야 할 구역들을 정했습니다.

벽에 페인트를 칠하는 롤러의 길이는 m미터이고, 롤러로 벽에 페인트를 한 번 칠하는 규칙은 다음과 같습니다.

롤러가 벽에서 벗어나면 안 됩니다. 구역의 일부분만 포함되도록 칠하면 안 됩니다. 즉, 롤러의 좌우측 끝을 구역의 경계선 혹은 벽의 좌우측 끝부분에 맞춘 후 롤러를 위아래로 움직이면서 벽을 칠합니다. 현재 페인트를 칠하는 구역들을 완전히 칠한 후 벽에서 롤러를 떼며, 이를 벽을 한 번 칠했다고 정의합니다.

한 구역에 페인트를 여러 번 칠해도 되고 다시 칠해야 할 구역이 아닌 곳에 페인트를 칠해도 되지만 다시 칠하기로 정한 구역은 적어도 한 번 페인트칠을 해야 합니다. 예산을 아끼기 위해 다시 칠할 구역을 정했듯 마찬가지로 롤러로 페인트칠을 하는 횟수를 최소화하려고 합니다.

정수 n, m과 다시 페인트를 칠하기로 정한 구역들의 번호가 담긴 정수 배열 section이 매개변수로 주어질 때 롤러로 페인트칠해야 하는 최소 횟수를 return 하는 solution 함수를 작성해 주세요.

나의코드

//처음시도
function solution(n, m, section) {
    let maxLen = section[section.length-1]-section[0]+1
    if(maxLen <= m) return 1
    return Math.ceil(maxLen/m)
}

테스트 코드 3개는 통과햇는데 제출실패

원하는 카드 뭉치에서 카드를 순서대로 한 장씩 사용합니다. 한 번 사용한 카드는 다시 사용할 수 없습니다. 카드를 사용하지 않고 다음 카드로 넘어갈 수 없습니다. 기존에 주어진 카드 뭉치의 단어 순서는 바꿀 수 없습니다. 예를 들어 첫 번째 카드 뭉치에 순서대로 ["i", "drink", "water"], 두 번째 카드 뭉치에 순서대로 ["want", "to"]가 적혀있을 때 ["i", "want", "to", "drink", "water"] 순서의 단어 배열을 만들려고 한다면 첫 번째 카드 뭉치에서 "i"를 사용한 후 두 번째 카드 뭉치에서 "want"와 "to"를 사용하고 첫 번째 카드뭉치에 "drink"와 "water"를 차례대로 사용하면 원하는 순서의 단어 배열을 만들 수 있습니다.

문자열로 이루어진 배열 cards1, cards2와 원하는 단어 배열 goal이 매개변수로 주어질 때, cards1과 cards2에 적힌 단어들로 goal를 만들 있다면 "Yes"를, 만들 수 없다면 "No"를 return하는 solution 함수를 완성해주세요.

나의 코드

function solution(cards1, cards2, goal) {
    for(let i=0; i<goal.length;i++){
        if(goal[i] != cards1[0] && goal[i] != cards2[0]){
            return 'No'
        } //종료조건 먼저 적어주고 
        if(goal[i]==cards1[0]){
            cards1.shift()
        }if(goal[i]==cards2[0]){
            cards2.shift()
        }
    } return 'Yes'
}