[공부노트: JAVA] 입문편 정리

개발환경

 

운영체제 : Windows11

개발도구 : IntelliJ

JDK버전 : jdk-23

프로그래밍 언어 : java

빌드 도구 : Gradle-8.10.2

 

 

 

 

---

 

목차

1. Hello World

2. 변수

3. 연산자

4. 조건문

5. 반복문

6. 스코프, 형변환

7. 배열

8. 메서드

 

1. Hello World

 

자바란?

자바표준 스펙과 구현

자바는 표준 스펙과 구현으로 나눌 수 있다.

• 자바 표준스펙
  • 자바는 이렇게 만들어야 한다는 설계도이며, 문서이다.
  • 이 표준 스펙을 기반으로 여러 회사에서 실제 작동하는 자바를 만든다.
  • 자바 표준 스펙은 자바 커뮤니티 프로세스(JCP)를 통해 관리된다.
• 다양한 자바 구현
  • 여러 회사에서 자바 표준 스펙에 맞추어 실제 작동하는 자바 프로그램을 개발한다.
  • 각각 장단점이 있다. 예를 들어 Amazon Corretto는 AWS에 최적화 되어있다.
  • 각 회사들은 대부분 윈도우, MAC, 리눅스 같이 다양한 OS에서 작동하는 버전의 자바도 함께 제공한다.
• 자바 구현들은 모두 표준 스펙에 맞도록 개발되어 있다. 따라서 오라클 Open JDK를 사용하다가 Amazon Corretto자바로 변경해도 대부분 문제 없이 동작한다.

| 개인 공부는 어떤 자바를 사용하든 크게 상관이 없다.

 

컴파일과 실행

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

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

인텔리제이를 통한 자바 컴파일, 실행 과정

• 컴파일
  • 자바 코드를 컴파일 하려면 javac라는 프로그램을 직접 사용해야하는데, 인텔리제이는 자바 코드를 실행할 때 이과정을 자동으로 처리해준다.
    • ex) javac Hello.java
  • 인텔리제이 화면에서 프로젝트에 있는 out폴더에 가보면 컴파일된 .class파일이 있는 것을 확인할 수 있다.
• 실행
  • 자바를 실행하려면 java라는 프로그램을 사용해야 한다. 이때 컴파일된 .class파일을 지정해주면 된다.
    • ex) java Hello, 참고로 확장자는 제외한다.
• 인텔리제이에서 자바 코드를 실행하면 컴파일과 실행을 모두 한번에 처리한다.
• 인텔리제이 덕분에 매우 편리하게 자바 프로그램을 개발하고, 학습할 수 있다.

자바와 운영체제 독립성

• 일반적인 프로그램은 다른 운영체제에서 실행할 수 없다.
• 예를 들어서 윈도우 프로그램은 MAC이나 리눅스에서 작동하지 않는다.
• 왜냐하면 윈도우 프로그램은 윈도우 OS가 사용하는 명령어들로 구성되어 있기 때문이다. 해당 명령어는 다른OS와는 호환되지 않는다.

자바 프로그램

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

자바개발과 운영 환경

• 개발할 때 자바와 서버에서 실행할 때 다른 자바를 사용할 수 있다.
• 개발자들은 개발의 편의를 위해서 윈도우나 MAC OS를 주로 사용한다.
• 서버는 주로 리눅스를 사용한다. 만약 AWS를 사용한다면 Amazon Corretto 자바를 AWS리눅스 서버에 설치하면 된다.
• 자바의 운영체제 독립성 덕분에 각각의 환경에 맞추어 자바를 설치하는 것이 가능하다.

2. 변수

변수 선언과 초기화

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

변수를 선언하고, 선언한 변수에 처음으로 값을 저장하는 것을 변수 초기화라 한다.

 

리터럴

코드에서 개발자가 직접 적은 100, 10.5, true, 'A', "Hello Java"와 같은 고정된 값을 프로그래밍 용어로 리터럴(literal)이라 한다.

int a = 100; //정수 리터럴
double b = 10.5; //실수 리터럴
boolean c = true; //불리언 리터럴
char d = 'A'; //문자 하나 리터럴
String e = "Hello Java"; //문자열 리터럴

*리터럴 이라는 단어의 어원이 문자 또는 글자를 의미한다.

 

변수와 메모리 공간 크기

•  정수형
  • byte : -128 ~ 127 (2의8제곱)
  • short : - 32,768 ~ 32,767 (2의16제곱)
  • int : - 2,147,483,648 ~ 2,147,483,647 (2의32제곱)
  • long : - 9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807 (2의64제곱)
