JAVA_2

Week 3.

-반복문: for, while, do while

-for문: ```
for (초기문; 조건식; 반복 후 작업){
..작업문..
}

	>for문 내에서 변수 선언 O
    ex) for (int i=0; i<10; i++){}
    //이때 변수 i는 for문 내에서만 사용 가능!
    

-while문: ```
while(조건식){
..작업문..
}

-do-while문: ```
do {
..작업문..
}while(조건식);

	>중첩반복문,, -> 2중/3중 반복이 적당!
    >index는 되도록 안헷갈리게 i, k, r 쓰기

-continue문 : 다음 반복 진행
-break문 : 반복문 종료! (중첩 시 break가 묶인 첫번째 괄호 반복문을 '하나만' 탈출!)

-**.equals() -> 문자열 전체를 비교!
ex) "hellomyname~".equals("hello")
//비교하면 같은 문자열이 Xx

-배열 -> 객체! >> 변수 선언&생성의 두 단계 필요

>선언: 레퍼런스 변수 선언
int intArray[]; or int[] intArray;
//메모리를 잡아주지 X
//**[] 안에 숫자 적으면 X**
//intArray

>생성: 배열의 저장공간 할당
intArray = new int [10]; or int intArray[] = new int[10];
//new : 배열 생성
//intArray : 배열 이름처럼 사용!, 변수이므로 바뀔 수도 O(이때 레퍼런스 변수가 가리키는 배열이 달라지면 그 전에 생성된 배열은 접근할 수 X, 가비지 값이 되어버림)

>선언과 생성 한번에 가능
int intArray[] = new int[5];
int intArray[] = {0, 1, 2, 3, 4};
// 초기화된 값의 개수만큼의 배열 생성(선언과 함께 초기화)
//선언부: int intArray[]
//	>이때 [] 안에 크기를 주면 X!! 그냥 레퍼런스

-배열 원소 접근: intArray[0]
ex)```
intArray[2] = 5;
int n = intArray[2]; // n = 5

반드시 배열 생성 후 접근
인덱스의 범위,, C와 달리 음수 사용 불가

-하나의 배열을 다수의 레퍼런스가 참조 가능!

int intArray[] = new int[5];
int myArray[] = intArray;
//두 레퍼런스가 배열을 공유! > 데이터 변질 우려.
intArray[1] = 2;
myArray[1] = 6; //가리키는 배열 인덱스 1의 값(2)이 6으로 바뀜

레퍼런스가 없으면 그 배열에 접근 불가,,, 가비지값이 되어버림!

-배열은 자바에서 객체로 관리 > new 연산자로 생성
->객체 내의 length 필드: 배열의 크기를 나타냄 (속성! 메소드아님) (잡아놓은 사이즈 의미,,, 들어가 있는 갯수 X)

ex)```
int intArray[];
intArray = new int[5];
int size = intArray.length; //size = 5

-레퍼런스는 가변적이다.

-for-each문:
for(변수: 배열의 레퍼런스){
...반복할 작업문...
}
// 배열의 인덱스 순서대로 데이터를 가져와서 변수에 저장 > 작업 > 다음 인덱스값 변수에 저장> ,,,, > 배열 끝날 때까지!

ex)```
int[] num = {1, 2, 3, 4, 5}
int sum =0;
for(int x: num){ //x와 달리 미리 선언한 변수는 사용불가!
	sum+=x;
}

-나열(enum): 이것도 객체!
enum 열거체이름 {상수1이름, 상수2이름, ...}
//이름이니까 큰따옴표 사용 Xx

>ex)```
enum Rainbow{RED(3), ORANGE(10),...}

-values() 메소드 -> 상수이름 저장한 배열 생성해서 반환.

>ex) ```
enum week(월, 화, ... , 일); 			//월의 값은 0, 화의 값은 1
for(week day: week.values()){ 		//week.values()는 배열!
	System.out.println(day + "요일");
} 									//월요일화요일...

-다차원 배열,, 복잡해서 2차원 넘어서는 안만드는 것을 추천
<2차원 배열>

int intArray[]; 			//선언
intArray = new int[2][5]; 	//생성
// 2차원 배열에서 행의 각 원소는 1차원 배열의 레퍼런스가 된다.

레퍼런스는 1차원 배열들의 레퍼런스들의 배열을 참조한다.

