개념 요약 노트 (~ 객체 배열)

<변수>
값을 저장하기 위한 메모리 공간 (Stack)
장점 : 가독성 좋음 / 유지보수 용이

<변수 선언>
메모리 공간에 데이터 저장 공간을 할당하는 것
자료형 변수명;

<자료형>
- 기본형
논리형 : boolean(1byte)
문자형 : 문자 char(2byte)
숫자 / 정수형 : byte(1byte), short(2byte), int(4byte), long(8byte)
숫자 / 실수형 : float(4byte), double(8byte)

<참조형>
기본형을 제외한 나머지 자료형

<형변환>
값(데이터)의 자료형을 바꾸는 것

<자동 형변환>
컴파일러가 자동으로 값의 범위가 작은 데이터를
값의 범위가 큰 데이터의 자료형으로 변환하는 것
+ byte / short는 형변환시 int로 형변환 됨

<강제 형변환>
값이 큰 자료형을 작은 자료형으로 변환
(데이터 손실 발생 가능성 있음)

<Scanner>
사용자의 입력을 처리하는 클래스
import 작성 → Scanner 생성 → 키보드 입력 값 받기

<입력 값 받을 때 주의사항>
● nextLine()
≫ 입력한 값을 한 줄 자체로 모두 읽어옴
(엔터도'\n' 전부 읽어옴, 그 후 날아감)
● next(), nextInt() …등
≫ 입력한 값만 읽어옴
(그렇다 보니 버퍼에 /n이 남게 되어,
다음에 문자열을 읽어오면 줄바꿈만 가져감
게다가 /n은 읽어오면 홀라당 날려버림)
● next, nextInt, nextfloat, nextdouble 후에 nextLine을 쓰면 안 됨
● 해결책
1. int면 int를 문자열로 받은 후 파싱 Integer.parseInt(); < ☆
2. sc.nextLine();으로 버퍼에 남은 줄바꿈(/n) 제거
+) next()는 문자를 받지만 띄어쓰기를 구분자로 인식해서 안 됨

<파싱>
문자열을 다른 기본 자료형으로 바꾸는 것

<charAt(n)>
- 문자열을 하나의 문자로 바꾸는 것
- 제로 베이스드 기준
- Scanner로 문자 입력받을 시, String 타입만 가능하기 때문에
　문자를 받아와야 한다면 charAt() 활용

<메소드(Method)>
- 기능을 수행하는 것
1. 수행 O / 결과 반환 X → print(), println(), printf() // 출력하고 끝
2. 수행 O / 결과 반환(리턴 값) O → sc.nextxxx() … // 받아서 반환

---

<연산자 우선 순위>
최단산비논삼대

<논리부정 연산자>
! // 반대 값으로 변경 시 씀

<증감 연산자>
++, -- // 피연산자 값을 1 더하거나 뺌
전위 연산과 후위 연산으로 나뉘고,
위치에 따라 출력 값이 달라진다

<산술 연산자>
+, -, *, /, %

<비교 연산자>
== 같다
!= 다르다
비교 결과 값은 true / false

+) 비교 연산자는 문자열 비교 불가능!
　문자열 비교 메소드는 equals()
　String으로 반환 타입 boolean (true || false)

<논리 연산자>
&& and // 두 피연산자 모두 true여야 true
|| or // 두 피연산자 중 하나만 true여도 true

<복합 대입 연산자>
자기 자신과 연산 후 결과를 자신에게 누적 대입
ex) a += 10 ≫ a = a + 10
- 증감 연산자는 1씩 증감하지만 복합 대입 연산자는
　원하는 값을 증감해 변수에 저장할 수 있다

<삼항 연산자>
조건식 결과 값에 따라 연산을 처리
삼항 연산자를 중첩으로 사용할 수 있음
결과 값에 따라서 자료형이 달라진다.

＊참조 자료형은 Class가 될 수 있음 (주소 값 가짐)
결론은 Class가 이미 주소 값을 가졌다는 것!
뒤에서 배웠던 stack과 heap 구조를 생각해보자.

---

<if문>
// 결과 값은 항상 boolean
// 조건식 결과가 true여야 내용 실행 (false면 건너뜀)

<if~else문>
- else에는 조건식 들어가지 않음
- if 조건식 결과가 false일 때 실행