• 실수형
  • float : 약 -3.4E38 ~ 3.4E38
  • double : 약 -1.7E308 ~ 1.7E308
• 기타
  • boolean : true. false
  • char : 문자 하나
  • String : 문자열을 표현한다. 메모리 사용량은 문자 길이에 따라 동적으로 달라진다.

실무에서는 int, long, double, boolean, String이 많이 쓰이고 나머지는 거의 사용하지 않는다.

 

변수 명명 규칙

자바에서 변수의 이름을 짓는데는 규칙과 관례가 있다.

규칙은 필수이다. 규칙을 지키지 않으면 컴파일 오류가 발생한다.

관례는 필수는 아니지만 전세계 개발자가 해당 관례를 따르기 때문에 사실상 규칙이라고 생각해도 된다.

 

규칙

• 변수 이름은 숫자로 시작할 수 없다. (예: 1num)
  • 그러나 숫자를 이름에 포함하는 것은 가능하다. (예: num1)
• 이름에는 공백이 들어갈 수 없다.
• 자바의 예약어를 변수 이름으로 사용할 수 없다. (예: int, class, public)
• 변수 이름에는 영문자, 숫자, 달러 기호 또는 밑줄만 사용할 수 있다.

관례

• 소문자로 시작하는 낙타 표기법
  • 변수 이름은 소문자로 시작하는 것이 일반적이다. 여러 단어로 이루어진 변수 이름의 경우, 첫 번째 단어는 소문자로 시작하고 그 이후의 각 단어는 대문자로 시작하는 낙타 표기법(camel case)를 사용한다. (예: myAccount)
  • 예외) 상수는 모두 대문자 및 언더바로 구분 (예: USER_LIMIT)
  • 예외) 패키지는 모두 소문자 (예: org.sporing.boot)

 

3. 연산자

연산자 종류

• 산술 연산자 : +,-,*,/,%
• 증감 연산자 : ++,--
• 비교 연산자 : ==,!=,<,>,>=,<=
• 논리 연산자 : &&(and),||(or),!(not)
• 대입 연산자 : =,+=,-=,*=,/=,%=
• 삼항 연산자 : a<b ? print("a가 크다") : print("b가 크다")

 

문자열 더하기

//문자열끼리 더하기
String word = "hello " + "world";
System.out.println(word);
consol# hello world
//----------------------------------------
String word1 = "hello";
String word2 = "world";
String fusion = word1+ word2;
System.out.println(fusion);
consol# helloworld
//----------------------------------------
//문자열과 숫자 더하기 //문자와 숫자를 더하면 숫자는 문자열로 변경된다
String math = "a + b = " + 5;
System.out.println(math);
consol# a + b = 5
//----------------------------------------
int num = 3;
String str=" a - b = ";
String fusion= str + num;
System.out.println(fusion);
consol# a - b = 3

 

4. 조건문

• if
• esle if

	int price = 10000;
	int age = 10;
	int discount = 0;

		if (price >= 10000){
        	discount = discount +1000;
            System.out.println("10000원 이상 구매, 1000원 할인");
        }else if (age <=10){
            discount = discount + 1000;
            System.out.println("어린이 1000원 할인");
        }else {
            System.out.println("할인없음");
        }
        System.out.println("\n총 할인 금액: " + discount + "원");

• switch

	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);

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

java14 이후 버전부터 적용 가능한 새로운 switch문 이다

 

5. 반복문

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

while (조건식) {
	}

int sum = 0;
int i = 1;
int endNum = 3;
while (i <= endNum) {
	sum = sum + i;
    System.out.println("i=" + i + " sum=" + sum);
    i++;
    }

*i=1, endNum=3이라면 3번 반복한다. | i=3, endNum=4이라면 2번 반복한다.

1. while문에서 i <= endNum조건을 통해 i가 endNum이 될 때까지 코드 블럭을 실행한다.

2. i가 endNum보다 크면 while문을 종료한다.

 

• do-while

while문과 비슷하지만, 조건에 상관없이 무조건 한 번은 코드를 실행한다.

int i = 10;
do {
	System.out.println("현재 숫자는:" + i);
    i++;
    } while (i<3);

*do-while 문은 최초 한번은 항상 코드 블럭을 꼭 실행된다. 따라서 먼저 현재 숫자는:10이 된다.

*코드 블럭을  실행 후에 조건식을 검증하는데, i=11이기 때문에 while(i<3)조건식은 거짓이 된다. 따라서 do-while문을 빠져나온다.

 

• break, continue

break는 반복문을 즉시 종료하고 나간다. continue는 반복문의 나머지 부분을 건너뛰고 다음 반복으로 진행하는데 사용된다.

