Dreaming Dean

File and Stream I/O 파일 및 스트림 I/O

Dean92 — Fri, 9 Jun 2017 18:37:58 +0900

입출력 I/O

I/O는 Input & Output 의 약자로 입력과 출력을 뜻하고 컴퓨터 내부 또는 외부 장치와 프로그램 사이에 데이터를 주고받는 것을 일컫는다.

입출력의 범위와 모델

입출력 대상이 달라지면 프로그램상에서의 입출력 방식도 달라지는 것이 보통이다. 그런데 자바에서는 입출력 대상에 관계없이 입출력의 진행방식이 동일하도록 별도의 “I/O 모델”을 정의하고 있다.

I/O 모델의 정의로 인해서 입출력 대상의 차이에 따른 입출력 방식의 차이는 크지 않다. 기본적인 입출력의 형태는 동일하고 이것이 Java의 I/O 스트림이 가지는 장점이다.

▼ 일반적인 입출력 대상

키보드와 모니터

하드디스크에 저장되어 있는 파일

USB와 같은 외부 메모리 장치

네트워크로 연결되어 있는 컴퓨터

사운드, 오디오카드와 같은 멀티미디어 장치

프린터, 팩시밀리와 같은 출력장치

파일 스트림

파일 대상 바이트 입력 스트림

스트림의 생성은 결국 인스턴스의 생성을 의미하고 FileInputStream은 InputStream 클래스를 상속한다. InputStream 클래스는 모든 입력 스트림 클래스의 최상위 클래스이다.

▼ InputStream 클래스의 대표 메소드

메소드	설명
void close()	스트림을 닫음으로써 사용하고 있던 자원을 반납한다.
abstract int read()	1 byte를 읽어온다. 더 이상 읽어 올 데이터가 없으면 -1을 반환한다. abstract메소드이기 때문에 InputStream의 자손들은 상황에 맞게 구현해야 한다.

입력의 대상에 적절하게 read 메소드가 정의되어 있고 입력의 대상에 따라서 입력 스트림을 의미하는 별도의 클래스가 정의되어 있다.

InputStream in = new FileInputStream(“run.exe”);
Int bData = in.read();       // 오버라이딩에 의해 FileInputStram의 read 메소드 호출됨

파일 대상의 입력 스트림 생성

파일 대상 바이트 출력 스트림

▼ OutputStream 클래스의 대표 메소드

메소드	설명
void close()	입력소스를 닫음으로써 사용하고 있던 자원을 반환한다.
abstract write(int b)	주어진 값을 출력소스에 사용한다.

		OutputStream out = new FileOutputStream("home.bin");
		out.write(1);			// 4바이트 int형 정수 1의 하위 1바이트만 전달된다.
		out.write(2);			// 4바이트 int형 정수 2의 하위 1바이트만 전달된다.
		out.close();				// 입력 스트림 소멸

파일 대상의 출력 스트림 생성 및 데이터 전송

파일 복사 테스트

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;



public class FileInputStreamTest {

	public static void main(String[] args) throws IOException {
		InputStream in = new FileInputStream("c:/test.bin");
		OutputStream out = new FileOutputStream("c:/copy_test.bin");
		
		int bData = 0;
		
		while(true) {
			bData = in.read();
			if (bData == -1) {
				break;
			}
			out.write(bData);
		}
		
		in.close();
		out.close();
	}

}

문자 스트림

FileReader/FileWriter

▼ Reader 클래스의 대표 메소드

메소드	설명
int read()	입력소스로부터 하나의 문자를 읽어 온다. char의 범위인 0~65535 범위의 정수를 반환하며 입력스트림의 마지막 데이터에 도달하면 -1을 반환한다.
int read(char[ ] c, int off, int len)	입력 소스로부터 최대 len 개의 문자를 읽어서 배열 c의 지정된 위치(off)로 부터 읽은 만큼 저장한다. 읽어 온 데이터의 개수 또는 -1을 반환한다.

▼ Write 클래스의 대표 메소드

메소드	설명
void write(int a)	주어진 값을 출력소스에 쓴다.
abstract void write(char[ ] c, int off, int len)	주어진 배열 c에 저장된 내용 중에서 off번째부터 len 길이만큼만 출력소스에 쓴다.

BufferedReader/BufferedWriter

BufferedReader/BufferedWriter는 버퍼를 사용해서 입출력의 효율을 높일 수 있도록 해준다.

문자열의 입력

BufferedReader 클래스의
public String readLine() 메소드 이용
└ readLine()은 데이터를 라인단위로 읽어 온다.

문자열의 출력

Writer 클래스의
public String write() 메소드 이용

// 문자열 출력을 위한 스트림의 구성
BufferedWriter out = new BufferedWriter(new FileWriter("StrInt.txt"));
//문자열 입력을 위한 스트림의 구성
BufferedReader in = new BufferedReader(new FileReader("StrInt.txt"));

File 클래스

- File 클래스가 지원하는 기능

디렉터리의 생성과 소멸

파일의 소멸

디렉터리 내에 존재하는 파일이름 출력

File myDir = new File("C:\\Dean\java");	// 디렉터리 위치 정보
myDir.mkdir();	// 디렉터리 생성

디렉터리 생성


File myFile = new File("c:\\Dean\myJava.bin");
File myFile = new File("c:\\Dean2\myJava.bin");
myFile.renameTo(reFile);	// 파일 이동

파일이동, renameTo 는 파일의 이름을 변경하는 메소드이고 경로의 변경에 사용이 가능하다.

File myFile("C:" + File.separator + "Dean" + File.separator + "myJava.bin");

운영체제에 따라 구분자 치환

상대경로

실제 프로그램 개발에서는 절대경로가 아닌 상대경로를 이용하는 것이 일반적이다. 왜냐하면 상대경로를 이용해야 실행환경 및 실행위치의 변경에 따른 문제점을 최소화 할 수 있기 때문이다.

// 현재 디렉터리 기준
File subDir1 = new File("AAA");
// 현재 디렉터리에 존재하는 AAA의 하위 디렉터리 BBB
File subDir2 = new File("AAA\\BBB");
// AAA\\BBB의 운영체제에 상관없이 실행 가능한 코드
File subDir3 = new File("AAA" + File.separator + "BBB");

File 클래스 기반 I/O 스트림 생성

// FileInputStream의 생성자
public void FileInputStream(File file) throws FileNotFoundException 
//FileOutputStream의 생성자
public void FileOutputStream(File file) throws FileNotFoundException 
//FileInputStream의 생성자
public void FileReader(File file) throws FileNotFoundException 
//FileInputStream의 생성자
public void FileWriter(File file) throws IOException

File inFile = new File(data.bin);
if(inFile.exists()==false) {
	// 데이터를 읽어 들일 대상 파일이 존재하지 않을 때 필요한 처리
}
InputStream in = new FileInputStream(inFile);

Collection Framework 컬렉션 프레임워크(2/2)

Dean92 — Fri, 9 Jun 2017 16:54:11 +0900

Iterator

Iterator는 컬렉션 프레임워크에서 컬렉션에 저장된 요소들을 읽어오는 방법을 표준환 한 것이다.

Collection 인터페이스에는 iterator라는 이름의 메소드가 다음의 형태로 정의되어 있다.

Iterater<E> iterator() { …. }

iterator 메소드가 반환하는 참조값의 인스턴스는 Iterator<E> 인터페이스를 구현하고 있다.

iterator 메소드가 반환한 참조값의 인스턴스를 이용하면 컬렉션 인스턴스에 저장된 인스턴스의 순차적 접근이 가능하다.

iterator 메소드의 반환형이 Iterator<E>이니, 반환된 참조값을 이용해서 Iterator<E>에 선언된 함수들만 호출하면 된다.

▼ Iterator인터페이스에 정의된 메소드들

메소드	설명
boolean hasNext()	참조할 다음 번째 요소Element가 존재하면 true를 반환한다.
E next()	다음 번 요소를 반환한다.
void remove()	현재 위치의 요소를 삭제한다.

import java.util.Iterator;
import java.util.LinkedList;

public class IteratorTest {

