-
์ธํฐํ์ด์ค๋ ๋์๋ง ์ค๋ช ํฉ๋๋ค. ์ํ๊ฐ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ถ์ ํด๋์ค๋ ์ํ๋ฅผ ํฌํจํฉ๋๋ค. ๋ ๋ค ์ค๋ช ํฉ๋๋ค.
์๋ฅผ ๋ค์ด
Bird
์ถ์ ํด๋์ค์CanFly
์ธํฐํ์ด์ค๋ฅผ ๊ฐ์ ธ์ต๋๋ค.public abstract class Bird { private String species; private int age; public abstract void fly(); public String getSpecies() { return species; } public void setSpecies(String species) { this.species = species; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
MockingJay
์ ํด๋์ค๋ฅผ ๋ง๋ค๊ณ ์์ํ๋๋ก ํฉ์๋คBird
.public class MockingJay extends Bird { @Override public void fly() { System.out.println("Fly, bird!"); } public static void main(String[] args) { MockingJay someBird = new MockingJay(); someBird.setAge(19); System.out.println(someBird.getAge()); } }
๋ณด์๋ค์ํผ ์ถ์ ํด๋์ค์ ์ํ(๊ทธ๊ฒ
species
๊ณผage
๋ณ์)์ ์ฝ๊ฒ ์ ๊ทผํ ์ ์์ต๋๋ค.๊ทธ๋ฌ๋ ์ธํฐํ์ด์ค๋ก ๋์ผํ ์์ ์ ์ํํ๋ ค๊ณ ํ๋ฉด ์ํฉ์ด ๋ฌ๋ผ์ง๋๋ค. ๋ณ์๋ฅผ ์ถ๊ฐํ๋ ค๊ณ ์๋ํ ์ ์์ต๋๋ค.
public interface CanFly { String species = new String(); int age = 10; public void fly(); } public interface CanFly { private String species = new String(); // Error private int age = 10; // Another error public void fly(); }
์ธํฐํ์ด์ค ๋ด๋ถ์ ๊ฐ์ธ ๋ณ์๋ฅผ ์ ์ธํ ์๋ ์์ต๋๋ค . ์? ์ฌ์ฉ์๋ก๋ถํฐ ๊ตฌํ์ ์จ๊ธฐ๊ธฐ ์ํด private ํ์ ์๊ฐ ๋ง๋ค์ด์ก๊ธฐ ๋๋ฌธ ์ ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ธํฐํ์ด์ค์๋ ๋ด๋ถ์ ๊ตฌํ์ด ์์ต๋๋ค. ์จ๊ธธ ๊ฒ์ด ์์ต๋๋ค.
์ธํฐํ์ด์ค๋ ๋์๋ง ์ค๋ช ํฉ๋๋ค. ๋ฐ๋ผ์ ์ธํฐํ์ด์ค ๋ด๋ถ์ getter ๋ฐ setter๋ฅผ ๊ตฌํํ ์ ์์ต๋๋ค. ์ด๊ฒ์ด ์ธํฐํ์ด์ค์ ํน์ฑ์ ๋๋ค. ์ธํฐํ์ด์ค๋ ์ํ๊ฐ ์๋๋ผ ๋์๊ณผ ํจ๊ป ์์ ํ๋ ๋ฐ ํ์ํฉ๋๋ค.
Java 8์๋ ๊ตฌํ์ด ์๋ ์ธํฐํ์ด์ค์ ๋ํ ๊ธฐ๋ณธ ๋ฉ์๋๊ฐ ๋์ ๋์์ต๋๋ค. ๋น์ ์ ์ด๋ฏธ ๊ทธ๋ค์ ๋ํด ์๊ณ ์์ผ๋ฏ๋ก ์ฐ๋ฆฌ๋ ๋ฐ๋ณตํ์ง ์์ ๊ฒ์ ๋๋ค.
-
์ถ์ ํด๋์ค๋ ๋งค์ฐ ๋ฐ์ ํ๊ฒ ๊ด๋ จ๋ ํด๋์ค๋ฅผ ์ฐ๊ฒฐํ๊ณ ํตํฉํฉ๋๋ค. ๋์์ ๋จ์ผ ์ธํฐํ์ด์ค๋ ์ ํ ๊ณตํต์ ์ด ์๋ ํด๋์ค์ ์ํด ๊ตฌํ๋ ์ ์์ต๋๋ค.
์์ ์๋ก ๋์๊ฐ ๋ณด๊ฒ ์ต๋๋ค.
์ถ์ ํด๋์ค
Bird
๋ ํด๋น ํด๋์ค๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์๋ฅผ ์์ฑํ๋ ๋ฐ ํ์ํฉ๋๋ค. ์๋ง ์๊ณ ๋ค๋ฅธ ๊ฒ์ ์์ต๋๋ค! ๋ฌผ๋ก ๋ค์ํ ์ข ๋ฅ์ ์๋ค์ด ์์ ๊ฒ์ ๋๋ค.์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ๋ฉด
CanFly
๋ชจ๋ ์ฌ๋์ด ์์ ์ ๋ฐฉ์์ผ๋ก ์์ ์ ์ํํ ์ ์์ต๋๋ค. ์ด๋ฆ๊ณผ ๊ด๋ จ๋ ๋์(๋นํ)๋ง ์ค๋ช ํฉ๋๋ค. ๊ด๋ จ ์๋ ๋ง์ ๊ฒ๋ค์ด '๋ ์ ์๋ค'.์ด 4๊ฐ์ ์ํฐํฐ๋ ์๋ก ๊ด๋ จ์ด ์์ต๋๋ค. ๊ทธ๋ค์ ๋ชจ๋ ์ด์ ์์ง๋ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๊ทธ๋ค์ ๋ชจ๋
CanFly
.์ถ์ ํด๋์ค๋ฅผ ์ฌ์ฉํ์ฌ ์ค๋ช ํ ์ ์์ต๋๋ค. ๋์ผํ ์ํ ๋๋ ๋์ผํ ํ๋๋ฅผ ๊ณต์ ํ์ง ์์ต๋๋ค. ํญ๊ณต๊ธฐ๋ฅผ ์ ์ํ๋ ค๋ฉด ๋ชจ๋ธ, ์์ฐ ์ฐ๋ ๋ฐ ์ต๋ ์น๊ฐ ์์ ๋ํ ํ๋๊ฐ ํ์ํ ๊ฒ์ ๋๋ค. Carlson์ ๊ฒฝ์ฐ ์ค๋ ๋จน์ ๋ชจ๋ ๊ณผ์๋ฅผ ์ํ ํ๋์ ๋จ๋์๊ณผ ํจ๊ป ํ ๊ฒ์ ๋ชฉ๋ก์ด ํ์ํฉ๋๋ค. ๋ชจ๊ธฐ์ ๊ฒฝ์ฐ, ...์ด... ๋๋ ๋ชจ๋ฅด๊ฒ ์ด... ์๋ง๋ '์ฑ๊ฐ์ฌ ์์ค'? :)
์์ ์ ๊ทธ๊ฒ๋ค์ ์ค๋ช ํ๊ธฐ ์ํด ์ถ์ ํด๋์ค๋ฅผ ์ฌ์ฉํ ์ ์๋ค๋ ๊ฒ์ ๋๋ค. ๊ทธ๋ค์ ๋๋ฌด ๋ค๋ฆ ๋๋ค. ๊ทธ๋ฌ๋ ๊ทธ๋ค์ ๊ณต์ ๋ ํ๋์ ๊ฐ์ง๊ณ ์์ต๋๋ค. ๊ทธ๋ค์ ๋ ์ ์์ต๋๋ค. ์ธํฐํ์ด์ค๋ ๋ ๊ณ , ์์ํ๊ณ , ์ ํํ๊ฑฐ๋, ๋ค๋ฅธ ํ๋์ ๋ณด์ผ ์ ์๋ ์ธ์์ ๋ชจ๋ ๊ฒ์ ์ค๋ช ํ๋ ๋ฐ ์ ํฉํฉ๋๋ค.
-
ํด๋์ค๋ ์ํ๋ ๋งํผ ๋ง์ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ์ ์์ง๋ง ํ๋์ ํด๋์ค๋ง ์์ํ ์ ์์ต๋๋ค.
์ฐ๋ฆฌ๋ ์ด๋ฏธ ์ด๊ฒ์ ๋ ๋ฒ ์ด์ ์ธ๊ธํ์ต๋๋ค. Java๋ ํด๋์ค์ ๋ค์ค ์์์ด ์์ง๋ง ์ธํฐํ์ด์ค์ ๋ค์ค ์์์ ์ง์ํฉ๋๋ค. ์ด ์ ์ ์ด์ ํญ๋ชฉ์์ ๋ถ๋ถ์ ์ผ๋ก ์ด์ด์ง๋๋ค. ์ธํฐํ์ด์ค๋ ์ข ์ข ๊ณตํต์ ์ด ์๋ ๋ง์ ๋ค๋ฅธ ํด๋์ค๋ฅผ ์ฐ๊ฒฐํ๋ ๋ฐ๋ฉด ์ถ์ ํด๋์ค๋ ๋งค์ฐ ๋ฐ์ ํ๊ฒ ๊ด๋ จ๋ ํด๋์ค ๊ทธ๋ฃน์ ๋ํด ์์ฑ๋ฉ๋๋ค. ๋ฐ๋ผ์ ์ด๋ฌํ ํด๋์ค๋ฅผ ํ๋๋ง ์์ํ ์ ์๋ค๋ ๊ฒ์ด ์ด์น์ ๋ง์ต๋๋ค. ์ถ์ ํด๋์ค๋ 'is-a' ๊ด๊ณ๋ฅผ ์ค๋ช ํฉ๋๋ค.
ํ์ค ์ธํฐํ์ด์ค: InputStream ๋ฐ OutputStream
์ฐ๋ฆฌ๋ ์ด๋ฏธ ์ ๋ ฅ ๋ฐ ์ถ๋ ฅ ์คํธ๋ฆผ์ ๋ด๋นํ๋ ๋ค์ํ ํด๋์ค๋ฅผ ์ดํด๋ณด์์ต๋๋ค. ๊ทธ๋ฆฌ๊ณInputStream
. OutputStream
_ ์ผ๋ฐ์ ์ผ๋ก ์ด๋ค์ ์ ํ ์ธํฐํ์ด์ค๊ฐ ์๋๋ผ ์์ ํ ์์ํ ์ถ์ ํด๋์ค์
๋๋ค. ์ด์ ๊ทธ๊ฒ์ด ๋ฌด์์ ์๋ฏธํ๋์ง ์์์ผ๋ฏ๋ก ์์
ํ๊ธฐ๊ฐ ํจ์ฌ ์ฌ์ธ ๊ฒ์
๋๋ค. :) InputStream
๋ ๋ฐ์ดํธ ์
๋ ฅ์ ๋ด๋นํ๋ ์ถ์ ํด๋์ค์
๋๋ค. Java์๋ InputStream
. ๊ฐ๊ฐ์ ์๋ก ๋ค๋ฅธ ์์ค์์ ๋ฐ์ดํฐ๋ฅผ ์์ ํ๋๋ก ์ค๊ณ๋์์ต๋๋ค. ๋ถ๋ชจ์ด๊ธฐ ๋๋ฌธ์ InputStream
๋ฐ์ดํฐ ์คํธ๋ฆผ ์์
์ ์ฝ๊ฒ ํ๋ ์ฌ๋ฌ ๋ฉ์๋๋ฅผ ์ ๊ณตํฉ๋๋ค. ์ ๊ฐ ์์์๋ InputStream
๋ค์ ๋ฉ์๋๊ฐ ์์ต๋๋ค.
int available()
์ฝ์ ์ ์๋ ๋ฐ์ดํธ ์๋ฅผ ๋ฐํํฉ๋๋ค.close()
์ ๋ ฅ ์คํธ๋ฆผ์ ๋ซ์ต๋๋ค.int read()
์คํธ๋ฆผ์์ ์ฌ์ฉ ๊ฐ๋ฅํ ๋ค์ ๋ฐ์ดํธ์ ์ ์ ํํ์ ๋ฐํํฉ๋๋ค. ์คํธ๋ฆผ์ ๋์ ๋๋ฌํ๋ฉด -1์ด ๋ฐํ๋ฉ๋๋ค.int read(byte[] buffer)
๋ฐ์ดํธ๋ฅผ ๋ฒํผ๋ก ์ฝ์ผ๋ ค๊ณ ์๋ํ๊ณ ์ฝ์ ๋ฐ์ดํธ ์๋ฅผ ๋ฐํํฉ๋๋ค. ํ์ผ ๋์ ๋๋ฌํ๋ฉด -1์ ๋ฐํํฉ๋๋ค.int read(byte[] buffer, int byteOffset, int byteCount)
๋ฐ์ดํธ ๋ธ๋ก์ ์ผ๋ถ๋ฅผ ์๋๋ค. ๋ฐ์ดํธ ๋ฐฐ์ด์ด ์์ ํ ์ฑ์์ง์ง ์์์ ๋ ์ฌ์ฉ๋ฉ๋๋ค. ํ์ผ ๋์ ๋๋ฌํ๋ฉด -1์ ๋ฐํํฉ๋๋ค.long skip(long byteCount)
์ ๋ ฅ ์คํธ๋ฆผ์์ byteCount ๋ฐ์ดํธ๋ฅผ ๊ฑด๋๋ฐ๊ณ ๋ฌด์๋ ๋ฐ์ดํธ ์๋ฅผ ๋ฐํํฉ๋๋ค.
FileInputStream
: ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ์ ํ์InputStream
. ํ์ผ์์ ์ ๋ณด๋ฅผ ์ฝ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.StringBufferInputStream
: ์ ๋ ๋ค๋ฅธ ์ ์ฉํ ์ ํ์ ๋๋คInputStream
. ๋ฌธ์์ด์InputStream
;BufferedInputStream
: ๋ฒํผ๋ง๋ ์ ๋ ฅ ์คํธ๋ฆผ์ ๋๋ค. ์ฑ๋ฅ์ ํฅ์์ํค๊ธฐ ์ํด ๊ฐ์ฅ ์์ฃผ ์ฌ์ฉ๋ฉ๋๋ค.
BufferedReader
๊ทธ๊ฒ์ ์ฌ์ฉํ ํ์๊ฐ ์๋ค๊ณ ๋งํ๋ ๋๋ฅผ ๊ธฐ์ตํ์ญ๋๊น? ์ฐ๋ฆฌ๊ฐ ์ธ ๋:
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))
...์ฌ์ฉํ ํ์๊ฐ ์์ต๋๋ค BufferedReader
. An์ด InputStreamReader
์์
์ ์ํํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ BufferedReader
์ฑ๋ฅ์ด ํฅ์๋๊ณ ๊ฐ๋ณ ๋ฌธ์๊ฐ ์๋ ์ ์ฒด ๋ฐ์ดํฐ ํ์ ์ฝ์ ์๋ ์์ต๋๋ค. ์๋ ๋์ผํ๊ฒ ์ ์ฉ๋ฉ๋๋ค BufferedInputStream
! ์ด ํด๋์ค๋ ์
๋ ฅ ์ฅ์น์ ์ง์์ ์ผ๋ก ์ก์ธ์คํ์ง ์๊ณ ํน์ ๋ฒํผ์ ์
๋ ฅ ๋ฐ์ดํฐ๋ฅผ ์ถ์ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด ๋ณด๊ฒ ์ต๋๋ค.
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.InputStream;
public class BufferedInputExample {
public static void main(String[] args) throws Exception {
InputStream inputStream = null;
BufferedInputStream buffer = null;
try {
inputStream = new FileInputStream("D:/Users/UserName/someFile.txt");
buffer = new BufferedInputStream(inputStream);
while(buffer.available()>0) {
char c = (char)buffer.read();
System.out.println("Character read: " + c);
}
} catch(Exception e) {
e.printStackTrace();
} finally {
inputStream.close();
buffer.close();
}
}
}
์ด ์์ ์์๋ ์ปดํจํฐ์ ' D:/Users/UserName/someFile.txt '์ ์๋ ํ์ผ์์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ต๋๋ค. ์ฐ๋ฆฌ๋ 2๊ฐ์ ๊ฐ์ฒด๋ฅผ ๋ง๋ญ๋๋ค. a FileInputStream
์ BufferedInputStream
๊ทธ๊ฒ์ '๊ฐ์ธ๋' a์
๋๋ค. ๊ทธ๋ฐ ๋ค์ ํ์ผ์์ ๋ฐ์ดํธ๋ฅผ ์ฝ๊ณ ๋ฌธ์๋ก ๋ณํํฉ๋๋ค. ํ์ผ์ด ๋๋ ๋๊น์ง ๊ทธ๋ ๊ฒ ํฉ๋๋ค. ๋ณด์๋ค์ํผ ์ฌ๊ธฐ์๋ ๋ณต์กํ ๊ฒ์ด ์์ต๋๋ค. ์ด ์ฝ๋๋ฅผ ๋ณต์ฌํ์ฌ ์ปดํจํฐ์ ์ค์ ํ์ผ์์ ์คํํ ์ ์์ต๋๋ค :) ํด๋์ค๋ OutputStream
๋ฐ์ดํธ์ ์ถ๋ ฅ ์คํธ๋ฆผ์ ๋ํ๋ด๋ ์ถ์ ํด๋์ค์
๋๋ค. ์ด๋ฏธ ์๊ณ ์๋ฏ์ด ์ด๊ฒ์ InputStream
. ์ด๋๊ฐ์์ ๋ฐ์ดํฐ๋ฅผ ์ฝ๋ ๊ฒ์ด ์๋๋ผ ๋ฐ์ดํฐ๋ฅผ ์ด๋๊ฐ๋ก ๋ณด๋ด๋ ์ญํ ์ ํฉ๋๋ค . ์ ๋ง์ฐฌ๊ฐ์ง๋ก InputStream
์ด ์ถ์ ํด๋์ค๋ ๋ชจ๋ ํ์ ํญ๋ชฉ์ ํธ๋ฆฌํ ๋ฉ์๋ ์งํฉ์ ์ ๊ณตํฉ๋๋ค.
void close()
์ถ๋ ฅ ์คํธ๋ฆผ์ ๋ซ์ต๋๋ค.void flush()
๋ชจ๋ ์ถ๋ ฅ ๋ฒํผ๋ฅผ ์ง์๋๋ค.abstract void write(int oneByte)
์ถ๋ ฅ ์คํธ๋ฆผ์ 1๋ฐ์ดํธ๋ฅผ ์๋๋ค.void write(byte[] buffer)
์ถ๋ ฅ ์คํธ๋ฆผ์ ๋ฐ์ดํธ ๋ฐฐ์ด์ ์๋๋ค.void write(byte[] buffer, int offset, int count)
์คํ์ ์์น์์ ์์ํ์ฌ ๋ฐฐ์ด์์ ์นด์ดํธ ๋ฐ์ดํธ ๋ฒ์๋ฅผ ์๋๋ค.
OutputStream
.
-
DataOutputStream
. ํ์ค Java ๋ฐ์ดํฐ ์ ํ์ ์์ฑํ๊ธฐ ์ํ ๋ฉ์๋๋ฅผ ํฌํจํ๋ ์ถ๋ ฅ ์คํธ๋ฆผ์ ๋๋ค.๊ธฐ๋ณธ Java ๋ฐ์ดํฐ ์ ํ ๋ฐ ๋ฌธ์์ด์ ์์ฑํ๊ธฐ ์ํ ๋งค์ฐ ๊ฐ๋จํ ํด๋์ค์ ๋๋ค. ์ค๋ช ์ด ์์ด๋ ๋ค์ ์ฝ๋๋ฅผ ์ดํดํ ์ ์์ ๊ฒ์ ๋๋ค.
import java.io.*; public class DataOutputStreamExample { public static void main(String[] args) throws IOException { DataOutputStream dos = new DataOutputStream(new FileOutputStream("testFile.txt")); dos.writeUTF("SomeString"); dos.writeInt(22); dos.writeDouble(1.21323); dos.writeBoolean(true); } }
writeDouble()
,writeLong()
,writeShort()
๋ฑ ๊ฐ ์ ํ์ ๋ํด ๋ณ๋์ ๋ฉ์๋๊ฐ ์์ต๋๋ค . FileOutputStream
. ์ด ํด๋์ค๋ ๋ฐ์ดํฐ๋ฅผ ๋์คํฌ์ ํ์ผ๋ก ๋ณด๋ด๋ ๋ฉ์ปค๋์ฆ์ ๊ตฌํํฉ๋๋ค. ๊ทธ๊ฑด ๊ทธ๋ ๊ณ , ์ฐ๋ฆฌ๋ ์ด๋ฏธ ๋ง์ง๋ง ์์ ์์ ๊ทธ๊ฒ์ ์ฌ์ฉํ์ต๋๋ค. ๋์น์ฑ์ จ๋์? '๋ํผ' ์ญํ ์ ํ๋ DataOutputStream์ ์ ๋ฌํ์ต๋๋ค.BufferedOutputStream
. ๋ฒํผ๋ง๋ ์ถ๋ ฅ ์คํธ๋ฆผ. ์ฌ๊ธฐ์๋ ๋ณต์กํ ๊ฒ์ ์์ต๋๋ค. ๊ทธ ๋ชฉ์ ์BufferedInputStream
(๋๋BufferedReader
)์ ์ ์ฌํฉ๋๋ค. ์ผ๋ฐ์ ์ธ ์์ฐจ์ ๋ฐ์ดํฐ ์ฝ๊ธฐ ๋์ ํน์ '๋์ ' ๋ฒํผ๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์๋๋ค. ๋ฒํผ๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฐ์ดํฐ ์ฑํฌ์ ์ก์ธ์คํ๋ ํ์๋ฅผ ์ค์ผ ์ ์์ผ๋ฏ๋ก ์ฑ๋ฅ์ด ํฅ์๋ฉ๋๋ค.import java.io.*; public class DataOutputStreamExample { public static void main(String[] args) throws IOException { FileOutputStream outputStream = new FileOutputStream("D:/Users/Username/someFile.txt"); BufferedOutputStream bufferedStream = new BufferedOutputStream(outputStream); String text = "I love Java!"; // We'll convert this string to a byte array and write it to a file byte[] buffer = text.getBytes(); bufferedStream.write(buffer, 0, buffer.length); } }
๋ค์ ๋งํ์ง๋ง, ์ด ์ฝ๋๋ฅผ ์ง์ ๊ฐ์ง๊ณ ๋๋ฉด์ ์ปดํจํฐ์ ์ค์ ํ์ผ์์ ์๋ํ๋์ง ํ์ธํ ์ ์์ต๋๋ค.
FileInputStream
, FileOutputStream
๋ฐ ์ ๋ํ ๋ณ๋์ ๊ฐ์๊ฐ ์์ผ๋ฏ๋ก BuffreredInputStream
์ฒ์ ์๋ ์ฌ๋์๊ฒ๋ ์ถฉ๋ถํ ์ ๋ณด์
๋๋ค. ๊ทธ๊ฒ ๋ค์ผ! ์ฐ๋ฆฌ๋ ๋น์ ์ด ์ธํฐํ์ด์ค์ ์ถ์ ํด๋์ค์ ์ฐจ์ด์ ์ ์ดํดํ๊ณ ์ด๋ค ์ง๋ฌธ, ์ฌ์ง์ด ์์์ ์ง๋ฌธ์๋ ๋๋ตํ ์ค๋น๊ฐ ๋์ด ์๊ธฐ๋ฅผ ๋ฐ๋๋๋ค :)