*while, do-while, for와 같은 반복문에서 사용할 수 있다.

int sum = 0;

for(int i=1;i<=10;i++) {
	//i가 5일때는 건너뛴다.
    if(i==5){
    	System.out.println("i가 5이므로 건너뜁니다.");
        continue;
	}
    sum += i;
    System.out.println("현재 i: " + i + ", 누적합: " + sum);
    
    //합이 20보다 크면 반복 종료
    if(sum > 20){
    	System.out.println("합이 20보다 크므로 종료: i=" + i + " sum=" + sum);
        break;
	}
}

 

• for

주로 반복 횟수가 정해져 있을 때 사용한다.

1. 초기식이 실행된다. 주로 반복 횟수와 관련된 변수를 선언하고 초기화 할 때 사용한다. 초기식은 딱 1번 사용된다.

2. 조건식을 검증한다. 참이면 코드를 실행하고, 거짓이면 for문을 빠져나간다.

3. 코드를 실행한다.

4. 코드가 종료되면 증감식을 실행한다. 주로 초기식에 넣은 반복 횟수와 관련된 변수의 값을 증가할 때 사용한다.

5. 다시 2. 조건식 보퉈 시작한다. (무한반복)

* for문은 복잡해 보이지만 while문을 조금 더 편하게 다룰 수 있도록 구조화 한 것 뿐이다.

for(int i=0;i<2;i++) {
	System.out.println("외부 for 시작 i:" + i);
    for(int j=0;j<3;j++) {
    	System.out.println("-> 내부 for " + i + "-" + j);
	}
    System.out.println("외부 for 종료 i:" + i);
    System.out.println(); //라인 구분을 위해 실행
}

 

for vs while

for문

장점

1. 초기화, 조건 체크, 반복 후의 작업을 한 줄에서 처리할 수 있어 편리하다.

2. 정해진 횟수만큼의 반복을 수행하는 경우에 사용하기 적합하다.

3. 루프 변수의 범위가 for 루프 블록에 제한되므로, 다른 곳에서 이 변수를 실수로 변경할 가능성이 적다.

단점

1. 루프의 조건이 루프 내부에서 변경되는 경우, for 루프는 관리하기 어렵다.

2. 복잡한 조건을 가진 반복문을 작성하기에는 while문이 더 적합할 수 있다.

 

while문

장점

1. 루프의 조건이 루프 내부에서 변경되는 경우, while루프는 이를 관리하기 쉽다.

2. for 루프보다 더 복잡한 조건과 시나리오에 적합하다.

3. 조건아이 충족되는 동안 계속해서 루프를 실행하며, 종료 시점을 명확하게 알 수 없는 경우에 유용하다.

단점

1. 초기화, 조건 체크, 반복 후의 작업이 분산되어 있어 코드를 이해하거나 작성하기 어려울 수 있다.

2. 루프 변수가 while 블록 바깥에서도 접근 가능하므로, 이 변수를 실수로 변경하는 상황이 발생할 수 있다.

정해진 횟수만큼 반복을 수행해야 하면 for문을 사용하고 그렇지 않으면 while문을 사용하면 된다. (기준으로 삼는 정도로만 이해하기)

 

6. 스코프, 형변환

지역변수

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

int m = 10;
if(true) {
	int x = 20; //x 생존 시작
    System.out.println("if m = " + m); //블록 내부에서 블록 외부는 접근 가능
    System.out.println("if x = " + x);
} //x 생존 종료
System.out.println("if x = " + x); //오류, 변수 x에 접근 불가

System.out.println("if m = " + m);

 

스코프 존재 이유?

변수를 선언한 시점부터 변수를 계속 사용할 수 있게 해도 되지 않을까? 왜 복잡하게 접근 범위(스코프)라는 개념을 만들었을까?

- 스코프를 안할 시 main() 코드 블록이 종료하기 전까지 계속 메모리에 남아있어서 메모리 사용에서 더 비효율적이고, 실무에서 코드가 길어질 경우 코드가 매우 복잡해지기 때문이다.

*변수는 꼭 필요한 범위로 한정해서 사용하는 것이 좋다. 변수의 스코프는 꼭 필요한 곳으로 한정해서 사용하자. 메모리를 효율적으로 사용하고 더 유지보수하기 좋은 코드를 만들 수 있다.
*좋은 프로그램은 무한한 자유가 있는 프로그램이 아니라 적절한 제약이 있는 프로그램이다.

 

명시적 형변환

int < long < double

int를 double에 넣을 경우 자동 형변환이 일어나서 double형으로 변경된다.