<if~else if~else>
- 원하는 만큼 조건 생성 가능
- 마지막 else는 없어도 상관 無
- 하지만 앞의 조건식에서 true가 걸리면,
이후 조건식 수행 않고 if문 전체 빠져나감

＊메소드 안의 변수(지역 변수)는
　해당 메소드 영역에서 한 번만 사용 가능

＊참조 자료형(클래스)도 기본 값, 주소 값 있음
　≫ null (널값으로 텅 비어있는 값을 의미)
　≫ 이 상태로 불러오거나 호출하면 에러 발생

<switch문>
// 결과 값은 정수, 문자, 문자열
// 참고 : if문의 결과 값은 boolean
- break;를 꼭 써서 멈춰주어야 함
- default는 if문 else와 같은 역할 = 끝
- 메뉴 만들 때 많이 사용
　(case 안에 같은 클래스 메소드 호출 가능)

＊if문은 전부 switch문과 바꿀 수 없다
　switch문은 전부 if문으로 바꿀 수 있다

<for문>
// 특정 코드 반복 수행
// 조건이 false 되면 문장 전체 빠져나감
// 조건식이 계속 true면 '무한 반복문'이 된다.
　while(true) {} 에서 많이 봤었음

<중첩 반복문>
// 구구단의 원리를 적용해 보면
　큰 for문은 1단 2단, 작은 for문은 x1, x2...
- for while if switch 등 서로 중첩 가능

<Math.random()>
// 클래스.메소드()
// 난수 : 랜덤한 수로 double 타입 반환
// 예를 들어 1~n 사이의 정수 난수를 출력하려면
　(int)(Math.random() * n + 1) → int로 형변환

<sum += i>
(1부터 i까지 합)
sum = sum + i
0 = 0 + 1
1 = 1 + 2
3 = 3 + 3
6 = 6 + 4
10

<while문>
int i = 0;
while(i < 10) {
　수행될 문장;
　i++
}
- 조건식 하나밖에 안 들어감
- 초기식은 조건식 위, 증감식은 안에 넣어줌.
- {} 안에 조건을 벗어날 증감식, 분기문 필요
　만약 까먹으면 무한 반복 루트에 빠짐
- 몇 번 반복할지 횟수는 정하지 않았지만
　종료할 때까지 돌리고 싶을 때 쓴다

<do~while문>
do {
　　수행될 문장
　　[증감식 / 분기문];
} while(조건식);
-무조건 한 번 실행 보장
-do 안의 내용 먼저 실행 후 조건식 확인
　조건식이 true면 문장 수행, false면 종료

＊for문은 전부 while문과 바꿀 수 있다

<length()>
문자열의 길이를 반환하는 메소드

<equals()>
문자열을 비교하는 메소드
널포인트 에러가 나면 . 앞을 살펴보면
대부분 그 공간이 null로 텅 비어있음

<return;>
나를 호출해준 메소드에게 돌아간다는 의미

<for문 / while문 사용법>
for문 : 내가 반복하고자 하는 횟수가 정해졌을 때
(5번 돌린다. 문자열 길이 만큼 돌리겠다)
while문 : 내가 반복할 횟수가 정해지지 않았을 때
(얼마나 돌릴지 모르지만 나갈 시점을 정했을 때)

---

<배열(Arrays)>
// 같은 자료형의 변수를 하나로 묶은 것
- 배열은 저장된 값마다 인덱스 번호 0부터 설정되어 있다
- 배열은 하나 안에 여러 개의 값을 저장 (변수는 1개)

<배열 선언>
// stack이라는 영역(메모리)에 공간을 생성하는 것
자료형[] 배열명;
ex ≫ int[] score;

<배열 할당>
// Heap 메모리 영역에 새롭게 공간을 만드는 것
// new 연산자를 이용한다
// 배열은 stack에 바로 값을 저장하지 않음
자료형[] 배열명 = new 자료형[배열 크기];
ex ≫ int[] 배열명 = new int[5];
　: Heap 메모리 영역에 int만 들어갈 수 있는 5개 공간 만들겠다.

＊1. new 연산자를 이용해 Heap 메모리 영역에 공간을 만듦
　2. 동시에 그 공간에 대한 주소 값이 발생하게 됨
　3. 발생한 주소 값은 대입 연산자로 인해 배열에 저장됨
　4. 배열의 주소 값을 따라가 해당 인덱스를 참조하여 값을 처리

