안녕하세요. 첫 게시물은 자바 입문편인데요 :)
이번 학기는 자바를 이용한 프로젝트를 진행하는 만큼 자바에 대한 공부가 필요했습니다.
추천을 받아 인프런에서 김영한 강사님의 자바강의를 선정하게 되었고
내용을 간략히 정리하여 포스팅해보겠습니다 🙌
목차
01. 변수
02. 연산자
03. 조건문
04. 반복문
05. 배열
06. 메서드
+Scanner
01. 변수
변수는 이름 그대로 변할 수 있는 수
1) 변수 선언과 초기화
변수 선언
변수를 선언하면 컴퓨터의 메모리 공간을 확보해서 그곳에 데이터를 저장할 수 있다.
그리고 변수의 이름을 통해서 해당 메모리 공간에 접근 가능!
변수 초기화
변수를 선언하고, 선언한 변수에 처음으로 값을 저장하는 것
public class Var5 {
public static void main(String[] args) {
//1. 변수 선언, 초기화 각각 따로
int a; //선언
a = 1; //초기화
System.out.println(a);
//2. 변수 선언과 초기화를 한번에
int b = 2;
System.out.println(b);
}
}
2) 변수 타입
int : 정수 예) 1 , 100 , 1000
double : 실수 예) 0.2 , 1.5 , 100.121
boolean : 불리언 타입 ( 참과 거짓을 판단 - true , false 값만 사용)
char : 문자 하나 ( 작은따옴표( ' )를 사용해서 감싼다.) 예) 'A' , '가'
String : 문자열 ( 큰따옴표를 사용해야 한다.) 예) "hello java"
⚠️각 변수는 지정한 타입에 맞는 값을 사용해야 한다
>> int a = "백원" : 정수 타입에 문자열(X)
리터럴
코드에서 개발자가 직접 적은 고정된 값을 프로그래밍 용어로 리터럴(literal)이라 한다.
변수의 값은 변할 수 있지만 리터럴은 개발자가 직접 입력한 고정된 값이다!
int a = 100; //정수 리터럴
double b = 10.5; //실수 리터럴
boolean c = true; //불리언 리터럴
char d = 'A'; //문자 하나 리터럴
String e = "Hello Java"; //문자열 리터럴
+) 변수를 선언하면 표현 범위에 따라 메모리 공간을 차지한다.
필요에 맞도록 다양한 타입을 제공하는데 자주 사용하는 타입은 아래와 같다.
> 정수 - int, long
> 실수 - double
> 불린형 - boolean
> 문자열 - String
3) 변수 명명 규칙
규칙
- 변수이름 숫자로 시작할 수 x
- 공백 들어갈 수 x
- 자바 예약어 사용 x
- 영문자, 숫자, 달러기호($), 밑줄(_)만 사용 가능
관례
- 소문자로 시작하는 낙타 표기법
: 첫 번째 단어는 소문자로 시작, 이후의 각 단어는 대문자로 시작 예) myAccount
+) 자바 언어 관례
>> 클래스는 첫 글자 대문자, 나머지는 모두 첫 글자 소문자로 시작 + 낙타 표기법
클래스: Person , OrderDetail
변수를 포함한 나머지: firstName , userAccount
02. 연산자
연산자 종류
산술 연산자: + , - , * , / (나눗셈), % (나머지 연산자)
증감(증가 및 감소) 연산자: ++ , --
비교 연산자: == , !=(불일치) , > , < , >= , <=
논리 연산자: && (AND), || (OR), ! (NOT)
대입 연산자: = , += , -= , *= , /= , %=
삼항 연산자: ? :
헷갈릴 수 있는 부분만 짚고 넘어가자면
전위, 후위 증감연산자
> ++a : 증감 연산자를 피연산자 앞에 둘 수 있다
> a++ : 증감 연산자를 피연산자 뒤에 둘 수 있다
축약(복합) 대입 연산자
산술 연산자와 대입 연산자를 한번에 축약해서 사용한다.
i = i + 3 → i += 3
i = i * 4 → i *= 4
03. 조건문
- if문
-switch문
-삼항연산자
1) if문
❗특정 조건을 만족하지 않으면 다음 조건을 검사하는 흐름
package cond;
public class If4 {
public static void main(String[] args) {
int age = 14;
if(age <= 7) { //~7: 미취학
System.out.println("미취학");
} else if(age <= 13) { //8~13: 초등학생
System.out.println("초등학생");
} else if(age <= 16) { //14~16: 중학생
System.out.println("중학생");
} else if(age <= 19) { //17~19: 고등학생
System.out.println("고등학생");
} else { //20~: 성인
System.out.println("성인");
}
}
}
단, 시스템이 두가지의 조건을 모두 확인해야하는 거라면 if문을 두개 작성해야함 (else if가 아닌!)
2) switch문
break를 안쓰게 되면 무한 루프!
switch (조건식) {
case value1:
// 조건식의 결과 값이 value1일 때 실행되는 코드
break;
case value2:
// 조건식의 결과 값이 value2일 때 실행되는 코드
break;
default:
// 조건식의 결과 값이 위의 어떤 값에도 해당하지 않을 때 실행되는 코드
}
예)
int grade = 2;
int coupon;
switch (grade) {
case 1:
coupon = 1000;
break;
아무래도 if문보다 덜 복잡해보이지만 깔끔해보이지 않는 탓인지
자바 14부터는 새로운 switch문이 정식 도입! 되었다고 한다.
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);
}
}
확실히 더 간단해진 코드를 확인할 수 있다!
3) 삼항연산자
단순히 참과 거짓에 따라서 특정 값을 구하는 경우, 삼항 연산자 또는 조건 연산자라고 불리는 ?: 연산자를 사용할 수 있다.
(조건) ? 참_표현식 : 거짓_표현식
public class CondOp2 {
public static void main(String[] args) {
int age = 18;
String status = (age >= 18) ? "성인" : "미성년자";
System.out.println("age = " + age + " status = " + status);
}
}
04. 반복문
- while문
- do-while문
- for문
1) while문
참이면 코드 블럭을 실행하고, 거짓이면 while문을 벗어나는 흐름
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++;
}
}2) do-while문
while 문과 비슷하지만, 조건에 상관없이 무조건 한 번은 코드를 실행
public static void main(String[] args) {
int i = 10;
do { //최초 한번은 항상 실행
System.out.println("현재 숫자는:" + i);
i++;
} while (i < 3);
}break, continue
: break 와 continue 는 반복문에서 사용할 수 있는 키워드
- break: 반복문을 즉시 종료하고 나간다.
- continue: 반복문의 나머지 부분을 건너뛰고 다음 반복으로 진행한다.
3) for문
for (1.초기식; 2.조건식; 4.증감식)
>> for문은 주로 반복 횟수가 정해져 있을 때 사용한다.
public static void main(String[] args) {
int sum = 0;
for (int i = 1; ; i++) {
sum += i;
if (sum > 10) {
System.out.println("합이 10보다 크면 종료: i=" + i + " sum=" + sum);
break;
}
}
}
중첩 for문
반복문은 내부에 또 반복문을 만들 수 있다. for , while 모두 가능하다.
public static void main(String[] args) {
for(int i = 1; i <= 9; i++) {
for(int j = 1; j <= 9; j++) {
System.out.println(i + " * " + j + " = " + i * j);
}
}
}
/*
출력 형태
```
1 * 1 = 1
1 * 2 = 2
...
9 * 9 = 81
*/
05. 배열
1) 배열의 선언과 생성
배열 선언
- int[] students; 와 같이 배열 변수를 선언 (일반 변수 선언과 달리 [] 대괄호가 들어감)
배열 생성
- students = new int[5]; 와 같이 배열 생성 (int 형 변수 5개를 다룰 수 있는 배열을 새로 만든다는 뜻)
배열 참조값 보관
- 배열을 생성하고 나면 메모리 어딘가에 있는 이 배열에 접근할 수 있는 참조값(주소)( x001 -> 예시)을 반환한다.
- 배열 변수인 int[] students 에 생성된 배열의 참조값( x001 )을 보관한다.
- 이 참조값을 통해 배열을 참조할 수 있다. (참조값을 통해 메모리에 있는 실제 배열에 접근하고 사용 가능)
배열 사용
> 인댁스(배열의 위치를 나타내는 숫자) 사용
예) students[0] = 90;
+ 기본형 vs 참조형
자바의 변수 데이터 타입을 가장 크게 보면 기본형과 참조형으로 분류할 수 있다.
- 기본형(Primitive Type): int , long , double , boolean 처럼 변수에 사용할 값을 직접 넣을 수 있는 데이터 타입
- 참조형(Reference Type): int[] students 와 같이 데이터에 접근하기 위한 참조(주소)를 저장하는 데이터 타입
2) 배열 리펙토링
리펙토링(Refactoring)이란?
기존의 코드 기능은 유지하면서 내부 구조를 개선하여 가독성을 높이고, 유지보수를 용이하게 하는 과정을 뜻한다.
중복을 제거하고, 복잡성을 줄이며, 이해하기 쉬운 코드로 만들기 위해 수행된다.
- 간단한 배열 생성 (배열의 편리한 초기화)
//기존 배열 선언 및 변수 값 대입
int[] students=new int[5];
students[0] = 90;
students[1] = 80;
students[2] = 70;
students[3] = 60;
students[4] = 50;
//배열 리펙토링
int[] students = new int[]{90, 80, 70, 60, 50};
//배열 생성 간략 버전, 배열 선언과 함께 사용시 new int[] 생략 가능
int[] students = {90, 80, 70, 60, 50};
3) 2차원 배열
- 2차원 배열은 행과 열로 구성
- int[][] arr = new int[2][3] 와 같이 선언하고 생성
- arr[행][열] , arr[row][column]
2차원 배열 리펙토링
// 기본 2차원 배열 선언 및 생성, 대입 코드
public static void main(String[] args) {
// 2x3 2차원 배열을 만든다.
int[][] arr = new int[2][3]; //행(row), 열(column)
arr[0][0] = 1; //0행, 0열
arr[0][1] = 2; //0행, 1열
arr[0][2] = 3; //0행, 2열
arr[1][0] = 4; //1행, 0열
arr[1][1] = 5; //1행, 1열
arr[1][2] = 6; //1행, 2열
//0행 출력
System.out.print(arr[0][0] + " "); //0열 출력
System.out.print(arr[0][1] + " "); //1열 출력
System.out.print(arr[0][2] + " "); //2열 출력
System.out.println(); //한 행이 끝나면 라인을 변경한다.
//1행 출력
System.out.print(arr[1][0] + " "); //0열 출력
System.out.print(arr[1][1] + " "); //1열 출력
System.out.print(arr[1][2] + " "); //2열 출력
System.out.println(); //한 행이 끝나면 라인을 변경한다.
}
//리펙토링 --------------------------------
public static void main(String[] args) {
// 2x3 2차원 배열, 초기화
int[][] arr = {
{1, 2, 3},
{4, 5, 6}
};
// 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();
}
}
4) 향상된 for문
- 배열을 순서대로 처음부터 끝까지 탐색하고 싶을때 사용 (index값 사용안할때 사용)
- (저장할 변수선언):(탐색할 배열)
public static void main(String[] args) {
int[] numbers = {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 < numbers.length; ++i) {
System.out.println("number" + i + "번의 결과는: " + numbers[i]);
}
}
06. 메서드(Method)
- 함수를 메서드라고 함다
- 수학의 함수를 생각해보면 쉬운데
- 숫자를 더한 다음에 그 결과를 출력하는 아주 단순한 함수를 add라고 한다
- add(a, b)= a+b
public class Method1Ref {
public static void main(String[] args) {
int sum1 = add(5, 10);
System.out.println("결과1 출력:" + sum1);
int sum2 = add(15, 20);
System.out.println("결과2 출력:" + sum2);
}
//add 메서드
public static int add(int a, int b) {
System.out.println(a + "+" + b + " 연산 수행");
int sum = a + b;
return sum;
}
}
메서드는 크게 두가지로 나눌 수 있다.
1) 메서드 정의
메서드 선언(Method Declaration)
public static int add(int a, int b)
- 제어자, 반환 타입(반환타입 없으면 void), 메서드 이름, 매개변수(파라미터) 목록을 포함
- public : 다른 클래스에서 호출할 수 있는 메서드라는 뜻 (제어자)
- static : 객체를 생성하지 않고 호출할 수 있는 정적 메서드라는 뜻 (제어자)
메서드 본문(Method Body)
System.out.println(a + "+" + b + " 연산 수행");
int sum = a + b;
return sum;
- 메서드가 수행해야 하는 코드 블록
- 메서드를 호출하는 곳에서는 메서드 선언은 알지만 메서드 본문은 모른다.
- 메서드의 실행 결과를 반환하려면 return 문을 사용해야 한다.
2) 메서드 호출과 용어정리
호출할 때는 다음과 같이 메서드에 넘기는 값과 매개변수(파라미터)의 타입이 맞아야 한다.
- 이때 넘기는 값이 인수(Argument)! (아규먼트, 인수, 인자라는 용어를 모두 사용)
- 메서드를 정의할 때 선언한 변수인 String str, int age 를 매개변수, 파라미터라 한다.
호출: call("hello", 20)
메서드 정의: int call(String str, int age)
void와 return 생략
- 모든 메서드는 항상 return 을 호출해야 한다.
- But, 반환 타입 void 의 경우에는 예외로 생략해도 된다.
- 자바가 반환 타입이 없는 경우에는 return 을 마지막줄에 넣어준다. (return 을 만나면 해당 메서드는 종료)
3) 메서드 호출과 값 전달
* 자바에서 중요한 대원칙*
- 자바는 항상 변수의 값을 복사해서 대입한다.
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 의 변경은 num1 에 영향을 주지 않는다. 복사해서 전달하기 때문!
4) 메서드와 형변환
명시적 형변환
메서드를 호출하는데 인자와 매개변수의 타입이 맞지 않다면 명시적 형변환!
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);
}
}
자동 형변환
- int < long < double
- double 형 매개변수(파라미터)에 int 형 인수를 전달하는데 문제없이 잘 동작!
5) 메서드 오버로딩
- 메서드 오버로딩(Overloading): 메서드 이름이 같고, 매개변수가 다른 메서드를 여러개 정의하는 것
add(int a, int b)
add(int a, int b, int c)
add(double a, double b)
오버로딩 규칙
- 메서드의 이름이 같아도 매개변수의 타입 및 순서가 다르면 오버로딩을 할 수 있다.
(참고로 반환 타입은 인정하지 않는다.)
메서드 시그니처(method signature)
메서드 시그니처 = 메서드 이름 + 매개변수 타입(순서)
- 자바에서 메서드를 구분할 수 있는 고유한 식별자나 서명을 뜻한다.
- 메서드 이름이 같아도 메서드 시그니처가 다르면 다른 메서드로 간주하여 구분 가능
//오버로딩 실패 - 매개변수 타입까지 같아 메서드 시그니처 =
int add(int a, int b)
double add(int a, int b)
+ 사용자 입력 받기: Scanner 이용
- System.out 을 통해서 출력을 했듯이, System.in 을 통해서 사용자의 입력을 받을 수 있다.
- 자바가 제공하는 System.in 을 통해서 사용자 입력을 받으려면 여러 과정을 거쳐야해서 복잡하고 어렵기에 Scanner 라는 클래스를 제공한다.
Scanner scanner = new Scanner(System.in);
import java.util.Scanner;
public class Scanner1 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("문자열을 입력하세요:");
String str = scanner.nextLine(); // 입력을 String으로 가져옵니다.
System.out.println("입력한 문자열: " + str);
System.out.print("정수를 입력하세요:");
int intValue = scanner.nextInt(); // 입력을 int로 가져옵니다.
System.out.println("입력한 정수: " + intValue);
System.out.print("실수를 입력하세요:");
}
}
오늘은 자바 입문강의에서
핵심적인 개념과 내용들을 정리해보았습니다
다음 포스팅에서는 기본편 강의 내용을
가져오도록 하겠습니다 :)
모두들 화이팅!!!
'자바' 카테고리의 다른 글
| [자바의 정석] 변수, 배열, 객체 지향 파트 요약 정리 (챕터2, 5, 6 정리) (0) | 2025.03.16 |
|---|---|
| 자바 실전개념편 3(상속, 다형성) (1) | 2024.06.02 |
| 자바 실전개념편 2(접근 제어자~final) (0) | 2024.05.26 |
| 자바 실전개념편 1(클래스와 데이터 ~ 생성자) (0) | 2024.05.19 |