int intValue = 10;
long longValue;
double doubleValue;

longValue = intValue; // int -> long
System.out.prinln("longValue = " + longValue);
// 10
doubleValue = intValue; // int -> double
System.out.prinln("doubleValue = " + doubleValue);
// 10.0
doubleValue = 20L; //long -> double
System.out.prinln("doubleValue2 = " + doubleValue);
// 20.0

하지만 double을 int에 넣을 경우 큰 숫자 표현 범위를 작은 숫자 표현 범위에 넣는 것으로 컴파일 오류가 발생한다. 그래서 명시적 형변환을 이용할 시 소수점을 버리고 변환이 가능하다.

double double Value = 1.5;
int intValue = 0;

intValue = doubleValue; //형변환 -> 컴파일 오류
intValue = (int) doubleValue; //명시적 형변환 -> double에서 int로의 손실 벼환
//출력: 1 (기존1.5에서 0.5 소수점 손실)

* 만약 작은 숫자가 표현할 수 있는 범위를 넘어서면 오버플로우가 발생하여 마치 시계가 한바퀴 돈 것 처럼 다시 처음부터 시작한다. 만약 int라면 가장 작은 숫자인 -2747483648부터 시작한다.

정리

int -> long -> double

• 작은 범위에서 큰 범위로는 대입할 수 있다.
  • 이것을 뭇기적 형변환 또는 자동 형변환이라 한다.
• 큰 범위에서 작은 범위의 대입은 다음과 같은 문제가 발생할 수 있다. 이때는 명시적 형변환을 사용해야 한다.
  • 소수점 버림
  • 오버플로우
• 연산과 형변환
  • 같은 타입은 같은 결과를낸다.
  • 서로 다른 타입의 계산은 큰 범위로 자동 형변환이 일어난다.

7. 배열

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

*배열은 1이 아닌 0부터 시작한다.

 

기본형vs참조형

자바의 변수 데이터 타입을 가장 크게 보면 기본형과 참조형으로 분류할 수 있다. 사용하는 값을 직접 넣을 수 있는 기본형, 그리고 방금 본 배열 변수와 같이 메모리의 참조값을 넣을 수 있는 참조형으로 분류할 수 있다.

• 기본형(Primitive Type) : 우리가 지금까지 봤던 int, long, double, boolean처럼 변수에 사용할 값을 직접 넣을 수 있는 데이터 타입을 기본형이라 한다.
• 참조형(Reference Type) : int[ ] students와 같이 데이터에 접근하기 위한 참조(주소)를 저장하는 데이터 타입을 참조형이라한다. 객체나 클래스를 담을 수 있는 변수들도 모두 참조형이다.

참고: 리펙토링
리펙토링(Refactoring)은 기존 코드 기능은 유지하면서 내부 구조를 개선하여 가독성을 높이고, 유지보수를 용이하게 하는 과정을 뜻한다. 이는 중복을 제거하고, 복잡성을 줄이며, 이해하기 쉬운 코드로 만들기 위해 수행된다. 리펙토링은 버그를 줄이고, 프로그램의 성능을 향상시킬 수도 있으며, 코드의 설계를 개선하는데에도 도움이 된다.
쉽게 이야기해서 작동하는 기능은 똑같은데, 코드를 개선하는 것을 리펙토링이라 한다.

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

for(int i=0;i<students.length;i++) {
	System.out.println("학생" + (i + 1) " 점수: " + students[i]);
    }

*학생의 점수를 수정할 때 { }의 내용만 변경하면 된다. 그러면 나머지 코드는 변경하지 않아도 된다.

 

2차원바열

2차원배열은 int[ ][ ] arr = new int[2][3]와 같이 선언하고 생성한다. 그리고 arr[1][2]와 같이 사용하는데, 먼저 행 번호를 찾고, 그 다음에 열 번호를 찾으면된다.

*행은 영어로 row(로우), 열은 영어로 column(컬럼)이라 한다. 자주 사용하는 단어이다.

//2x3 2차원 배열, 초기화
int[ ][ ] arr = new int[2][3];
int i = 1;

//순서대로 1씩 증가하는 값을 입력한다.
for(int row=0;row<arr.length;row++) {
	for(int column=0;column<arr[row].length;column++) {
    	arr[row][column] = i++;
	}
}

//2차원 배열의 길이를 활용
for(int row=0;row<arr.length;row++) {
	for(int column=0;column<arr[row].length;column++) {
    	System.out.print(arr[row][column] + " ");
	}
    System.out.println();
}

*중첩된 for문을 사용해서 값을 순서대로 입력한다.