＊Heap 메모리 영역에 공간을 만들면
　해당 자료형의 기본 값으로 전부 채워짐

＊클래스(참조 자료형) 안에는 주소 값이 담겨 있음 (ex.String)
　배열 또한 참조 자료형이니 결국 주소 값을 가지고 있음


<배열 초기화>

1. 인덱스를 이용한 초기화 (하나씩)
　arr[0] = 1;

2. for문을 이용한 초기화 (값이 규칙적일 때)
　＊ .length는 .length()와 다름

　length는 배열 길이를 나타내는 변수로 쓰이고,
　length()는 소괄호로 문자열 길이를 나타내는 메소드

3. 선언과 동시에 초기화
// 알아서 배열의 개수를 파악해 공간을 만들고 값을 넣는다
　int[] arr = {1, 2, 3, 4, 5}
　①int[] arr;
　　arr = new int[5]
　②int[] arr = new int[5]
　arr[0] = 1;
　arr[1] = 2;
　arr[2] = 3;
　arr[3] = 4;
　arr[4] = 5;

＊생성했던 배열 크기를 변경했을 때
　새로운 Heap 메모리 주소가 생기는 이유

≫ 변수를 그대로 사용해도 new 연산자로 인해
　해당 공간에 대한 새로운 주소 값이 생기게 됨
　(크기 만큼 새로운 자리를 찾으려고)
≫ 원래 배열 크기는 변경 안됨 : 새로 생성

＊배열이름 = null;로 배열 삭제 가능

< 얕은 복사 >
객체의 주소 값만 가져와 참조형 변수에 저장하고
하나의 객체를 두 변수가 참조하는 것
- 같은 공간을 참조하고 있다 (같은 원본)
- 원본이 바뀌면 복사본도 함께 바뀜

< 깊은 복사 >
새로운 배열 객체를 생성하여
기존 배열의 데이터를 복사하는 것
- 기존 데이터를 새로운 공간에 넣음
- 얕은 복사와 달리 원본 배열이 바뀌어도
　복사된 배열에는 영향을 끼치지 않는다

1. for문을 사용한 1:1 복사
　for(int i = 0; i < originArr.length; i++){
　　copyArr[i] = origintArr[i];
　}
2. arraycopy
　arraycopy(원본배열, 복사 시작 위치(제로인덱스기반), 복사배열, 붙여넣기 시작할 위치(제로인덱스기반), 복사 길이)
　ex) System.arraycopy(originArr, 0, copyArr, 3, originArr.length);
3. Arrays.copyOf ★ (Arrays 클래스에 있는 copyOf)
　Arrays.copyOf(original 원본배열, newLength 복사할 길이, 새로운 배열의 크기);
　ex) copyArr = Arrays.copyOf(originArr, originArr.length);
　(얕은 복사가 되는 개념만 이해하면 됨)

---

< 객체 >
new 연산자를 통해 Heap 메모리 영역에 생성된 것
→ 이러한 객체와 객체 사이에 상호 작용을 하며
　일하는 것이 객체 지향이다
→ 자동으로 해당 자료형 기본 값으로 초기화

＊ 객체와의 상호 작용으로 발생한 모든 사건의 개념을
컴퓨터로 옮겨 만든 것을 객체 지향 언어라고 한다

< 객체 지향의 3대 특징 >
캡슐화 / 상속 / 다형성 + 추상화

 

<객체(Instance)의 할당 >

예) Student s = new Student()

Stack에 Student 클래스(자료형, 타입)의 참조변수 s를 선언,

new 연산자 + 생성자로 Heap 메모리에 공간 생성 (객체 생성/주소값 반환)
≫ 참조변수 s는 생성된 객체의 주소를 참조한다

< 캡슐화 >
외부에서 데이터에 접근하지 못하도록 막는 것
데이터 은닉화 상태에 외부에서 응용할 수 있는 기능을 넣어둔 것
+ 캡슐화까지 적용되어 있는 상태를 '클래스'라 일컫는다

< 캡슐화 원칙 >
- 멤버 변수 접근 권한은 private이 원칙
(캡슐로 감싸는 것을 private 이라고 한다)
- 멤버 함수는 클래스 밖에서 접근하도록 public 설정