ex)```
int i[][] = new int[2][5];
int size = i.length; //2
//i[n].length는 n번째 행의 열 개수 ex) i[0].length는 5
// >굳이 행 지정 이유: 가변성 존재하기 때문!

-비정방형 배열

int i[][];
i = new int[4][]; //비워놓고 하나씩 값 넣기,, length 달라지게,,!
i[0] = new int[1];
i[1] = new int[2];

>명시적 X,, 가변적으로 쓸 땐 length 사용하기!

-메소드의 배열 리턴(배열의 레퍼런스 리턴)

int[] makeArray(){ //int[]: 리턴타입 >>리턴타입과 뱅려 타입 일치시켜야 함!!
	int temp[] = new int[4];
    return temp; //배열리턴
}

-선언하지 않은 메모리에 접근하면,, Java는 다 죽임!

Week 4.

-main() 메소드 : 자바 응용프로그램의 실행 시작 메소드

public static void main (String[] args){
}

>public: 다른 클래스에서 메소드 접근 허용
>static: 객체 생성 전부터 호출 가능
>void: 리턴값 X
>String[]: 문자열 배열 (반드시 매개변수 타입은 문자열 배열!)
>args: 매개변수

-예외처리

>컴파일 오류
>예외 : 오동작이나 결과에 악영향을 미칠 수 있는 실행 중 발생한 오류 ex) 0으로 나눈다거나,,
	->예외 발생 > 자바 플랫폼 인지 > 응용program 전달 > 응용program이 처리하지 못하면 강제 종료!
    

-try-catch-finally문 (예외가 발생할 때 대응하는 응용program 코드)

```
try{
	예외가 발생할 가능성이 있는 실행문 (try 블록)
}
catch(처리할 예외타입(예외클래스) 선언)
	예외처리문 (catch 블록)
finally{ //이 블록은 생략O
	예외 발생 여부와 상관없이 무조건 실행되는 문장 (finally 블록)
}

-객체인데 아직 할당 안된,, > NULL

-세상 모든 것이 객체(object)
객체마다 고유한 특성state과 행동behavior을 가짐
-객체지향언어의 3가지 특성 : 캡슐화, 상속, 다형성(여러 모양을 갖는 함수들 제공)

1. 캡슐화: 객체(=특성+행동)를 캡슐로 싸서 내부를 볼 수 없게 하는 것

   		>객체의 본질적 특징 : 외부의 접근으로부터 객체 보호

   -클래스(class): 객체 모양을 선언한 틀(캡슐화)

   >메소드(멤버함수)와 필드(멤버변수)는 모두 클래스 내에 구현 (설계도)

   -객체(object): 클래스의 모양대로 생성된 실체(instance), 객체 내 데이터에 대한 보호, 외부 접근 제한
   // -> 접근지정자 사용,, 등,, 일부 접근 제한! 공개할 건 공개!
   (객체 외부에서는 공개된 메소드를 통해 비공개 멤버 접근)

   클래스는 메모리에 올라가지 X

2. 상속(Inheritance): 상위 객체의 속성이 하위 객체에 물려짐
   자식 클래스가 부모 클래스의 속성을 물려받고, 기능 확장,, > extends 키워드 사용 (설계도가 2개~~)

   >부모 클래스: 슈퍼클래스
   >자식 클래스: 서브클래스(-> 수퍼클래스 재사용 & 새로운 특성 추가)

   Java: 클래스 다중 상속 Xx,, 인터페이스 다중 상속 O
   계층을 잘 나눠서 상속받게 설계해야 좋음!

3. 다형성: 같은 이름의 메소드가 클래스나 객체에 따라 다르게 동작하도록 구현

   >사례: **메소드 오버라이딩Overriding** : 슈퍼클래스의 메소드를 서브클래스마다 다르게 구현 (상세한 내용은 다르게,,!) -> (상속을 받아도,,,) **상위계층 메소드 재구현**
   메소드 오버로딩Overloading: 클래스 내에서 같은 이름이지만 다르게 작동하는 여러 메소드 구현 (명시적으로 구분은 해야해! 입력 받는 값을 다르게,,,)

-객체지향 언어의 목적: 소프트웨어의 생산성 향상(재사용, 수정 용이), 실세계에 대한 쉬운 모델링

-객체지향: 관계, 상호작용
vs 절차지향: 작업순서

-객체: 메모리 공간을 차지하는 실제적인 것, 물리적으로 존재하거나 추상적으로 생각할 수 있는 것 중에서 자신의 속성을 가지고 있고 다른것과 식별 가능한 것

