코딩일기

IO (Input & Output) 

IO클래스 : Input & Output의 약자로서, 내외부의 데이터 자료를 사용해야 할 때 유용한 클래스이다.

스트림(Stream) : 입출력 장치에서 데이터를 읽고 쓰기 위해서 자바에서 제공하는 클래스로,

데이터가 지나다니는 길이라고 생각하면 된다. 

• 자바에서 모든 데이터는 스트림을 통해 입출력된다.
• 모든 스트림은 단방향으로만 통신이 가능하다. (입출력을 동시에 수행할 수 없다)
• 외부에서 내부로 들어오는 InputStream과, 내부에서 외부로 나가는 OutputStream이 있으며,
  하나의 스트림으로 동시에 두 가지 흐름을 제어할 수는 없다.
• 실제 프로그램에서 데이터의 입력은 '키보드, 파일 ,네트워크' 로부터 입력될 수 있고,
  데이터의 출력은 '모니터의 화면, 파일' 로 출력될 수 있다.

예제 1.

<ByteArrayIOStream>

public class IOTest01 {
	public static void main(String[] args) {
		//바이트 배열을 만들고 거기 값을 읽어오기
		byte[] input = { 1, 3, 5, 7, 9, 12, -1, 15, 18, 21, 90 };
		byte[] output = null;
		
		//input 통로 생성
		ByteArrayInputStream bais = null;
		bais = new ByteArrayInputStream(input);
		
		//output 통로 생성
		ByteArrayOutputStream baos = null;
		baos = new ByteArrayOutputStream();
		
		//읽거나 쓰는 바이트를 담을 변수
		int data = 0;
		//읽은 data를 검사해서 -1이면 read()중지하기
		//-1은 더이상 읽을 값이 없다는 반환값
		//스트림에서 하나의 바이트를 읽는 대표적 메소드read()
		//read() : 읽은 바이트의 값을 정수(int)로 리턴
		
		while (true) {
			data = bais.read();	//하나하나 읽어오기
			if(data == -1) {
				break;
			}
			baos.write(data);	//옮긴 결과
		}
		
		output = baos.toByteArray();
		
		System.out.println(Arrays.toString(input));
		System.out.println(Arrays.toString(output));
		System.out.println("두개 비교하기");

[실행결과]

[1, 3, 5, 7, 9, 12, -1, 15, 18, 21, 90]
[1, 3, 5, 7, 9, 12, -1, 15, 18, 21, 90]
두개 비교하기

예제 2.

<ByteArrayIOStream 2>

package IO;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;

//여러개 읽어오기
public class IOTest02 {
	public static void main(String[] args) {

		byte[] input = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 };
		byte[] output = null;
		
		//.read 할 때 데이터를 읽을 배열이 필요하므로 미리 선언해두어야 한다. 
		byte[] temp = new byte[3];
		
		ByteArrayInputStream bais = new ByteArrayInputStream(input);
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		
		int data;
		
		try {
			//.read(배열) : 배열의 길이 반환
			//만약 bais에 값이 없다면 -1 반환
			while ((data = bais.read(temp)) != -1) {		
				
				System.out.println("data : " + data);
				//.write(배열, 시작위치, 끝위치);
				baos.write(temp, 0, data);
				
			} 
			
		} catch (IOException e) {
			e.printStackTrace();
		}
		output = baos.toByteArray();
		System.out.println(Arrays.toString(input));
		System.out.println(Arrays.toString(output));

	}
}

[실행결과]

data : 3
data : 3
data : 3
data : 3
data : 1
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

예제 3.

<ByteArrayIOStream 3>

package IO;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class IOTest03 {
	public static void main(String[] args) {
		
		byte[] input = {0,1,2,3,4,5,6,7,8,9,-1};
		byte[] output = null;
		byte[] temp = new byte[3];
		
		ByteArrayInputStream bais = new ByteArrayInputStream(input);
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		
		//bais.available() : bais 속에 있는 값 전체의 수
		//bais.read(배열) : 배열의 길이 반환. 
		while (bais.available() > 0) {
			System.out.println(bais.available() + " 길이");
			try {
				int len = bais.read(temp);//temp를 통해 read한 만큼 bais의 길이는 줄어든다. 
				System.out.println(len + " temp속의 길이");
				baos.write(temp, 0, len);//내용, 시작, 끝. (끝 index의 값은 포함되지 않음) 
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		output = baos.toByteArray();
		System.out.println(Arrays.toString(input));
		System.out.println(Arrays.toString(output));
		
	}
}

[실행결과]

11 길이
3 temp속의 길이
8 길이
3 temp속의 길이
5 길이
3 temp속의 길이
2 길이
2 temp속의 길이
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1]

예제 4.

<FileReader>

package IO;

import java.io.BufferedReader;
import java.io.FileReader;

public class IOTest04 {
	public static void main(String[] args) {
		
		FileReader fr = null;//파일 읽어오는 변수
		BufferedReader br = null;//불러온 파일을 보여주는 변수
		
		try {
			//fr = new FileReader("c:\\temp\\temp.txt"); 와 같은 표현
			fr = new FileReader("c:/temp/temp.txt");
			
			//문자열을 이어서 한 객체에 넣어두고 출력하기 위해서 스트링 버퍼를 사용
			StringBuffer sb = new StringBuffer();
			
			//.readLine() : 한 줄 읽기 
			//line에 br의 한 줄을 읽어서 저장
			//더이상 저장할 것이 없으면 반복문 멈추기
			br = new BufferedReader(fr);
			String line = null;
			while ((line = br.readLine()) != null) {
				System.out.println(line);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
}

[실행결과]

c:/temp/temp.txt CONTENT

(c:/temp/temp.txt 속의 내용)

예제 5.

<FileIOStream>

package IO;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class IOtest05 {
	public static void main(String[] args) {
		
		//파일 경로를 주고 해당 파일을 읽어오고 파일로 출력하기
		FileInputStream fis = null;
		FileOutputStream fos = null;
		
		try {
			fis = new FileInputStream("c:\\temp\\temp.txt");
			fos = new FileOutputStream("c:\\temp\\out.txt");
			
			int data = 0;
			byte[] temp = new byte[5];
			
			while ((data = fis.read(temp)) != -1) {
				fos.write(temp, 0, data);
			}
			
			System.out.println("파일 저장 완료");
			
			while ((data = fis.read(temp)) != -1) {
				char c = (char) data;
				fos.write(c);
			}		
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			try {
				fos.close();
				fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
	}
}

[실행결과]

파일 저장 완료

(c:/temp/temp.txt 속의 내용을 c:/temp/out.txt 에 출력 )

예제 6.

<FileInputStream 없이 FileOutputStream에 직접 쓰기>

package IO;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class IOTest06 {
	public static void main(String[] args) {
		
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream("c:\\temp\\fos.txt");

			for (int i = 0; i < 10; i++) {
				String data = i + "번째 줄 입력 \r\n";//줄바꿈
				fos.write(data.getBytes());//바이트로 파일에 직접쓰기
			}
			System.out.println("저장완료 ");
			/* FileOutStream에 값을 쓸 때는 byte로 변환합니다.
			 * getByte()를 이용했습니다.
			 * FileWriter는 String을 직접 씁니다.
			 * 
			 */
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
				
			}
		}	
	}
}

• close( ) : 열린 파일 객체를 닫아주는 메소드
  자바가 종료될 때 열린 파일의 경우 자동으로 닫아주기는 하지만 직접 닫아주는 것이 좋은데,열었던 파일을 닫지 않고 다시 사용하려고 하면 에러가 나는 경우가 있기 때문이다.

[실행결과]

저장완료

(c:/temp/fos.txt 에 (0 ~ 9번째 줄 입력 \r \n) 출력)

예제 7.

<FileWriter>

package IO;

import java.io.FileWriter;
import java.io.IOException;

public class IOTest07 {
	public static void main(String[] args) {
		try {
			FileWriter fw = new FileWriter("c:\\temp\\fileWriter.txt");
			for (int i = 0; i < 10; i++) {
				String data = i + "번째 입니다. \r\n";
				fw.write(data);//String이 그대로 들어갔습니다.
			}
			fw.close();
		} catch (IOException e) {
			
			e.printStackTrace();
		}
		
	}
}

[실행결과]

(c:/temp/fileWriter.txt 에 (0 ~ 9번째 입니다. \r \n) 출력)

예제 8.

<FileWriter 2>

package IO;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Scanner;

public class IOTest08 {
	public static void main(String[] args) {
		//사용자가 -1이라고 입력하면 입력을 멈추고 입력된 내용을 저장하기
		Scanner sc = new Scanner(System.in);
		StringBuffer sb = new StringBuffer();
		String temp = "";

		while (true) {//입력대기 만들기
			System.out.println("입력할 문장을 입력하세요.");
			System.out.println("-1을 입력하면 종료됩니다.");
			temp = sc.next();
			if(temp.equals("-1")){
				break;
			}
			sb.append(temp + "\r\n");//줄바꿈 포함해서 sb에 저장
		}
		
		try {
			FileWriter fw = new FileWriter("c:\\temp\\write.txt");
			fw.write(sb.toString());
			fw.close();
			
			//저장된 내용을 화면에 출력하기
			FileReader fr = new FileReader("c:\\temp\\write.txt");
			BufferedReader br = new BufferedReader(fr);//fr보다 조금 더 큰
			
			//위 두 문장을 합친다면 아래와 같이 
			BufferedReader br2 = 
					new BufferedReader(
							new FileReader("c:\\temp\\write.txt"));
			
			String line = "";
			while ((line = br.readLine()) != null) {//읽을것이 없으면 null			
				System.out.println(line);
			}
			
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		
	}
}

[실행결과]

입력할 문장을 입력하세요.
-1을 입력하면 종료됩니다.
1번째 문장
입력할 문장을 입력하세요.
-1을 입력하면 종료됩니다.
입력할 문장을 입력하세요.
-1을 입력하면 종료됩니다.
2번째_문장
입력할 문장을 입력하세요.
-1을 입력하면 종료됩니다.
3번째문장
입력할 문장을 입력하세요.
-1을 입력하면 종료됩니다.
4번째문장!
입력할 문장을 입력하세요.
-1을 입력하면 종료됩니다.
5..번..째..문..장..
입력할 문장을 입력하세요.
-1을 입력하면 종료됩니다.
-1
1번째
문장
2번째_문장
3번째문장
4번째문장!
5..번..째..문..장..

(c:/temp/write.txt 에 해당 출력값 출력)

예제 9.

<FileWriter 이어쓰기>

• FileWriter("경로",true)

package IO;

import java.io.FileWriter;
import java.io.IOException;

//FileWriter 이어쓰기
public class IOTest09 {
	public static void main(String[] args) {
		
		try {
			FileWriter fw = new FileWriter("c:\\temp\\write.txt");
		
			for (int i = 0; i < 10; i++) {
				String data = i + "번째 줄을 씁니다.\r\n";
				fw.write(data);
			}
			fw.close();
			
			//이어쓰기 
			FileWriter fw2 = new FileWriter("c:\\temp\\write.txt", true);
			
			for (int i = 10; i < 20; i++) {
				String data = i + "번째 줄을 씁니다.\r\n";
				fw2.write(data);
			}
			fw2.close();
			
			
			System.out.println("이어쓰기 완료");
			
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
		
	}
}

[실행결과]

이어쓰기 완료

(c:/temp/write.txt 에 (0 ~ 9 번째 줄을 씁니다. \r \n) 출력 후 이어서

(10 ~ 19 번째 줄을 씁니다. \r \n) 출력)

Inner Class : 클래스 내부에 선언된 클래스

• 내부 클래스는 클래스 내에 선언되므로 인스턴스 속성 변수처럼 활용된다
  즉 메소드 { } 안에서만 유효하다.
  
  
• 인스턴스 변수는 클래스 내에서 선언되지만 메소드 밖에서, 생성자 밖에서, 다른블록 밖에서 선언된다.
  이 경우 반드시 초기화가 필요하다
  
  
• 내부 클래스는 외부 클래스의 멤버를 활용할 수 있지만
  외부 클래스는 내부 클래스의 멤버 변수를 활용할 수 없다.
  
  
• static이 붙은 메소드 내에서는 내부 클래스의 객체 선언을 할 수 없다.
  
  
• 정적 클래스 static이 아닌 경우(static선언이 없으면) 내부 클래스라고 부른다.
  
  
• 일반적으로 AWT, Swing 등의 GUI 이벤트 처리 외에는 잘 사용되지 않는다.

ex)

class A{

	class B{
    
	}
}

B는 A의 내부 클래스이고, A는 B의 외부 클래스이다. 

※ 내부 클래스 B는 외부 클래스인 A가 아닌 클래스에서 잘 사용되지 않아야 한다. 

외부 클래스가 아닌 다른 클래스에서 내부 클래스에 접근해야 한다면 내부 클래스로 선언해서는 안 되는 클래스를 내부 클래스로 선언했다는 의미이기 때문이다.

내부 클래스의 장점

1. 내부 클래스에서 외부 클래스의 멤버들에게 쉽게 접근 가능하다.
2. 코드의 복잡성을 줄여준다. (캡슐화)

내부 클래스(Inner Class)의 종류와 특징

1. 스태틱 클래스 (Static Class)

• 외부 클래스의 멤버 변수 위치에 선언된다.
• class 앞에 static이 붙어있다.
• static이 붙어있기 때문에 객체 생성없이 사용 가능하다.
• 외부 클래스의 static변수처럼 사용된다.
• 외부 클래스와 내부 클래스는 다르게 동작한다.
• 외부 클래스와 내부 클래스의 멤버가 private라도 상호 접근 가능하다
• 경로만 지정된다면 단독으로 직접 사용할 수 있다.
• 주로 외부 클래스의 static멤버, 특히 static메소드에서 사용된다.

public class StaticClass01 {
	private int num = 1;			//객체 생성, 외부X
	int sc = num;				//객체 생성. 외부O
	private static int outterSI = 0;	//클래스명. 객체X, 외부X
	public static void outterMethod() {
		System.out.println(SInner.innerSM);
	}
	
	public static class SInner{
		private int innerMember = 200;
		private static int innerSM = 300;
		final int LV = 100;
		
		public static void innerMethod() {
			System.out.println("static 클래스 내부 static 메소드");
		}
		
		public void innerM() {
			System.out.println("static 클래스 내부 클래스");
			System.out.println("this.innerSM " + this.innerSM);
			//System.out.println("sc " + sc); 호출 불가
			System.out.println("outterSI" + outterSI);
		}
		
	}
	
	public static void main(String[] args) {
		StaticClass01 staticClass01 = new StaticClass01();
		StaticClass01.SInner si = new SInner();
		StaticClass01.SInner si2 = new StaticClass01.SInner();
		
		si.innerMethod();
		si.innerM();
	
		
		StaticClass01.SInner.innerMethod();
		//StaticClass01.SInner.innerM();객체 생성 후 호출
		
		
		//AAA객체 생성
		AAA aaa = new AAA();
		//System.out.println(aaa.BBB..);	//불가
		//System.out.println(AAA.BBB.);		//안보임
		AAA.BBB bbb = new AAA.BBB();
	}
}
//private : 같은 클래스에서만 접근 가능
//내부 클래스 - 외부 클래스 서로 접근 가능
class AAA{
	private static int innerNum = BBB.number;	//내부 클래스의 private 접근 가능
	private static int outternum = 100;
	
	static class BBB{
		private static int number = 10;
		int number2 = outternum;		//외부 클래스의 private도 접근 가능
		
	}
}

[실행결과]

static 클래스 내부 static 메소드
static 클래스 내부 클래스
this.innerSM 300
outterSI0
static 클래스 내부 static 메소드

2. 멤버 클래스 (Member Class)

• 외부 클래스의 멤버 변수 위치에 선언된다.
• 외부 클래스의 인스턴스 멤버처럼 사용된다.
• 멤버 변수와 같은 성질을 가진다.
• 주로 외부 클래스의 인스턴스 멤버들과 관련된 작업에서 사용된다.

public class MemberClass01 {
	private int outerDf = 10;
	private static int osi = 55;
	int number = 777;
	
	void outerMethod() {
		System.out.println(number);
		System.out.println(osi);
		System.out.println(this.osi);
	}
	
	static void outterSM() {
		System.out.println(osi);
		//System.out.println(number);	//X
	}
	
	public class InnerClass{
		private int x = 100;
		int innerDf = 100;
		static final int ISI = 123;
		
		public void innerMethod() {
			int imnum = osi;	//외부 클래스 private static int osi = 55;
			System.out.println(x);
			System.out.println(innerDf);
			System.out.println(ISI);
			System.out.println(number);
			System.out.println(outerDf);
		}
		
	}
	
	public static void main(String[] args) {
		MemberClass01 memberClass01 = new MemberClass01();
		
		//MemberClass01.InnerClass in = new MemberClass01.InnerClass();
		MemberClass01.InnerClass in = memberClass01.new InnerClass();
		in.innerMethod();
		//내부 클래스 -> 입출력 -> 쓰레드 -> 네트워킹 -> 그래픽
	}

[실행결과]

100
100
123
777
10

3. 지역 클래스 (Local Class)

• 외부 클래스의 메소드나 초기화 블럭 안에서 선언된다.
• 메소드 안에서만 지역변수처럼 클래스를 활용하므로 메소드의 실행이 끝나면 지역 클래스는 제거된다.
• 외부에서 인스턴스를 생성할 수 없다.
• static을 사용할 수 없다.
• 인스턴스 변수 또는 메소드는 사용 가능하다.
• final이 붙은 지역변수(상수)나 매개변수는 지역 클래스의 메소드에서 접근 가능하다.
• 객체를 생성해서 활용해야 한다.
• 컴파일 하면 외부 클래스$숫자+로컬 클래스명.class로 만들어진다.
  (숫자는 서로 다른 메소드인 경우 같은 이름의 클래스가 존재할 수 있어서 구분하기 위해서 붙인다.)
• 선언된 영역 내부에서만 사용된다.

public class LocalClass01 {
	private int a = 10;
	final int LV = 100;
	
	void method() {
		int in = 100;
		final int inD = 1000;
		
		class LocalClass{
			int no = 99;
			void msg() {
				no = no + 10;
				System.out.println("외부 a " + a);
				System.out.println(LocalClass01.this.a);
				System.out.println(in);
				System.out.println(inD);
			}
		}	//LocalCalass 끝
		//지역 클래스가 선언된 메소드 안에서 객체를 만든다.
		LocalClass local = new LocalClass();
		local.msg();	//객체 생성 후에 호출해서 사용한다.
		
	}		//메소드 끝
	
	public static void main(String[] args) {
		LocalClass01 localClass01 = new LocalClass01();
		localClass01.method();
	}

[실행결과]

외부 a 10
10
100
1000

4. 익명 클래스 (Anonymous Class)

• 클래스 이름이 없는 클래스
• new 슈퍼클래스 또는 인터페이스명( ){ };
• 선언과 동시에 인스턴스 생성을 하나로 통합한다.
• 클래스를 인수의 값으로 활용한다.
• 클래스의 선언부가 없기 때문에 이름이 없으므로 생성자를 가질 수 없다.
• 슈퍼 클래스의 이름이나 구현할 인터페이스를 구현하거나 둘 이상의 인터페이스를 구현할 수 없다.
  (오직 하나의 클래스를 상속받거나 하나의 인스턴스만 구현 가능)
• 코드 블럭에 클래스 선언을 하는 점만 제외하고는 생성자를 호출하는 것과 동일하다.
• 객체를 구성하는 new문장 뒤에 클래스의 블럭{ }을 첨부하여 몸통을 닫는 형식으로 구성된다.
• 객체를 생성한 후에 { }; 즉 메소드를 구현한 블록이 있고 블록 끝에는 세미콜론이 붙는다.
• new 뒤에 오는 생성자명이 기존 클래스명이면 익명 클래스가 자동으로 클래스의 하위 클래스가 된다.
• 인터페이스인 경우에는 인터페이스를 상속하는 부모 클래스가 Object가 된다.
• 객체를 한번만 사용할 경우 사용된다. (일회성)

interface Sound{	
	abstract void sound();//불완전 요소
}

abstract class Animal{
	String name;
	int age;
}

class Cat extends Animal implements Sound{

	@Override
	public void sound() {
		
	}
}

class Dog{
}
class Mouse{
}

class AMClass{
	public void method() {
		System.out.println("method");
	}
}

public class Anonymous {
	public static void main(String[] args) {
		//상속 -> 추상화 -> 인터페이스 -> 다형성
		//List<String> list = new List<String>();
		//이렇게 만들 수 없다. = 미구현된 메소드 완벽 X
		//인터페이스는 상속받는 자식 클래스로 생성
		AMClass amc = new AMClass() {
			@Override
			public void method() {
				System.out.println("오버라이드 했습니다.");
			}
		};
		
		amc.method();
				
	}
}

[실행결과]

오버라이드 했습니다.

BinaryTree : 여러개의 노드(node)가 트리형태로 연결된 구조

루트(root) 라고 불리는 하나의 노드에서 시작해 각 노드에 최대 2개의 노드를 연결할 수 있는 구조
 
연결된 두 노드를 부모-자식 관계에 있다고 하며 
위에 있는 노드를 부모노드, 아래 노드를 자식노드라고 한다.
하나의 부모노드는 최대 두개의 자식 노드와 연결될 수 있다.
 
첫번째 저장하는 값은 루트 노드가 되고 두번째 값은
루트 노드에서 값의 크기를 비교하면서 트리를 따라 내려간다.
(숫자가 아닌 문자를 저장할 경우 = 문자의 유니코드값을 비교)

부모 노드를 기준으로 부모 노드보다 작은 값은 왼쪽에, 큰 값은 오른쪽에 저장하면
왼쪽 마지막 노드가 제일 작은 값, 오른쪽 마지막 노드가 제일 큰 값이 된다.

TreeSet

이진트리를 기반으로 한 set
하나의 노드는 노드 값인 value와 왼쪽과 오른쪽 자식 노드를 
참고하기 위한 두개의 변수로 구성되어 있다.
 
TreeSet에 값을 저장하면 자동으로 정렬된다.
(부모 값과 비교해서 낮은 것은 왼쪽에, 높은 것은 오른쪽에 저장)

• first() 가장 작은 값 리턴
• last() 가장 큰 값 리턴
• lower(v) v보다 작은 바로 아래 값 리턴
• higher(v) v보다 바로 위의 객체 리턴
• floor(v) v와 동등한 객체가 있으면 리턴, 없으면 바로 아래 값 리턴
• ceiling(v) v와 동등한 객체가 있으면 리턴, 없으면 상위 객체 리턴
• pollFirst() 제일 낮은 객체를 꺼내오고 컬랙션에서 삭제
• pollLast()  제일 높은 객체를 꺼내오고 컬랙션에서 삭제

Exception : 실행시에 발생할 수 있는 모든 에러상황들

자바에서는 예외를 두고 목적에 따라서 처리(핸들링)하도록 설계되어있다.

또한 예외는 객체이기 때문에 클래스로 정의되어 있다.

특정 API는 컴파일시 예외를 처리하지 않으면 컴파일 되지 않는 예외들도 있다.

자바에서 예외가 발생되는 순서

1. 컴파일
2. 실행
3. 실행중 예외 발생
4. VM이 발생한 예외의 종류 및 내용을 파악한 뒤 예외 객체 생성
5. 발생된 코드 밖으로 예외 던지기(예외 처리하기) 
6. 예외의 콜 스택에 전이
7. main메소드 밖까지 던지게 되면 프로그램 비정상 종료

예외 처리 방법

try를 활용하여 오류를 막고 다른 부분까지 실행되게 할 수 있다.

1. 예외 복구

예외가 발생하여도 정상적으로 실행되도록 하는 것

try{
	예외가 발생할만한 코드;
}catch(예외종류 e){
	예외가 발생하면 실행할 코드;
 }finally{
	예외 발생유무와 상관없이 반드시 실행해야 할 코드;
}

2. 예외 회피

메소드 뒷부분에 throw 처리할 예외타입을 적어주면
메소드가 실행되다가 예외를 만나면 메소드를 호출한쪽으로 예외를 던진다.
main메소드의 경우 VM으로 던진다. 

3. 직접 예외 객체 만들어서 처리하기
예외 객체를 만들어서 처리하기

throw 객체명;
	@override
	public void printStrackTrace(){
		super.printstrackTrace();
		System.out.println("계산 불가");
	}

Throwable : 예외의 상위클래스

예외의 상위클래스는 lang패키지의 Throwable이며, 자식클래스는 Error와 Exception이 있다.

• 에러 (Error) : 개발자가 미리 예측할 수 없는 오류
  일반적으로 JVM(Java Virtual Machine)에 관련된 에러 상황들을 정의한 클래스 이다.
  따라서 프로그래머는 Error 타입들의 예외(에러)는 처리할 방법이 없어 무시한다.
  - 시스템 레벨에서 발생하는 에러
  - 심각한 오류로 더 이상의 실행이 불가능
  
  
• 예외 (Exception) : 개발자가 미리 예측이 가능한 오류
  프로그래머가 '예외 처리'(Exception Handling)를 통해 예외 상황을 처리할 수 있다.
  - 프로그래머가 구현한 로직에서 발생
  - 경미한 오류로 복구가 가능
  
  ▶ 예외의 종류
  • 알려지지 않는 예외 (Unchecked Exception)
    컴파일러가 관여하지 않으면서 실행시에 예외가 발생할수도, 발생하지 않을수도 있는 예외
    프로그램을 작성하면서 예외를 발생시키지 않도록 주의
    - 예외 처리를 할 필요가 없음
    
    
  • 알려진 예외 (Checked Exception)
    컴파일러가 관여하는 예외
    치명적인 예외 상황을 발생시키므로 반드시 예외를 처리해야한다.
    - 예외 처리가 강제 (예외 처리 코드를 작성하지 않을 경우 컴파일 오류 발생)
    
    ※ Exception하위 클래스 중 RuntimeException 클래스의 자식 클래스들은 모두 알려지지 않은 예외이고,
    나머지는 알려진 예외이다.