＊멤버 변수 = 필드 = 멤버 필드 = 전역 변수
＊멤버 함수 = 메소드 = 클래스 안에 있는 것

< 상속 >
다른 클래스가 가지고 있는 멤버들을 새로 작성할 클래스에서
직접 만들지 않고 상속을 받음으로 새 클래스가 자신의 멤버처럼 사용할 수 있는 기술

≫ 부모 클래스가 가진 멤버를 후손 클래스에서  extends 상속을 받음으로써

　부모 클래스가 가진 멤버를 자신의 멤버처럼 사용할 수 있는 기술

< 다형성 >
상속이 먼저 기반이 되어 자식 객체를 부모 객체 타입 하나로 다룰 수 있는 기술

< 추상화 abstraction >
추상화 작업을 통해 공통적인 것만 추출해 클래스를 만드는 것
유연성을 확보하기 위해 구체적인 것은 제거

 

▽ 

< 클래스 >
[접근제한자] [예약어] Class 클래스명 {}
// 접근제한자, 예약어는 생략 가능

< 클래스 접근제한자 > 2개
접근제한자 4개 중 2개 ≫ public, default // 생략 가능

< 소스 파일 구성 순서 (src) >
1. package문
2. import문
3. 클래스 선언

< import문 >
같은 패키지 있을 때는 안 해도 됨
java.lang 패키지 내 클래스는 안 함
+) 서로 다른 패키지에 속한 같은 이름 클래스를
　import 할 때는 클래스 앞에 패키지 명 적어 구분

< 필드(Field) >
＊멤버 변수 = 필드 = 멤버 필드 = 전역 변수

< 필드 표현식 >
[접근제한자] [예약어] 자료형 변수명[=초기값];

< 필드 접근제한자 > 4개

접근제한자 생략 시 default

public : 모든 곳
protected : 해당 클래스 / 같은 패키지 / 후손 클래스
(default) : 해당 클래스 / 같은 패키지
private : 해당 클래스

따로 설계 목적이 없는 한 캡슐화 원칙으로 private 사용

< 필드 예약어 static >
static은 공유
프로그램 시작하자마자 static 메모리 영역에 올라감 → 프로그램을 끌 때 같이 내려감
프로그램 시작부터 끝까지 사용할 변수가 필요하거나
모든 객체에 공동으로 사용할 게 필요하면 static 사용

< static 변수 = 클래스 변수 >
static 변수는 프로그램 시작 시 메모리 올라가고, 끝날 때 없어져 객체 만들 필요가 없다
↔ 인스턴스 변수는 객체를 만들어야 메모리에 올라감
∴ 인스턴스 변수는 객체 생성에 영향을 받지만 static 변수는 객체 생성과 상관이 없다

static 변수는 클래스명.변수명 으로 불러야 한다 (이래서 클래스 변수라 함)
ex) KindsOfVariable2.staticNum = 10; < 값을 넣어야 필드에 초기화

< 필드 예약어 final >
한 번만 저장하겠다는 의미 (상수)

＊static과 final은 자주 같이 쓰인다
　고정되어 있는 상태를 공유하는 경우 多
ex) public static final double PI = 3.14;

< 생성자 >
객체가 new 연산자를 통해 Heap 메모리에 할당될 때
객체 안에서 만들어지는 필드(전역 변수)를 초기화하는 역할

(Heap 메모리에 올라가고 나면 해당 기본 값으로 초기화되는데,

전달 받은 초기 값을 필드에 초기화해주는 역할/ 일종의 메소드)

< 생성자 규칙 >
1. 생성자명은 클래스명과 똑같아야 함 ★
2. 메소드 선언과 유사하나 반환 타입을 적으면 안 됨
3. 기본 생성자 없이 매개변수 생성자를 하나라도 만들면
　JVM이 기본 생성자를 만들어주지 않는다

< 생성자 표현식 >
[접근제한자] 클래스명() {}
[접근제한자] 클래스명(매개변수) { this.필드명 = 매개변수;}

< 기본 생성자 >
작성 안 하면 클래스 사용시 JVM이 자동으로 기본 생성자 생성

대부분 접근 제한자로 public 사용

순서 : 필드 - 생성자 - 메소드 순으로 대부분 작성