객체 = 속성(필드) + 동작(메소드)

-public -> 접근지정자(접근 권한 관련) //다른 모든 클래스의 접근 허용
-class -> 클래스 선언 (클래스 이름은 항상 대문자 시작!)

-필드(변수) : 외부에 공개
-생성자-> class 이름과 동일하게!,
일반 함수 생성과 동일하게,,이때 리턴 타입이 존재하지 X

-클래스 선언
-필드와 메소드

>필드: 객체 내에 값을 저장하는 멤버 변수 (메소드 내의 변수와는 구분)
>메소드: 함수,,, 객체의 행동(행위)을 구현

-생성자(Constructor): 클래스의 이름과 동일한 특별한 메소드, 객체가 생성될 때 자동으로 한 번 호출되는 메소드
개발자는 객체 초기화 (==필드 초기화)하는 데 필요한 코드 작성
-객체 생성: new 키워드를 이용하여 생성
(new 객체 생성한 후 객체의 생성자 호출)

과정: 객체에 대한 레퍼런스 변수 선언 -> 객체 생성(클래스 타입 크기의 메모리 할당, 객체 내 생성자 코드 실행)
객체의 멤버(필드/메소드) 접근: 점(.) 연산자
ex)```
public static void main(String args[]){
	Circle pizza;
    pizza = new Circle();
    pizza.radius = 10;
    pizza.name = "자바피자"; //객체의 멤버 접근
    double area = pizza.getArea();

ex1) ```
Circle pizza;
pizza = new Circle(); 			//Circle 객체 생성
ex2)
Circle donut = new Circle();	//Circle 객체 생성

-생성자 -> default로 제공되기도 O
명시적으로 작성 안하면 자동으로 빈 생성자 생성!

-생성자: 객체가 생성될 때 초기화를 위해 자동 실행되는 메소드

>생성자는 객체가 생성될 때 반드시 호출됨.
(하나 이상 선언되어야 함! 작성 안하면 자동으로 기본 생성자 삽입)
>이름은 **클래스 이름과 반드시 동일**
>여러개 작성 O(오버로딩)
>객체당 하나의 생성자가 한 번 호출!
>생성자는 리턴 타입을 지정할 수 X (리턴타입 작성 아예 Xx)

-입력 파라미터 X -> 기본 생성자
매개변수 있는 것도 만들거면, 없는 기본형도 만들어주기!
하나라도 생성자가 명시적으로 작성되어 있으면 기본생성자 자동 생성 X

선언된 생성자와 입력된 생성자의 매개변수 타입이 안맞으면 error!

오버로딩 오류(매개변수 타입이 같게 두 개의 이름 같은 생성자를 만들면 > 실행은 되지만 두번째 정의된 것이 무시됨!)

타입 두 종류가 순서만 다르게 해서 정의하면,,??

-기본생성자(default constructor): 매개변수 X, 아무 작업 X, 단순 리턴하는 생성자
(의도적으로 빼는게 아니면 넣기!)

-this: 객체 자신에 대한 레퍼런스

>this.멤버 형태로 멤버 사용
>this의 필요성: 1. 객체의 멤버 변수와 메소드 변수의 이름이 같은 경우
	ex)```
public class ~~{
	int **radius**;
}
public Circle(int _radius_){
	this. **radius** = _radius_;

			2. 메소드 호출 시 객체 자신의 레퍼런스를 전달할 때
            3. 메소드가 객체 자신의 레퍼런스를 반환할 때

-this(): 클래스 내의 다른 생성자 호출
생성자 내에서만 사용 가능, 반드시 생성자 코드의 제일 처음에 생성!

ex)```
public Circle(){
	int **radius**;
    String **name**;
}
public Circle(int _radius_){
	this("수원"); 	//두번째 Circle 생성자 정의가 실행됨
    this.**radius** = _radius_;
}
public Circle(String _name_){
	this.**name** = _name_;
}
public static void main(String[] args){
	Circle pizza = new Circle(100);
    // 매개변수로 100만 넣었는데 pizza.radius -> 100, pizza.name -> "수원" 이 저장됨! 
    ...
}

-객체의 치환: 객체가 복사되는 것이 X, 레퍼런스가 복사됨!

>객체치환(ob1 = ob2) 후
	-> ob1이 가리키던 객체(A)는 아무도 가리키지 X
    -> 프로그램은 더이상 "객체A"에 접근 불가
    (객체A는 garbage!!!)