	public static void main(String[] args) {
		LinkedList<String> list = new LinkedList<String>();
		list.add("First");
		list.add("Second");
		list.add("Third");
		list.add("Fourth");
		
		// iterator 메소드가 생성하는 인스턴스를 '반복자'라고 한다.
		Iterator<String> itr = list.iterator();
		
		System.out.println("반복자를 이용한 1차 출력과 \"Third\" 삭제");
		
		while(itr.hasNext()) {
			String curStr = itr.next();
			System.out.println(curStr);
			if(curStr.compareTo("Third")==0) {
				itr.remove();
			}
		}
		
		System.out.println("\n\"Third\" 삭제 후 반복자를 이용한 2차 출력");
		itr = list.iterator();
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

Iterator의 장점

반복자를 사용하면 컬렉션 클래스의 종류에 상관없이 동일한 형태의 데이터 참조방식을 유지할 수 있다.

따라서 컬렉션 클래스의 교체에 큰 영향이 없다.

컬렉션 클래스 별 데이터 참조방식을 별도로 확인할 필요가 없다.

컬렉션 클래스 기본자료형 저장

ArrayList arr = new ArrayList();      //error
LinkedList linl = new LinkedList();   //error

기본 자료형 정보를 이용해서 제네릭 인스턴스는 생성 불가능하다. 그러므로 Wraper 클래스를 기반으로 컬렉션 인스턴스를 생성해야 한다.

import java.util.Iterator;
import java.util.LinkedList;

public class IteratorTest {

	public static void main(String[] args) {
		LinkedList<Integer> list = new LinkedList<Integer>();
		list.add(10);		// Auto Boxing
		list.add(20);		// Auto Boxing
		list.add(30);		// Auto Boxing

		Iterator<Integer> itr = list.iterator();

		while(itr.hasNext()) {
			int num = itr.next();	// Auto Boxing
			System.out.println(num);
		}
	}
}

Auto Boxing과 Auto Unboxing의 도움으로 정수 단위의 데이터 입출력이 매우 자연스럽다.

HashSet

HashSet은 Set인터페이스를 구현하는 대표적인 컬렉션으로 Set의 특징과 같이 중복된 요소를 저장하지 않는다. HashSet은 ArrayList와 달리 저장순서를 유지 하지 않는다.

List<E>를 구현하는 클래스들과 달리 Set<E>를 구현하는 클래스들은 데이터의 저장순서를 유지하지 않는다.

List<E>를 구현하는 클래스와 달리 Set<E>를 구현하는 클래스들은 데이터의 중복저장을 허용하지 않는다. 단, 동일 데이터에 대한 기준은 프로그래머가 정의한다.

Set<E>를 구현하는 클래스는 “집합”의 성격을 지닌다.

import java.util.HashSet;
import java.util.Iterator;

public class IteratorTest {

	public static void main(String[] args) {
		HashSet<String> hSet = new HashSet<String>();
		hSet.add("First");
		hSet.add("Second");
		hSet.add("Third");
		hSet.add("First");
		
		System.out.println("저장된 데이터 수 : " + hSet.size());
		
		Iterator<String> itr = hSet.iterator();
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

동일한 문자열의 인스턴스는 저장되지 않았다.

TreeSet

TreeSet은 이진 검색 트리라는 자료구조의 형태로 데이터를 저장하는 컬렉션이다. TreeSet은 Set인터페이스를 구현하여 중복된 데이터의 저장을 허용하지 않으며 정렬된 위치에 저장되므로 저장순서를 유지하지 않아도 된다.

TreeSet<E> 클래스는 트리라는 자료구조를 기반으로 데이터를 저장한다.

데이터를 정렬된 순서로 저장하며 HashSet<E>와 마찬가지로 데이터의 중복을 허용하지 않는다.

정렬의 기준은 프로그래머가 직접 정의한다.

import java.util.Iterator;
import java.util.TreeSet;

public class IteratorTest {

	public static void main(String[] args) {
		TreeSet<integer> sTree = new TreeSet<integer>();
		sTree.add(1);
		sTree.add(2);
		sTree.add(4);
		sTree.add(3);
		sTree.add(2);
		
		System.out.println("저장된 데이터 수 : " + sTree.size());
		
		Iterator<integer> itr = sTree.iterator();
		while(itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

데이터는 정렬되어 저장이 되며, iterator메소드의 호출로 생성된 반복자는 오름차순의 데이터 참조를 진행한다.

HashMap

HashMap은 Map을 구현하여 키Key와 값Value을 묶어서 하나의 데이터로 저장한다. HashMap은 해싱Hashing을 사용하여 많은 양의 데이터를 검색하는데 높은 성능을 보여준다.

Map 인터페이스를 구현하는 컬렉션 클래스는 key-value 방식의 데이터 저장을 한다.

Value는 저장할 데이터를 의미하고, Key는 value를 찾는 열쇠를 의미한다.

Map 를 구현하는 대표적인 클래스로는 HashMap과 TreeMap 이 있다.

TreeMap 은 정렬된 형태로 데이터가 저장된다.

import java.util.HashMap;

public class IteratorTest {

	public static void main(String[] args) {
		HashMap<Integer, String> hMap = new HashMap<Integer, String>();
		
		hMap.put(new Integer(3), "정동현");
		hMap.put(5, "안상현");
		hMap.put(8, "양동구");
		
		System.out.println("6학년 3반 8번 학생 : " + hMap.get(new Integer(8)));
		System.out.println("6학년 3반 5번 학생 : " + hMap.get(5));
		System.out.println("6학년 3반 3번 학생 : " + hMap.get(3));
		
		hMap.remove(5);		// 5번 데이터 제거
		System.out.println("6학년 3반 5번 학생 : " + hMap.get(5));
	}

}

Collection Framework 컬렉션 프레임워크(1/2)

Dean92 — Tue, 6 Jun 2017 16:37:15 +0900

컬렉션 프레임워크

컬렉션 프레임워크에서 컬렉션은 다수의 데이터, 데이터그룹을 뜻하고 프레임워크는 표준화된 프로그래밍 방식을 뜻한다. 즉 컬렉션 프레임 워크란 데이터 군을 저장하는 클래스들을 표준화 한 것이다.

컬렉션 프레임워크는 컬렉션들과 다수의 데이터를 사용하는 데 필요한 다양하고 유용한 클래스들을 제공한다.

컬렉션 프레임워크 구조

인터페이스 List와 Set을 구현한 컬렉션 클래스들의 공통부분을 뽑아 만든 것이 Collection인터페이스 이다. Map은 이들 컬렉션과 전혀 다른 형태 이므로 공통부분이 없다.

Collection 인터페이스를 구현하는 제네릭 클래스

- 인스턴스 단위의 데이터 저장 기능을 제공(배열과 같이 단순 인스턴스 참조 값 저장)

Map

- key-value 구조의 인스턴스 저장 기능 제공

▼ 컬렉션 프레임워크 인터페이스

인터페이스	특징	사용 예	구현클래스
List	순서가 있는 데이터의 집합. 데이터 중복 허용	대기자 명단	ArrayList, LinkedList, Stack, Vector 등
Set	순서를 유지하지 않는 데이터 집합. 데이터 중복 허용않함	양의 정수집합, 소수 집합	HashSet, TreeSet 등
Map	키Key와 값Value의 쌍으로 이루어진 데이터 집합, 순서는 유지되지 않고 키는 중복을 허용하지 않으며 값은 중복이 허용된다.	우편번호, 전화번호	HashMap, TreeMap, Hashtable, Properties

컬렉션 인터페이스 메소드

▼ 컬렉션 인터페이스에 정의된 메소드들

메소드	설명
int size()	원소의 개수 반환
boolean isEmpty()	공백 상태이면 true 반환
boolean contains(Object obj)	obj를 포함하고 있으면 true 반환
boolean add(E element)	원소 추가
boolean remove(Object Obj)	원소 삭제
Iterator iterator()	원소 확인
boolean addAll(Collection c)	c에 있는 모든 원소 추가
boolean containsAll(Collection c)	c에 있는 모든 원소가 포함되어 있으면 true
boolean removeAll(Collection c)	c에있는 모든 원소 삭제
void clear()	모든 원소 삭제
Object[ ] toArray()	컬렉션을 배열로 변환
T[ ] toArray(T[ ] a)	컬렉션을 배열로 변환

Collection 인터페이스는 컬렉션 클래스에 저장된 데이터를 읽고 추가/삭제하는 등 컬렉션을 다루는데 기본적인 메소드들을 가지고 있다.

List 인터페이스

List는 중복을 허용하면서 저장순서가 유지되는 컬렉션을 구현하는데 사용된다.

▼ List 인터페이스에 정의된 메소드들

메소드	설명
void add(int index, Object element) boolean addAll(int index, Collection c)	지정된 위치Index에 객체Element 또는 컬렉션에 포함된 객체들을 추가한다.
Object get(int index)	지정된 위치Index에 있는 객체를 반환한다.
...	나머지는 api문서를 참고한다.

Set 인터페이스

Set은 중복을 허용하지 않고 저장순서가 유지되지 않는 컬렉션 클래스를 구현하는 데 사용한다.

Map 인터페이스

Map 인터페이스는 키Key와 값Value을 하나의 쌍으로 묶어서 저장하는 컬렉션 클래스를 구현하는 데 사용된다. 키는 중복을 허락하지 않고 값은 중복이 허용된다.

▼ Map 인터페이스에 정의된 메소드들

메소드	설명
void clear()	Map의 모든객체를 삭제한다.
boolean containsKey(Object Key)	지정된 Key와 일치하는 Map의 Key객체가 있는지 확인한다.
boolean containsValue(Object Value)	지정된 Value와 일치하는 Map의 Value객체가 있는지 확인한다
Object get(Object key)	지정한 key객체에 대응하는 value객체를 찾아서 반환한다.
...	나머지는 api문서를 참고한다.

ArrayList

ArrayList는 List인터페이스를 구현하여 데이터의 저장순서가 유지되고 중복을 허용하는 특징을 갖게 된다.

List 인터페이스를 구현하는 대표적인 제너릭 클래스

- ArrayList, LinkedList

List 인터페이스를 구현한 클래스의 인스턴스 저장 특징

- 동일한 인스턴스의 중복 저장을 허용한다.
- 인스턴스의 저장 순서가 유지된다.


import java.util.ArrayList;

public class ArrayListTest {

	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		
		// 데이터 저장
		list.add(new Integer(11));
		list.add(new Integer(22));
		list.add(new Integer(33));
		
		// 데이터 참조
		System.out.println("1차 데이터 참조");
		for(int i=0; i<list.size(); i++) {
			// 0이 첫번 째
			System.out.println(list.get(i));
		}
		
		// 데이터 삭제
		list.remove(0);		// 0이 전달되었으므로 첫번 째 데이터 삭제
		System.out.println("2차 데이터 참조");
		for(int i=0; i<list.size(); i++) {
			System.out.println(list.get(i));
		}
	}

}

LinkedList

크기를 변경할 수 없고 비순차적인 데이터의 추가 또는 삭제에 걸리는 시간이 오래걸리는 단점을 가진 배열을 보완하기 위해 만들어진 자료구조가 LinkedList이다. LinkedList는 자료구조가 불연속적으로 존재하는 데이터를 서로 연결Link한 형태로 아래 그림과 같이 존재한다.

데이터의 저장방식

- ‘리스트’라는 자료구조를 기반으로 데이터를 저장한다.

사용방법

- ArrayList와 사용방법이 비슷하지만 데이터를 저장하는 방식에서 큰 차이가 난다.
- 대부분의 경우 ArrayList를 대체해서 사용할 수 있다.


import java.util.LinkedList;

public class ArrayListTest {

	public static void main(String[] args) {
		LinkedList<Integer> list = new LinkedList<Integer>();
		
		// 데이터 저장
		list.add(new Integer(11));
		list.add(new Integer(22));
		list.add(new Integer(33));
		
		// 데이터 참조
		System.out.println("1차 데이터 참조");
		for(int i=0; i<list.size(); i++) {
			// 0이 첫번 째
			System.out.println(list.get(i));
		}
		
		// 데이터 삭제
		list.remove(0);		// 0이 전달되었으므로 첫번 째 데이터 삭제
		System.out.println("2차 데이터 참조");
		for(int i=0; i<list.size(); i++) {
			System.out.println(list.get(i));
		}
	}

}

ArrayList Vs. LinkedList

	장점	단점
ArrayList	데이터의 참조가 용이해서 빠른 참조가 가능하다.	저장소의 용량을 늘리는 과정에서 많은 시간이 소요된다. 데이터의 삭제에 필요한 연산과정이 매우 길다.
LinkedList	저장소의 용량을 늘리는 과정이 간단하다. 데이터의 삭제가 매우 간단하다.	데이터의 참조가 비교적 불편하다.

Generics 제너릭

Dean92 — Mon, 5 Jun 2017 23:02:32 +0900

제너릭Generics

제너릭은 JDK 1.5버전에서 처음 도입 되었다. 제너릭은 다양한 타입의 객체들을 다루는 메소드나 컬렉션 클래스의 타입을 컴파일 과정에서 체크(compile time type check)해주는 기능을 한다. 객체 타입을 컴파일 시에 체크하기 때문에 객체 타입 안정성이 높아지고 형변환의 불편함이 줄어든다.

- Generics 장점

타입 안정성을 제공한다.

타입체크 과정과 형변환 과정을 생략 할 수 있으므로 코드가 줄어든다.

"제너릭은 다루게 될 객체의 타입을 미리 명시함으로써 번거러운 형변환을 줄이는 기능을 한다."

제너릭 클래스

제너릭 클래스 선언

제너릭은 클래스와 메서드에 모두 선언할 수 있다. 클래스에 제너릭을 선언하기 위해선 클래스 옆에 괄호와 타입변수를 선언 해 주면 된다.

class GenericsClass {		// 제너릭 타입 T를 선언함
	T item;
	
	void setItem(T item) { this.item = item; }
	T getItem() { return item; }
}

T는 타입변수(Type variable)라고 하며 꼭 T가아닌 다른 것을 사용해도 된다. 타입 변수가 여러개인 경우에는 Map와 같이 콤마를 사용해서 나열하면 된다.

▼ 타입 매개변수 표기

표기	의미
E	Element
K	Key
N	Number
T	Type
V	Value
S, U, V	순서 2, 3, 4

이들 기호는 기호의 종류만 다를 뿐 임의의 참조형 타입을 의미한다는 것은 모두 같다.

지네릭 클래스가 된 클래스의 객체를 생성할 때는 참조변수와 생성자에 타입 T대신 사용될 실제 타입을 지정해주어야 한다.

GenericsClass gc = new GenericsClass();	// 타입 T대신 실제 사용할 타입을 지정함
gc.setItem(new Object());		// 컴파일 에러, String 이외 타입은 지정불가함
gc.setItem("ABC");			// String타입이므로 가능함
String item = (String)gc.getItem();	// (String)형변환 필요없음

제너릭 클래스 인스턴스 생성

Box appleBox = new Box();

T를 Apple로 결정하고 Box의 인스턴스를 생성하고 이를 참조할 수 있는 참조변수를 선언해서 참조 값을 저장했다.

Box appleBox = new Box();  // 컴파일에러.

참조변수와 생성자에 대입된 타입(매개변수화된 타입)이 일치해야 한다.

// Apple이 Fruit의 자손일 때
Box appleBox = new Box();

두 타입이 상속관계에 있어도 대입 된 타입이 일치해야 한다.

// FruitBox는 Box의 자손일 때
Box appleBox = new FruitBox();

두 제너릭클래스의 타입이 상속관계에 있고 대입된 타입이 같은 것은 괜찮다.

Box appleBox = new Box();
Box appleBox = new Box<>();    // 생략가능

참조변수의 타입을 추정 가능한 경우 생략이 가능하다.

Exception 예외

Dean92 — Mon, 5 Jun 2017 01:24:05 +0900

오류Error

프로그램 구동 중 오작동을 일으키거나 비정상적 종료를 일으키는 원인을 오류라고 하는데 발생 시점에 따라 분류되는 컴파일 에러, 런타임 에러와 프래그래머의 의도와 다르게 동작하는 논리적 에러가 존재한다.

자바에서는 런타임시 발생할 수 있는 프로그램 오류를 에러Error와 예외Exception 두가지로 구분한다. 에러는 메모리 부족이나 스택오버플로우와 같이 발생하면 복구할 수 없는 심각한 오류들을 뜻하고 예외는 발생하더라도 프로그래머가 작성한 예방 코드로 수습될 수 있는 덜 심각한 오류를 뜻한다.

오류Error 수습될 수 없는 심각한 오류
예외Exception 수습될 수 있는 오류

"오류는 어쩔 수 없지만 예외는 반드시 처리해야 한다."

예외처리

나이를 입력받는데 0보다 작은 값이 입력되었다.

나눗셈 계산을 위해 두개의 정수를 입력 받는데 나누는 수로 0이 입력되었다.

주민등록번호 숫자13자리를 입력 받는데 중간에 ‘-’를 포함한 14자리를 입력 받았다.

위와 같이 프로그램의 실행 도중에 발생하는 문제 상황을 예외라고 한다. 예외는 컴파일 오류같이 문법오류와는 의미가 다르다.

예외처리Exception Handling

정의 – 프로그램 실행 시 발생할 수 있는 예외의 발생에 대비한 코드를 작성한다.

목적 – 프로그램의 비정상 종료를 막고 정상적인 실행상태를 유지한다.

try-catch문

예외를 처리하기위해 try-catch문을 사용한다.

try {
	// 예외 발생 가능성이 있는 코드가 들어간다.
} catch (Exception1 e1) {
	// Exception1이 발생했을 때 처리할 코드가 들어간다.
} catch (Exception2 e2) {
	// Exception2가 발생했을 때 처리할 코드가 들어간다.
}
	...
} catch (ExceptionN eN) {
	// ExceptionN이 발생했을 때 처리할 코드가 들어간다.
}

하나의 try 블럭다음에는 하나 이상의 catch블럭이 올수 있고 이중 발생한 예외 종류와 일치하는 단 하나의 catch블럭만 수행된다. 일치하는 블럭이 없으면 예외처리는 되지 않는다.

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

			} catch (Exception e) {
				// TODO: handle exception
			}
		} catch (Exception e) {
			try {

			} catch (Exception e2) {
				// catch블럭 내에 또 다른 try-catch문이 포함된 경우
				// 다른 이름의 참조변수(e1,e2)를 사용해야 한다.
			}
		}
	}

각 catch블럭 내의 두 참조변수 영역이 겹치므로 다른 이름을 사용해서 구별해 주어야 한다.

try-catch문 실행순서

- try 블럭 내에서 예외가 발생한 경우

발생한 예외와 일치하는 catch블럭이 있는지 검사한다.

일치하는 catch블럭이 존재하면 그 catch블럭 내의 문장들을 수행하고 전체 try-catch문을 빠져나와서 그 다음 코드들을 계속 수행한다. 만약 일치하는 catch블럭이 없다면 예외는 처리되지 않는다.

- try 블럭 내에서 예외가 발생하지 않은 경우

catch블럭을 거치지 않고 전체 try-catch문을 빠져나와 다음 코드를 수행한다.

	public static void main(String[] args) {
		System.out.println(1);
		try {
			System.out.println(2);
		} catch (Exception e) {
			System.out.println(3);
		}
		System.out.println(4);
	}

예외가 발생하지 않았으므로 catch블럭 내의 문장(3이 출력되지 않음)이 실행되지 않았다.

	public static void main(String[] args) {
		System.out.println(1);
		try {
			System.out.println(2);
			System.out.println(100/0);	//예외를 발생시킴 catch블럭으로 이동
			System.out.println(3);		//실행되지 않음
		} catch (ArithmeticException ae) {
			System.out.println(4);
		}
		System.out.println(5);
	}

try블럭에서 예외가 발생(100/0)했기 때문에 try블럭을 바로 벗어나서(3은 출력되지 않음) catch블럭으로 이동해 코드를 실행한 다음 전체 try-catch문을 벗어나서 5를 출력한다.

예외처리 클래스

자바는 실행 시 발생할 수 있는 오류를 클래스로 정의해 놓았다. 모든 클래스의 조상은 Object클래스이므로 Exception과 Error클래스 역시 Object의 자손이다.

모든 예외의 조상은 Exception이다.

RuntimeException 클래스들 – 프로그래머의 실수로 발생하는 예외(언체크 예외)
Exception클래스들 – 사용자의 실수와 같은 외적인 요인에 의해 발생하는 예외(체크 예외)

예외발생과 catch블럭

try블럭에서 예외가 발생하면, 발생한 예외를 처리할 catch블럭을 찾는다.

첫번째 catch블럭부터 순서대로 찾아 내려가며, 일치하는 catch블럭이 없으면 예외는 처리되지 않는다.

예외의 최고 조상인 Exception을 처리하는 catch블럭은 모든 종류의 예외를 처리할 수 있다.(반드시 마지막 catch블럭이어야 한다.)

	public static void main(String[] args) {
		System.out.println(1);
		try {
			System.out.println(2);
			System.out.println(100/0);	//예외를 발생시킴
			System.out.println(3);		//실행되지 않음
		} catch (ArithmeticException ae) {
			if(ae instanceof ArithmeticException) {
				System.out.println("true");
			}
			System.out.println("ArithmeticException");
		} catch (Exception e) {	// ArithmeticException을 제외한 모든 예외가 처리됨
			System.out.println("Exception");
		}
		System.out.println(5);
	}

try-catch문의 마지막에 Exception클래스 타입의 참조변수를 선언한 catch블럭을 사용하면 어떤 종류의 예외가 발생 하더라도 이 catch블럭에 의해 예외가 처리될 수 있다.

예외처리 클래스의 메소드

예외처리 클래스의 특정 메소드를 사용하면 발생한 예외 객체를 catch블럭의 참조변수로 접근할 수 있다.

printStackTrace() – 예외발생 당시의 호출스택(Call Stack)에 있던 메서드의 정보와 예외 메세지를 화면에 출력한다.
getMessage() – 발생한 예외클래스의 인스턴스에 저장된 메세지를 얻을 수 있다.

	public static void main(String[] args) {
		System.out.println(1);
		try {
			System.out.println(2);
			System.out.println(100/0);	//예외를 발생시킴
			System.out.println(3);		//실행되지 않음
		} catch (ArithmeticException ae) {
			//참조변수 ae를 통해 생성된 ArithmeticException의
			//인스턴스에 접근 가능
			ae.printStackTrace(); 
			System.out.println("Exception Message : " + ae.getMessage());
		} 
		System.out.println(5);

printStackTrace() 와 getMessage()메소드를 통해 예외 발생 원인을 분석 할 수 있다.

finally블럭

finally블럭은 try-catch문과 함께 예외의 발생여부에 상관없이 코드가 실행되어야 할 때 사용한다.

예외의 발생여부와 관계없이 실행되어야 하는 코드를 넣는다.

선택적으로 사용할 수 있으며, try-catch-finally의 순서로 구성된다.

예외 발생시, try → catch → finally의 순서로 실행되고
예외 미발생시, try → finally의 순서로 실행된다.

try 또는 catch블럭에서 return문을 만나도 finally블럭은 수행된다.

		try {
			// 예외 발생 가능성이 있는 코드
		} catch (Exception e) {
			// 예외 처리 코드
		} finally {
			// 예외 발생 여부에 상관없이 동작하는 코드
			// try-catch블럭은 맨 마지막에 위치함
		}

예외 던지기

예외를 처리하는 방법에는 try-catch외에도 예외를 메소드에 선언하는 방법(예외 던지기)이 있다.

void method() throws Exception1, Exception2, ... , ExceptionN {
 ...
}

메서드 선언부에 throws를 사용하고 메소드 내에 발생하는 예외를 선언한다.

예외를 처리하는 또 다른 방법이다.

사실은 예외를 처리하는 것이 아니라, 호출한 메서드로 예외 처리 해야할 정보를 전달해주는 것이다.

호출한 메서드에서 예외처리를 해야만 할 때 사용한다.

Abstract class and Interface 추상클래스와 인터페이스

Dean92 — Sun, 28 May 2017 22:35:28 +0900

추상Abstract 클래스

추상 클래스란 클래스가 완성되지 못한(미완성) 상태를 뜻한다. 클래스가 완성되지 못했다는 것은 클래스의 코드가 완전하지 못한 것이 아니라 미완성 메소드(추상 메소드)를 포함하고 있다는 뜻이다. 추상 클래스로는 인스턴스를 생성할 수 없고 상속을 통해 자손클래스를 구현하여 활용하게 된다.

추상 클래스는 바탕이 되는 조상클래스로서 새로운 클래스를 생성할 때 중요한 역할을 한다. 추상 클래스는 클래스 앞에 'abstract'를 붙이면 추상 클래스가 되고 'abstract'가 붙은 클래스는 추상 메서드를 포함하고 있으니 상속을 통해서 구현해야 한다는 것을 알 수 있다.

abstract class 클래스이름 {
..
}

클래스가 설계도라면 추상클래스는 ‘미완성 설계도’로 비유할 수 있다.

추상메서드(미완성 메서드)를 포함하고 있는 클래스를 추상클래스라 한다.

- 추상메서드 : 선언부만 있고 구현부(몸통, body)가 없는 메서드

일반메서드는 추상메서드를 호출할 수 있다. (호출할 때 필요한 건 선언부)

완성된 클래스가 아니므로 인스턴스를 생성할 수 없다.

다른 클래스를 작성하는 데 도움을 줄 목적으로 작성된다.

추상 메소드

추상 메소드는 선언부만 정의(설계만)하고 구현부(실제 구현될 코드)는 정의하지 않은 메소드이다. 추상 메소드를 선언부만 정의하는 것은 메서드의 내용이 상속받는 클래스의 목적에 따라 달라지기 때문에 상속받는 클래스에서 구현하도록 하는 것이 목적이다.

추상 메소드는 메소드 앞에 'abstract'를 붙이면 추상 메소드가 된다. 추상 클래스를 상속받는 자손클래스는 오버라이딩을 통해 조상인 추상클래스의 추상 메소드를 전부 구현해 주어야 한다.

// 주석으로 추상 메소드가 어떤 기능을 구현해야 하는지 알려준다.
abstract 리턴타입 메소드이름();

abstract class Player {
	//음악을 재생시키는 기능을 구현하여야 한다.
	abstract void play(int pos);	//추상메소드
	//음악을 정지시키는 기능을 구현하여야 한다.
	abstract void stop();			//추상메소드
}

class Mp3Player extends Player {
	void play(int pos) { /* 기능 구현 */ }	
	void stop() { /* 기능 구현 */ }		//추상클래스의 추상메서드를 모두 구현했음
}

//추상클래스의 추상메서드를 모두 구현하지 않았으면
//자손클래스 역시 추상클래스로 지정하여야 한다.
abstract class Speaker extends Player {
	void play(int pos) { /* 기능 구현 */ }
}

선언부만 있고 구현부(몸통, body)가 없는 메소드이다.

꼭 필요하지만 자손마다 다르게 구현될 것으로 예상되는 경우에 사용한다.

추상클래스를 상속받는 자손클래스에서 추상메소드의 구현부를 완성해야 한다.

추상 클래스 작성법

상속이 자식 클래스를 만드는데 조상 클래스를 사용하는 것이라면 추상화는 이와 반대로 기존의 클래스의 공통부분을 추출해서 조상 클래스를 만드는 것으로 생각하면 된다.

추상화Abstract 클래스간의 공통부분을 추출하여 조상 클래스를 정의하는 것 Vs. 상속Extends 상속을 통해 자손 클래스를 정의하는 것

abstract class Player {
	boolean pause;				//일시정지 상태를 저장하는 변수
	int playbackLocation;		//재생 위치를 저장하는 변수
	
	Player() {						//추상클래스의 생성자 정의
		pause = false;
		playbackLocation = 0;
	}
	
	//지정된 위치에서 재생을 시작하는 기능을 구현하여야 한다.
	abstract void play(int pos);		//추상메소드
	//재생을 멈추는 기능을 구현하여야 한다.
	abstract void stop();				//추상메소드
	
	void play() {
		play(playbackLocation);		//추상메소드를 사용할 수 있다.
	}
	
	void pause() {
		if(pause) {						//pause가 true(정지)일 때 pause가 호출되면
			pause = false;				//pause에 false를 저장하고
			play(playbackLocation);	//현재위치에서 재생
		} else {							//pause가 false(재생)일 때 pause가 호출되면
			pause = true;				//pause에 true를 저장하고
			stop();							//재생 정지
		}
	}
}

class Mp3Player extends Player {	//Player클래스를 조상으로 정의
	void play(int playbackLocation) { /* 기능 구현 */ }
	void stop() { /* 기능 구현 */ }
	
	int currentTrack;		//Mp3클래스에 새로 추가된 멤버변수
	
	//새로운 기능 추가
	void nextTrack() {
		currentTrack++;
	}
	
	//새로운 기능 추가
	void preTrack() {
		if(currentTrack > 1) {
			currentTrack--;
		}
	}
}

조상 클래스의 추상메소드를 MP3Player클래스의 성격에 맞게 완성하고 MP3Player만의 새로운 기능을 추가하였다.

인터페이스Interface

인터페이스는 추상클래스의 일종으로 추상메소드를 포함하고 있지만 추상화가 심해서 일반 메소드, 멤버변수를 가질 수 없고 오직 추상 메소드와 상수만을 멤버로 가질 수 있다.

일종의 추상클래스. 추상클래스(미완성 설계도)보다 추상화 정도가 높다.

실제 구현된 것이 전혀 없는 기본 설계도(알맹이 없는 껍데기)로 비유할 수 있다.

추상메서드와 상수만을 멤버로 가질 수 있다.

인스턴스를 생성할 수 없고, 클래스 작성에 도움을 줄 목적으로 사용된다.

미리 정해진 규칙에 맞게 구현하도록 표준을 제시하는 데 사용된다.

인터페이스 작성법

인터페이스를 작성하는 방법은 클래스를 작성하는 방법과 동일한데 'class' 키워드 대신 'interface' 키워드를 사용하면 된다.

interface 인터페이스이름 {
	public static final 타입 상수이름 = 상수값;
	public abstract 메서드이름(매개변수);
}

interface도 클래스와 같이 접근제어자 public, default를 사용가능하다.

모든 멤버변수는 public static final 로 정의해야 하며 생략가능하다.

모든 메소드는 public abstract 로 정의해야 하며 생략가능하다.

- JDK1.8 버전부터는 static 메소드와 default 메소드 추가를 허용한다.

인터페이스의 상속

인터페이스는 인터페이스간에만 상속관계를 맺을 수 있고 클래스와는 달리 다중상속(여러 인터페이스로부터 상속)을 맺는 것이 가능하다.

interface Playable {
	void play();		//재생기능
}

interface Pauseable {
	void pause();	//일시정지기능
}

interface MusicPlayable extends Playable, Pauseable {
	
}

MusicPlayable 인터페이스에는 정의된 멤버가 하나도 없지만 Playable, Pauseable 인터페이스로 부터 상속 받은 두개의 추상메소드 play()와 pause()를 멤버로 갖게 된다.

인터페이스 구현

인터페이스도 추상클래스와 마찬가지로 그 자체로는 인스턴스를 생성할 수 없고 추상클래스가 상속을 통해 추상메소드를 완성해 나가는 것과 같이 인터페이스도 마찬가지로 자신에게 정의된 추상메서드의 내용을 정의해 주는 클래스를 작성해 주어야 한다. 추상 클래스가 자신을 상속받는 클래스를 정의하는 것과 같이 인터페이스는 구현한다는 키워드 'implements'를 사용한다.

class 클래스이름 implements 인터페이스이름 {
         //인터페이스에 정의된 추상메소드 구현
}

class Mp3Player implements MusicPlayable {

	public void play() {
		//인터페이스에 정의된 추상메소드 구현
	}


	public void pause() {
		//인터페이스에 정의된 추상메소드 구현
	}

}

인터페이스를 구현하는 것은 클래스를 상속받는 것과 같다. ‘extends’ 대신 ‘implements’를 사용한다.

인터페이스에 정의된 추상메서드를 완성해야 한다.

상속과 구현이 동시에 가능하다.

인터페이스의 다형성

다형성이란 자손클래스의 인스턴스를 조상타입의 참조변수로 참조하는 것을 말하는데 인터페이스 역시 다형성을 구현한 클래스의 조상이므로 해당 인터페이스의 타입의 참조변수로 이를 구현한 클래스의 인스턴스를 참조할 수 있으며 인터페이스 타입으로 형변환 또한 가능하다.

MusicPlayable m = (MusicPlayable)new Mp3Player();
//또는 MusicPlayable m = new Mp3Player();

인터페이스 MusicPlayable을 클래스 Mp3Player가 구현했을 때 Mp3Player인스턴스를 MusicPlayable타입의 참조변수로 참조하는 것이 가능하다.

void pause(MusicPlayable m) {
//...
}

인터페이스를 메서드의 매개변수 타입으로 지정할 수 있다.

MusicPlayable method() {
//...
return new Mp3Player();
}

인터페이스를 메서드의 리턴타입으로 지정할 수 있다.

String Class 스트링 클래스

Dean92 — Sun, 28 May 2017 22:28:35 +0900

스트링String 클래스

String 객체는 문자열을 다루는데 가장 많이 사용하는 클래스이다. 일단 String 객체가 하나 생성되면, 그 값은 길어지거나 줄어들 수 없으며, 그 문자들은 수정 할 수 없다. 그래서 String 객체는 변경불능immutable하다고 한다. 하지만 String 클래스의 함수(Method)를 사용하여 String 결과를 수정한 결과를 새로운 String 객체로 반환할 수 있다.

String str = "dean";
str = str + "92";			//"dean92"라는 새로운 문자열이 str에 저장되었다.
System.out.println(str);	//"dean92" 출력됨

문자열 변수 str의 내용이 변경된 것 처럼 보이지만 문자열은 변경될 수 없으므로 새로운 내용의 문자열이 생성된 것이다.

문자열을 변경하려면 StringBuffer 클래스를 사용하면 된다.

스트링 클래스의 인스턴스 생성

자바는 큰 따옴표로 묶인 문자열을 모두 인스턴스화 한다.

문자열은 String 이라는 이름의 클래스로 표현된다.

String str1 = "String Instance";
String str2 = "My String";

두 개의 Strung 인스턴스가 생성되고 참조변수 str1과 str2로 참조한다.

System.out.println("Hello DEAN!");
System.out.println("Beautiful!");

Println 메소드의 매개변수형이 String이기 때문에 이러한 문장 구성이 가능하다.

public class StringInstance {

	public static void main(String[] args) {
		java.lang.String str = "My name is Dean";
		int strLength1 = str.length();
		System.out.println("strLength1 : " + strLength1);
		int strLength2 = "한글의 길이".length();
		System.out.println("strLength2 : " + strLength2);
	}

}

문자열의 선언은 인스턴스의 생성으로 이어짐을 볼 수 있다.

변경불능Immutable

String 인스턴스에 저장된 문자열의 내용은 변경이 불가능하다.

- 이는 동일한 문자열의 인스턴스를 하나만 생성해서 공유하려는 목적이다.

public class Immutable {

	public static void main(String[] args) {
		String str1 = "My String";
		String str2 = "My String";
		String str3 = "Your String";
		
		if(str1==str2)
			System.out.println("동일 인스턴스 참조");
		else
			System.out.println("다른 인스턴스 참조");
	}

}

String 인스턴스의 문자열 변경이 불가능하기 때문에 둘 이상의 참조변수가 동시에 참조를 해도 에러가 발생하지 않는다.

스트링String 클래스의 메소드

String 클래스는 많은 문자열 관련 메서드를 포함하고 있다. 예비 개발자라면 한글로된 교재에서 메소드의 기능을 찾는 습관은 버려야 하며 API 문서를 보는 것에 익숙해 져야 한다. API 문서를 볼 줄 모르는 개발자는 있을 수 없고 API 문서를 참조하지 않고 개발하는 개발자도 있을 수 없으므로 API문서와 친해져야 한다.

String class Api

Access Modifier 접근제어자

Dean92 — Sun, 28 May 2017 19:05:13 +0900

접근제어자

접근제어자는 클래스, 변수, 메서드의 선언부에 사용되어 클래스 내ㆍ외부에서 접근할 수 있는 범위를 지정한다.

지시자	클래스 내부	동일 패키지	상속받은 클래스	이외의 영역
private	○	X	X	X
default	○	○	X	X
protected	○	○	○	X
public	○	○	○	○

접근 제어자가 사용될 수 있는곳 - 클래스, 멤버변수, 메서드, 생성자

private - 같은 클래스 내에서만 접근 가능하다

defualt - 같은 패키지 내에서만 접근 가능하다.

protected - 같은 패키지, 다른 패키지의 자손 패키지에서 접근 가능하다.

public - 접근 제한이 없다.

default 는 아무런 접근 제어자도 붙이지 않는 것을 의미한다.

class AAA{
	private int num;
	public void setNum(int n) { num = n; }
	public int getNum() { return num; }
}

class BBB{
	public accessAAA(AAA inst){
		inst.num=20;
		inst.setNum(20);
		System.out.println(inst.getNum());
	}
}

Int.num=20;에서 num은 private 멤버이므로 컴파일 에러가 발생한다.
System.out.println(inst.getNum());에서 setNum, getNum은 public이므로 호출 가능하다.

package dean;

class AAA{	//package dean으로 묶인다.
	int num;
}

class BBB{	//package dean으로 묶인다.
	public init(AAA a) { a.num=20; }
}

Int.num이 defualt로 선언되었고
BBB는 AAA와 같은 패키지로 묶여있기 때문에 a.num=20; 같이 접근 가능하다.

class AAA {
	protected int num;
}

class BBB extends AAA{
	public void init(int n) { num=n; }
}

Int.num이 defualt로 선언되었고
클래스 BBB가 클래스 AAA를 상속하였으므로 클래스 BBB가 상속된 변수 num에 접근 가능하다.

캡슐화

접근 제어자를 사용하는 목적은 주로 클래스 내부에 선언된 데이터들을 보호하기 위해서이다.

데이터가 유효한 값을 유지하기 위해 비밀번호, 개인정보같은 데이터를 외부에서 함부로 접근하지 못하도록 하기 위해서는 외부로 부터 접근을 제한하는 것이 필요한데 이것을 객체지향에서는 캡슐화Encapsulation라고 한다.

접근 제어자를 사용하는 또다른 목적은 외부에서 접근할 필요가 없는 멤버들을 private로 정의하여 외부에 노출시키지 않음으로 코드의 복잡성을 줄인다.

접근 제어자를 사용하는 이유

외부로부터 데이터를 보호하기 위해 사용한다.

외부에는 불필요하고 내부적으로만 사용되는 부분을 감추기 위해 사용한다.

default 클래스

default 클래스는 동일한 패키지 내에 정의된 클래스에 의해서만 인스턴스 생성이 가능하다.

package apple;

class AAA { } //default 클래스 선언

package banana;

class BBB {	//default 클래스 선언
	public void make() {
		apple.AAA inst = new apple.AAA();
	}
}

클래스를 대표할 정보로 외부에 의미가 있는 클래스를 public으로 선언한다.
apple.AAA는 AAA와 BBB의 패키지가 다르므로 인스턴스 생성이 불가능 하다.

public 클래스

public 클래스는 동일한 패키지 내에 정의된 클래스에 의해서만 인스턴스 생성이 가능하다.

하나의 코드파일에 하나의 클래스만 public으로 선언 가능하고 public 클래스 이름과 소스파일 이름은 일치해야 한다.

package apple;

public class AAA { } //public 클래스 선언

package banana;

public class BBB {	//public 클래스 선언
	public void make() {
		apple.AAA inst = new apple.AAA();
	}
}

AAA는 public 클래스이므로 어디서든지 인스턴스 생성이 가능하다.

생성자의 접근 제어자

생성자에 접근 제어자를 사용함으로써 인스턴스의 생성을 제한할 수 있다. 생성자의 접근 제어자를 private로 정의하면 외부에서 생성자에 접근 불가능 하므로 인스턴스를 생성할 수 없게 되지만 클래스 내부에서는 인스턴스의 생성이 가능하다.

public class AAA{
	AAA() { }
}

클래스는 public으로 선언되어서 파일을 대표하게 되었다. 그럼에도 불구하고 생성자가 default로 선언되었기 때문에 동일 패키지 내에서만 인스턴스 생성이 허용된다.

class BBB {
	public BBB() { }
}

생성자가 public 임에도 클래스가 default로 정의되어서 동일 패키지 내에서만 인스턴스 생성이 허용된다.

Overriding and Overloading 오버라이딩과 오버로딩

Dean92 — Fri, 26 May 2017 22:54:52 +0900

오버라이딩Overriding

오버라이딩Overriding은 객체 지향 관점에서 서브클래스 또는 자식 클래스가 자신의 슈퍼클래스들 또는 부모 클래스들 중 하나에 의해 이미 제공된 메소드를 특정한 형태로 구현하는 것을 말한다. 즉 조상 클래스로부터 상속받은 메서드의 내용을 변경하는 것을 말한다. 상속받은 메서드를 원본 그대로 사용하기도 하지만 많은경우 자식 클래스만의 특징에 맞게 변경해야하는 경우가 훨씬 많고 이 때 부모 클래스를 오버라이딩 한다.

“조상클래스로부터 상속받은 메서드의 내용을 상속받는 클래스에 맞게 변경하는 것을 오버라이딩이라고 한다.”

class Point {
	int x;
	int y;
	
	String getLocation(){
		return "x : " + x + ", y : " + y;
	}
}

class Pint3D extends Point {
	int z;
	String getLocation() {	//오버라이딩
		return "x : " + x + ", y : " + y + ", z : " + z;
	}
}

오버라이딩 조건

선언부(이름, 매개변수, 리턴타입)가 같아야 한다.

접근제어자를 좁은 범위로 변경할 수 없다.

- 조상의 메서드가 protected라면, 범위가 같거나 넓은 protected나 public으로만 변경할 수 있다.

조상클래스의 메서드보다 많은 수의 예외를 선언할 수 없다.

class Parent {
	void parentMethod() throws IOException, SQLException {
		// ...
	}
}

class Child extends Parent {
	void parentMethod() throws IOException {
		// ...
	}
}

class Child2 extends Parent {
	void parentMethod() throws SQLException {
		// ...
	}
}

오버로딩Overloading

메서드도 변수와 마찬가지로 같은 클래스 안에서 각각 다른 이름을 붙여 구분 되게 하여야 하지만 자바에서는 한 클래스내에 같은 이름의 메서드가 있다고 하더라도 매개변수의 개수 또는 타입이 다르면 같은 이름을 붙여 메소드를 정의할 수 있다.

"하나의 클래스에 같은 이름의 메소드를 여러 개 정의하는것을 오버로딩이라고 한다."

오버로딩 조건

메서드의 이름이 같아야 한다

매개변수의 개수 또는 타입이 달라야 한다.

매개변수는 같고 리턴타입이 다른 경우는 오버로딩이 성립되지 않는다.

- 오버로딩된 메소드는 호출시 전달하는 인자를 통해서 구분

class AAA {
	//오버로딩된 메소드들
	void isYourFunc(int n) { }
	void isYourFunc(int n1, int n2) { }
	void isYourFunc(int n1, double n2) { }
}

public static void main(String[] args) {
	AAA inst = new AAA();
	inst.isYourFunc(10, 'a');
	//문자 'a'는 int형으로도 double형으로도 변환이 가능하다.
	//결론적으로 형변환 규칙을 적용하되 가장 가까운 
	//위치의 자료형으로 변환이 이루어진다.
	//따라서 isYourFunc(int n1, int n2) 가 호출된다.
}

"형변환의 규칙까지 적용해야 메소드가 구분되는 상황은 만들지 않는 것이 좋다."

오버라이딩 vs. 오버로딩

오버라이딩Overriding 상속받은 메소드의 내용을 변경하는 것 Vs. 오버라이딩Overloading 기존에 존재하지 않는 새로운 메소드를 정의하는 것

class Parent {
	void parentMethod() { }
}

class Child extends Parent {
	void parentMethod() { }		//오버라이딩
	void parentMethod(int i) { }	//오버로딩
	
	void childMethod() { }
	void childMethod(int i) { }		//오버로딩
	void childeMethod() { }		//중복정의로 인한 컴파일 에러
}

super

super는 자손 클래스에서 조상 클래스로부터 상속받은 멤버를 참조하는데 사용되는 참조변수이다. 앞선 포스팅에서 멤버변수와 지역변수의 이름이 같을 때 this를 사용해서 구별했듯이 상속받은 멤버와 자신의 클래스에 정의된 멤버의 이름이 같을 때 super을 사용한다.

조상 클래스로부터 상속받은 멤버도 자손 클래스 자신의 멤버이므로 super대신 this를 사용할 수 있다. 그러므로 조상 클래스의 멤버와 자손클래스의 멤버가 중복 정의되어 서로 구별해야하는 경우에 super을 사용한다.

조상의 멤버와 자신의 멤버를 구별하는데 사용되는 점을 제외하면 super와 this는 같다. 모든 인스턴스화 된 메서드에서는 자신이 속한 인스턴스의 주소가 지역변수로 저장되는데 이것이 참조변수인 this와 super의 값이 된다.

static메서드(클래스메서드)는 인스턴스와 관련이 없기 때문에 this와 마찬가지로 super 역시 static메서드에서는 사용할 수 없고 인스턴스메서드에서만 사용할 수 있다.

super ▶ this와 같다. 조상의 멤버와 자신의 멤버를 구별하는 데 사용된다. Vs. this ▶ 인스턴스 자신을 가리키는 참조변수. 인스턴스의 주소가 저장되어있다. 모든 인스턴스 메서드에 지역변수로 숨겨진 채로 존재한다.

class Parent {
	int x = 10;
}

class Child extends Parent {
	void method() {
		System.out.println("x=" + x);
		System.out.println("this.x=" + this.x);
		System.out.println("super.x" + super.x);
	}
}

class SuperTest {
	public static void main(String args[]) {
		Child c = new Child();
		c.method();
	}
}

x, this.x super.x 모두 같은 변수를 의미하므로 모두 같은 값 10이 출력된다.

class Parent {
	int x = 10;
}

class Child extends Parent {
	int x = 10;
	void method() {
		System.out.println("x=" + x);
		System.out.println("this.x=" + this.x);
		System.out.println("super.x" + super.x);
	}
}

class SuperTest2 {
	public static void main(String args[]) {
		Child c = new Child();
		c.method();
	}
}

같은 이름의 멤버변수가 조상 클래스인 Parent에도 있고 자손 클래스인 Child클래스에도 있을 때는 super.x와 this.x는 서로 다른 값을 참조하게 된다. super.x는 조상 클래스로부터 상속받은 멤버변수 x를 뜻하며 this.x는 자손 클래스에 선언된 멤버변수를 뜻한다. 즉 x=20, this.x=20, super.x=10 이다.

조상 클래스에 선언된 멤버변수와 같은 이름의 멤버변수를 자손 클래스에서 중복해서 정의하는 것이 가능하며 참조변수 super를 이용해서 서로 구별 할 수 있다.

super()

this()와 마찬가지로 super() 역시 생성자이다. 다른점은 this()는 같은 클래스의 다른 생성자를 호출하는 데 사용되지만, super()는 조상 클래스의 생성자를 호출하는데 사용된다.

자손 클래스의 멤버가 조상 클래스의 멤버를 사용할 수도 있으므로 조상의 멤버들이 먼저 초기화되어 있어야 하기 때문에 생성자의 첫 줄에서 조상클래스의 생성자를 호출해야 한다.

자손클래스의 인스턴스를 생성하면, 자손의 멤버와 조상의 멤버가 합쳐진 하나의 인스턴스가 생성된다.

조상의 멤버들도 초기화되어야 하기 때문에 자손의 생성자의 첫 문장에서 조상의 생성자를 호출해야 한다.

Object클래스를 제외한 모든 클래스의 생성자 첫 줄에는 생성자, this() 또는 super()를 호출해야 한다. 그렇지 않으면 컴파일러가 자동적으로 super();를 생성자의 첫 줄에 삽입한다

class Point {
	int x;
	int y;
	
	Point(int x, int y) {
		this.x = x;
		this.y = y;
	}
	
	String getLocation() {
		return "x :" + x + ",y :" + y; 
	}
}

class Point3D extends Point {
	int z;
	Point3D(int x, int y, int z) {
		/*
		 * 생성자 첫 줄에서 다른 생성자를 호출하지
		 * 않기 때문에 컴파일러가 super();를 이곳에
		 * 삽입한다.
		 * super()는 Point3D의 조상인 Point클래스의
		 * 기본생성자인 Point()를 의미한다.
		 */
		
		//super(x, y)를 삽입하면 컴파일 에러가 사라진다.
		this.x = x;
		this.y = y;
		this.z = z;
	}
	
	String getLocation() {		//오버라이딩
		return "x :" + x + ",y :" + y + ", z : " + z; 
	}
}

조상 클래스의 멤버변수는 조상의 생성자에 의해 초기화되도록 해야한다.

Extends 상속

Dean92 — Fri, 26 May 2017 11:06:18 +0900

상속

상속은 기존의 클래스를 재사용 해서 새로운 클래스를 작성하는 과정이다. 쉽게 말해서 부모 클래스를 상속extends받아 자식 클래스에서 부모 코드를 재사용 할 수 있는 것이다. 프로그램을 설계하다보면, 공통된 부분으로 인하여 중복되는 코드들이 계속 나올 수 있다. 이때 상속을 사용하여, 비슷한 객체끼리 하나의 묶음으로 묶어주고, 공통된 부분을 상위 개념의 부모 클래스로 생성하게 되고 이 객체들이 부모 객체를 상속하면 중복된 코드들을 줄일 수 있고 공통된 방식으로 프로그램을 설계할 수 있다.

class 자손클래스 extends 조상클래스 {
	// ...
}

class Point{
	int x;
	int y;
}

//class Point3D{
//	int x;
//	int y;
//	int z;
//}
//▼상속받아서 사용
class Point3D extends Point {
	int z;
}

상속의 의의

객체지향 이론은 코드 재활용의 관점에서 적합하지 않은 이론이다.
Java의 상속Extends은 클래스의 재활용적 측면에서만 바라보는 것은 문제가 있다.
재활용 할 수 있다는 이유만으로 상속을 하는 경우는 거의 없다.

상속을 사용하는 이유

연관된 일련의 클래스에 대한 공통적인 규약을 정의하고 적용하기 위해 상속을 사용한다.
재활용을 고려해서 클래스를 디자인 할 경우, 설계에 필요한 시간이 더욱 길어지므로 상속을 활용한다.
실무에서 여러 프로그래머가 동시에 같은 프로젝트를 코딩할 때 통일성을 갖출 수 있다.

클래스간의 관계

상속관계Inheritance

두 클래스가 조상과 자손으로써 관계를 가지게 되면 상속 관계에 있다고 한다. 상속 관계의 특징은 아래와 같다.

공통부분은 조상에서 관리하고 개별부분은 자손에서 관리한다.
공통부분은 조상에서 관리하고 개별부분은 자손에서 관리한다.

class Parent { }
class Child extends Parent { }
class Child2 extends Parent { }
class GreandChild extends childe { }

포함관계Composite

포함이란 한 클래스의 멤버변수로 다른 클래스를 선언하는 것을 말한다. 포함관계는 작은 단위의 클래스를 먼저 만들고, 이 들을 조합해서 하나의 커다란 클래스를 만든다.

상속관계

상속관계에 있는 두 클래스 사이에는 IS-A관계가 성립해야 한다.

IS-A 관계가 성립하지 않는 경우에는 상속의 타당성을 면밀히 검토해야 한다.

IS-A 이외에 HAS-A관계도 상속으로 표현 가능하다. 그러나 HAS-A를 대신해서 IS-A관계를 유지하는 것이 보다 적절한 경우가 많다

IS-A 관계

말 그대로 IS-A관계는 "~는 ~이다."가 성립되는 관계이다.

class Computer {
	String owner;
	public Computer(String name) { }
	public void calculate() { }
}

부모클래스

class NotebookComputer extends Computer {
	int battary;
	public NotebookComputer(String name, int initChag) {
		super(name);
	}
	public void charging() { }
	public void movingCal() { }
}

노트북은 컴퓨터 이다.

class TabletNotebook extends NotebookComputer {
	String regstPenModel;
	public TabletNotebook(String name, int initChag) {
		super(name, initChag);
	}
	public void write(String penInfo) { }
}

타블렛은 노트북 이다.

HAS-A 관계

클래스 내에 다른 클래스를 "포함" 함으로써 기능적인 것을 사용하고자 했을 때 HAS-A 관계를 이용한다.

class Gun {
	int bullet;	//장전된 총알의 수
	public Gun(int bnum) { bullet=bnum; }
	public void shut(){
		System.out.println("BANG@@");
		bullet--;
	}
}

class Police extends Gun {
	int handcuffs;	//소유한 수갑의 수
	public Police(int bnum, int bcuff) {
		super(bnum);
		handcuffs=bcuff;
	}
	public void putHandcuff(){
		System.out.println("SNAP!");
		handcuffs--;
	}
}

경찰은 총을 소유하고 있다.

상속은 강한 연결고리를 형성한다. 때문에 총을 소유하지 않는 경찰 또는 총이 아닌 경찰봉을 소유하는 경찰 등 다양한 표현에 한계를 보인다는 단점이 있다.

단일상속Single Inheritance관계

Java는 단일상속만을 허용한다. (C++은 다중상속 허용한다.)

class Police extends Gun, Handcuffs {      //이와같은 다중상속을 허용하지 않는다.
...
}

비중이 높은 클래스 하나만 상속관계로, 나머지는 포함관계로 한다.

Object클래스

Object클래스는 모든 클래스의 최고 조상으로 자바 클래스가 아무것도 상속하지 않으면 java.lang 패키지의 Object 클래스를 자동으로 상속한다. 때문에 모든 자바 클래스는 Object 클래스를 직접적 혹은 간접적으로 상속하게 된다.

모든 클래스가 Object 클래스를 직접 혹은 간접적으로 상속하므로 다음 두가지가 가능하다.

자바의 모든 인스턴스는 Object 클래스의 참조변수로 참조 가능하다.

자바의 모든 인스턴스를 대상으로 Object 클래스에 정의된 메소드를 호출 가능 하다.

모든 클래스가 Object 클래스를 상속한다는 것과 관련된 것

Object클래스에는 toString 메소드가 다음의 형태로 정의되어 있다.

public String toString() { … }

Println 메소드는 다음과 같이 정의되어 있다.

public void println(Object x) { … }

모든 인스턴스는 println 메소드의 인자로 전달될 수 있다.

인자로 전달되면 toString 메소드가 호출되고 이 때 반환되는 문자열이 출력된다.

toString 메소드는 적절한 문자열 정보를 반환하도록 오버라이딩 해야 한다.

예제

Code

StringTest.java

public class StringTest {
	public static void main(String[] args) {
//		==는 객체의 참조값 비교, Object 클래스의 equals()도 참조값비교
//		String 클래의 equals()는 오버라이딩 되어있음->문자열 내용비교				
		String aa = "aa";
		String bb = "aa";
		String cc = new String("aa");
		String dd= bb;
		System.out.println(aa.equals(bb));
		System.out.println(aa.equals(cc));
		System.out.println(aa==bb);
		System.out.println(bb==cc);
		System.out.println(aa==cc);
		System.out.println(dd==bb);
		System.out.println(dd.equals(cc));
	}
}

Result