< 매개변수 생성자 >
객체 생성시 매개변수로 전달 받은 값을 통해
필드를 초기화 하기 위해서 사용한다
+) 매개변수 생성자를 만들려면 꼭 기본 생성자를 정의하자
++) 타입(자료형), 개수는 정의된 대로 작성해야 한다.

< 오버로딩 >
한 클래스 안에 같은 이름의 메소드를 여러 개 작성하도록 하는 기법
- 조건 : 같은 메소드 이름 / 매개변수의 개수, 타입, 순서 중 하나라도 달라야 함

< 오버라이딩 >
자식 클래스가 상속 받은 부모 메소드를 재작성 하는 것 (super)

< this (참조 변수) >
모든 인스턴스 메소드에 숨겨진 채 존재하는 래퍼런스(참조 변수)로 할당된 객체를 가리킴
함수 실행 시 전달되는 할당된 객체의 주소를 자동으로 받는다
≫ this에는 현재 내가 만든 객체의 내 주소 값이 담겨 있음

< this() (생성자) >
같은 클래스 내 다른 생성자를 불러오는 것
this(name, age); ≪ 이게 this 생성자
this.height = height;

< 메소드 (Method) > // 멤버 함수
수학 함수와 비슷하고 정의해 놓은 메소드를 호출해 사용

< 메소드 표현식 >
[접근제한자] [예약어] 반환형 메소드명 ([매개변수]) { 기능 정의 }

< 메소드 접근제한자 > 4개
필드 접근제한자와 동일 (재 첨부)

 

< 메소드 예약어 > 5개
static　// static 영역에 할당 객체 생성 없이 사용
final　// 종단, 상속 시 오버라이딩 불가능
abstract　// 미완성된, 상속 후 오버라이딩으로 완성해야 함
synchronized　// 동기화 처리, 공유 자원에 한 개 스레드 접근 가능
static final　// static + final 둘의 의미를 다 가짐 (final static)

< 메소드 반환형 > 4개
void　// 반환형이 없음을 의미, 없으면 반드시 작성
기본형　// 그 타입의 값 자체
배열　// 안에 담긴 주소 값이 반환돼 변수에 담김 (얕은 복사)
클래스　// 안에 담긴 주소 값이 반환됨 (얕은 복사)

< 메소드 매개변수 >
() 　// 매개변수 없는 것
기본 자료형　// 값을 복사하여 전달
배열, 클래스　// 참조형을 전달할 때 데이터 주소 값을 전달해 매개변수를 수정하면 본래 데이터 수정됨 (얕은 복사)
가변인자　// 매개변수 개수 유동적 설정하는 방법 ex) printf() (몇 개가 들어올지 모르니까)

< setter 메소드 >
어떤 값을 받아 변경할 때 씀 set필드명

< getter 메소드 >
어떤 값을 반환하려면 get필드명

 

< 객체 배열 >

객체를 여러 개 저장하는 배열 (객체가 담긴 배열)

배열에 기본 자료형 대신 객체가 들어가는 것만 다름

 

객체 배열 각 인덱스(공간 하나)에

해당하는 공간은 레퍼런스 변수(참조 변수, 클래스)가 됨

왜냐면 주소 값을 가지고 있기 때문! // 그래서 객체 생성, 초기화 필수!

 

< 클래스(객체) 기본 값>

null ≫ Heap 메모리 영역에 올라갈 때 기본 값으로 채워짐

 

< 객체 배열 선언 할당 >

선언 : 클래스명[] 배열명;

ex) Acadamy[] arr;

할당 : 배열명 = new 클래스명[배열크기]

ex) arr = new Acadamy[5];

선언과 할당 동시에 하기: 클래스명[] 배열명 = new 클래스명[배열크기];

ex) Academy[] arr = new Academy[5];

 

< 객체 배열 주의사항 >

공간만 생성해 놓은 참조형 변수(레퍼런스 변수)에서

메소드를 호출하려고 하면 nullPointerException 발생

ex) Person[] pArr = new Person[5]; // 배열크기가 5인 객체 배열 선언 할당

　여기서 pArr[0].getAge를 바로 해버리면? nullPointerException. 

≫ 각 인덱스 별 공간에 객체를 생성하고 대입한 후 메소드를 호출해야 함.