*arr[row][column]= i++후의 증감 연산자(++)를 사용해서 값을 먼저 대입한 다음에 증가한다.

 

향상된 for문 (for-each문)

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

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

//일반 for문
for(int i=0;i<numbers.length;++i) {
	int number = numbers[i];
    System.out.println(number);
}

//향상된 for문, for-each문
for(int number : numbers) {
	System.out.println(number);
}

//for-each문을 사용할 수 없는 경우, 증가하는 index값 필요
for(int i=0;i<number.length;++i) {
	System.out.println("number" + i + "번의 결과는: " + numbers[i]);
}

 

8. 메서드

자바에서 메서는 함수의 한 종류라고 생각하면 된다.

 

메서드 선언

public static int add(int a, int b)

메서드의 선언 부분으로, 메서드 이름, 반환 타입, 매개변수(파라미터) 목록을 포함한다.

• public static
  • public : 다른 클래스에서 호출할 수 있는 메서드라는 뜻
  • static : 객체를 생성하지 않고 호출할 수 있는 정적 메서드
• int add(int a, in b)
  • int : 반환타입. 메서드의 실행 결과를 반환할 때 사용할 반환 타입을 지정한다.
  • add : 메서드에 이름을 부여한다. 이 이름으로 메서드를 호출할 수 있다.
  • (int a, int b) : 메서드를 호출할 때 전달하는 입력 값을 정의한다. 이 변수들은 해당 메서드 안에서만 사용된다. 이렇게 메서드 선언에 사용되는 변수를 영어로 파라미터, 한글로 매개변수라 한다.

public static void main(String[] args) {
	checkAge(10);
    checkAge(20);
}

public static void checkAge(int age) {
	if(age < 18) {
    	System.out.println(age + "살, 미성년자는 출입이 불가능 합니다.");
        return;
	}
    System.out.println(age + "살, 입장하세요.");
}

 

메서드 호출과 값 복사

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

//실행 과정 코드
changeNumber(num1); //changeNumber를 호출한다. num1(5)
changeNumber(5); //num1의 값을 읽는다.

void changeNumber(int num2=5) //num1의 값 5가 num2에 복사된다. 결과: num1(5), num2(5)
num2 = num2 * 2; //num2에 2를 곱한다. 결과: num1(5), num2(5)
num2 = 5 * 2; //num2의 값을 읽어서 2를 곱한다. 결과: num1(5), num2(5)
num2 = 10; //num2에 계산 결과인 값 10을 대입한다. 결과: num1(5), num2(10)

num2를 출력한다: num2의 값인 10이 출력된다.
num1을 출력한다: num1의 값인 5가 출력된다.

 

메서드 호출과 값 복사

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

public static int changeNumber(int num2) {
	num2 = num2 * 2;
	return num2;
}

//실행결과
changeNumber 호출 전, num1: 5
changeNumber 호출 후, num1: 10

//실행과정
num1 = changeNumber(num1); //num1(5)
num1 = changeNumber(5);

//호출 시작:changeNumber()
//num1의 값 5가 num2에 대입된다. num1의 값을 num2에 복사한다. num1(5), num2(5)
int changeNumber(int num2=5) 
num2 = num2 * 2; //계산 결과: num1(5), num2(10)
return num2; // num2의 값은 10이다.
return 10;
//호출 끝: changeNumber()

num1 = changeNumber(5);//반환 결과가 10이다.
num1 = 10;//결과: num1(10)

정리

꼭 기억하기! 자바는 항상 변수의 값을 복사해서 대입한다.

 

메서드 오버로딩

오버로딩 규칙

메서드의 이름이 같아도 매개변수의 타입 및 순서가 다르면 오버로딩을 할 수 있다. 참고로 반환 타입은 인정하지 않는다.

public static void main(String[] args) {
 	System.out.println("1: " + add(1, 2));
 	System.out.println("2: " + add(1.2, 1.5));
}

// 첫 번째 add 메서드: 두 정수를 받아서 합을 반환한다.
public static int add(int a, int b) {
	System.out.println("1번 호출");
	return a + b;
}

// 두 번째 add 메서드: 두 실수를 받아서 합을 반환한다.
// 첫 번째 메서드와 이름은 같지만, 매개변수의 유형이 다르다.
public static double add(double a, double b) {
	System.out.println("2번 호출");
	return a + b;
}

1. 정수1, 정수2를 호출했으므로 add(int a, in b)가 호출되어 3이 나온다.

2. 실수1.2, 실수1.5를 호출했으므로 add(double a, double b)가 호출되어 2.7이 나온다.

 

void와 return생략

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

---