๐ป BufferedReader/BufferedWriter - Buffer๋ฅผ ํตํด ์ฝ๊ณ ์ฐ๋ ํจ์ - ์ค๊ฐ์ ๋ฒํผ๋ง์ด ๋ ํ์ ์ ๋ฌ - ์๋๊ฐ ๋น ๋ฅด๋ค. ๋ชจ์๋์๋ค๊ฐ ํ ๋ฒ์ ์ ์กํ๋ ๊ฒ์ด ํจ์ฌ ๋ ํจ์จ์ ๐ป BufferedReader Scanner๋ ๋์ด์ฐ๊ธฐ, ์ํฐ๋ฅผ ๊ฒฝ๊ณ๋ก ์
๋ ฅ ๊ฐ์ ์ธ์ํ๊ธฐ ๋๋ฌธ์ ๋ฐ๋ก ๊ฐ๊ณตํ ํ์๊ฐ ์์ด์ ์ฌ์ฉํ๊ธฐ ํธ๋ฆฌ BufferedReader๋ ์ํฐ๋ง์ผ๋ก ๊ฒฝ๊ณ๋ก ์ธ์ํ๊ณ , ๋ฐ์ ๋ฐ์ดํฐ๊ฐ String์ผ๋ก ๊ณ ์ ๋์ด ๋ฐ์ดํฐ๋ฅผ ๋ฐ๋ก ๊ฐ๊ณตํด์ผ ํจ. ํ์ง๋ง Scanner๋ณด๋ค BufferedReader๊ฐ ์๋์ ์ผ๋ก ๋น ๋ฅด๋ค. - Method readLine() : ๋ผ์ธ ๋จ์๋ก ๋ฐ์ดํฐ ์ฝ๊ธฐ, ๊ณต๋ฐฑ ๋จ์๋ฅผ ๋์ด์ฃผ์ง ๋ชปํจ. ๋ค๋ฅธ ํ์
์ผ๋ก ์
๋ ฅ๋ฐ์ผ๋ ค๋ฉด ํ๋ณํ์ด ํ์ read() : ํ ๊ธ์๋ง ์ฝ์ด ์ ์..
Programming Language/Java
ํ๊ต ์์
์๊ฐ์ GUI ๊ทธ๋ฆผํ ํ๋ก๊ทธ๋๋ฐ์ ํ๋ฉด์ Enumeration์ ๋ํด ๊ณต๋ถํ๋ฉด์, Enum Class method์ ๋ํ ์ง์์ด ๋ถ์กฑํ์ฌ ๊ณต๋ถํด๋ณด๋ ์๊ฐ์ ๊ฐ๊ณ ์ ํ๋ค. panel.selectTool(EnumName.valueOf(e.getActionCommand())); (↑ ์ด๊ฑฐ๋ถํฐ๊ฐ ์ดํด๊ฐ ์๊ฐ์์;;) โจ ์ด๊ฑฐ์ฒด(Enumeration Type) ์ฅ์ 1. ์ด๊ฑฐ์ฒด๋ฅผ ๋น๊ตํ ๋ ์ค์ ๊ฐ + ํ์
์ฒดํฌ 2. ์ด๊ฑฐ์ฒด์ ์์ซ๊ฐ์ด ์ฌ์ ์๋๋๋ผ๋ ๋ค์ compile ํ์ ์์ โจ values() ํด๋น ์ด๊ฑฐ์ฒด์ ๋ชจ๋ ์์๋ฅผ ์ ์ฅํ ๋ฐฐ์ด์ ์์ฑํ์ฌ ๋ฐํ for(Rainbow rainbow; Rainbow.values()){ System.out.println(rainbow); } โจ valueOf() ์ ๋ฌ..
1. Date Class : ๋ ์ง๋ฅผ ํํํ๋ ํด๋์ค ๊ฐ์ฒด ๊ฐ์ ๋ ์ง ์ ๋ณด๋ฅผ ์ฃผ๊ณ ๋ฐ์ ๋ ๋งค๊ฐ๋ณ์๋ ๋ฆฌํดํ์
์ผ๋ก ์ฃผ๋ก ์ฌ์ฉ๋๋ค. Date ๊ฐ์ฒด์ toString() ๋ฉ์๋๋ ์๋ฌธ์ผ๋ก ๋ ๋ ์ง๋ฅผ ๋ฆฌํดํ๊ธฐ ๋๋ฌธ์ ์ํ๋ ๋ ์ง ํ์์ ๋ฌธ์์ด์ ์ป๊ณ ์ถ๋ค๋ฉด SimpleDateFormat์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค. SimpleDateFormat ํ์ ๋ฌธ์์ด: yyyy๋ 4์๋ฆฌ ์ฐ๋, MM์ 2์๋ฆฌ ์, dd๋ 2์๋ฆฌ ์ผ, hh๋ 2์๋ฆฌ ์๊ฐ, mm์ 2์๋ฆฌ ๋ถ, ss๋ ๋์๋ฆฌ ์ด format() method: ์ํ๋ ํ์์ ๋ ์ง ์ ๋ณด๋ฅผ ์ป๊ฒ ํด์ฃผ๋ ๋ฉ์๋, parameter variable์ date ๊ฐ์ฒด public static void main(String[] args) { Date date = new Date(..
- Wrapper Class (ํฌ์ฅ ํด๋์ค) ์๋ฐ๋ ๊ธฐ๋ณธ ํ์
(byte, char, short, int, long, float, double, boolean)์ ๊ฐ์ ๊ฐ๋ ๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์๋ค. ์ด๋ฐ ๊ฐ์ฒด๋ฅผ ํฌ์ฅ ๊ฐ์ฒด๋ผ๊ณ ํ๋ค.( ๊ธฐ๋ณธ ํ์
๊ฐ์ ๋ด๋ถ์ ๋๊ณ ํฌ์ฅ ) ํฌ์ฅ ํ๊ณ ์๋ ๊ธฐ๋ณธ ํ์
๊ฐ์ ์ธ๋ถ์์ ๋ณ๊ฒฝํ ์ ์๋ค. ๋ง์ฝ ๋ด๋ถ์ ๊ฐ์ ๋ณ๊ฒฝํ๊ณ ์ถ๋ค๋ฉด ์๋ก์ด ํฌ์ฅ ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด์ผ ํ๋ค. 1. ๋ฐ์ฑ(Boxing)๊ณผ ์ธ๋ฐ์ฑ(Unboxing) - ๋ฐ์ฑ: ๊ธฐ๋ณธ ํ์
์ ๊ฐ์ ํฌ์ฅ ๊ฐ์ฒด๋ก ๋ง๋๋ ๊ณผ์ - ์ธ๋ฐ์ฑ: ํฌ์ฅ ๊ฐ์ฒด์์ ๊ธฐ๋ณธ ํ์
๊ณผ ๊ฐ์ ์ป์ด๋ด๋ ๊ณผ์ //boxing Byte obj = new Byte(10); // ๋ฌธ์์ด์ ์ค ๊ฒฝ์ฐ Byte obj = new Byte("10"); Characto..
String ํด๋์ค๋ String ๊ฐ์ฒด๋ก ์๋ ์์ฑ ๋์ง๋ง, ๋ค์ํ ์์ฑ์๋ฅผ ์ด์ฉํด์ String ๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์๋ค. // ๋ฐฐ์ด ์ ์ฒด๋ฅผ String ๊ฐ์ฒด๋ก ์์ฑ String str = new String(byte[] bytes); // ์ง์ ํ ๋ฌธ์์
์ผ๋ก ๋์ฝ๋ฉ // ๋ฌธ์์
์์ : UTF-8 String str = new String(byte[] bytes, String charseName); //๋ฐฐ์ด์ offset ์ธ๋ฑ์ค ์์น๋ถํฐ length ๋งํผ String ๊ฐ์ฒด ์์ฑ String str = new String(byte[] bytes, int offset, int length); // ์ง์ ํ ๋ฌธ์์
์ผ๋ก ๋์ฝ๋ฉ String str = new String(byte[] bytes, int offset..
์๋ฐ์์ ์ ๊ณตํ๋ API(Application Programming Interface)๋ ํ๋ก๊ทธ๋จ์์ ๊ฐ๋ฐ์ ์์ฃผ ์ฌ์ฉ๋๋ ํด๋์ค ๋ฐ ์ธํฐํ์ด์ค์ ๋ชจ์์ ๋งํ๋ค. API ๋ํ๋จผํธ๋ HTML ํ์ด์ง์ ์์ฑ์ด ๋์ด์๋ค. -> ํ์ด์ง 1. Object Class : ํด๋์ค๋ฅผ ์ ์ธํ๊ฒ ๋๋ฉด extends ํค์๋๋ก ๋ค๋ฅธ ํด๋์ค๋ฅผ ์์ํ์ง ์์๋ ์๋์ผ๋ก java.lang.Object ํด๋์ค๋ฅผ ์์ ๋ฐ๋๋ค. ๋ฐ๋ผ์ ๋ชจ๋ ์๋ฐ์ ํด๋์ค๋ Object ํด๋์ค์ ์์์ด๊ฑฐ๋ ์์ ํด๋์ค๋ค. โ ๊ฐ์ฒด ๋น๊ต (equals()) : ๊ฐ์ฒด๋ฅผ ๋น๊ตํ ๋ ์ฌ์ฉ๋๊ณ , ๊ฐ์ ๊ฐ์ฒด๊ฑด ๋ค๋ฅธ ๊ฐ์ฒด๊ฑด ์๊ด ์์ด ๊ฐ์ฒด๊ฐ ์ ์ฅํ๊ณ ์๋ ๋ฐ์ดํฐ๊ฐ ๋์ผํ์ง ํ์ธํ๋ค. equals()๋ ๋น๊ต์ฐ์ฐ์ ==์ ๋์ผํ ๊ฒฐ๊ณผ๋ฅผ ๋ฆฌํดํ๋ค. ๋ ๊ฐ์ฒด๊ฐ ๋์ผํ ๊ฐ์ฒด..
์์ธ(Exception)๋ ์ฌ์ฉ์์ ์๋ชป๋ ์กฐ์, ๊ฐ๋ฐ์์์๋ชป๋ ์ฝ๋ฉ์ผ๋ก ๋ฐ์ํ๊ฒ ๋๋ ํ๋ก๊ทธ๋จ ์ค๋ฅ๋ฅผ ๋งํ๋ค. ์๋ฐ์์๋ ์์ธ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ๋์ ์ฝ๋๋ฅผ ์ปดํ์ผ ํ ๋, ์์ธ์ฒ๋ฆฌ ์ ๋ฌด๋ฅผ ํ์ธํ๋ค(try, catch ๋ฑ) 1. ์์ธ ํด๋์ค 1. ์ผ๋ฐ์์ธ : ์ปดํ์ผ๋ฌ ์ฒดํฌ ์์ธ ํ๋ก๊ทธ๋จ ์คํ ์, ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ๋์ ์๋ฐ ์์ค์ ์ปดํ์ผ ํ๋ ๊ณผ์ ์์ ํด๋น ์์ธ ์ฒ๋ฆฌ ์ฝ๋๊ฐ ์๋์ง ๊ฒ์ฌํ๋ค. ์ฆ, ์ปดํ์ผ ์ ์๋ฌ์ฒดํฌ, RunTimeException์ ํ์ ํด๋์คโโ 2. ์คํ์์ธ : ์ปดํ์ผ๋ฌ ๋ ์ฒดํฌ ์์ธ ์คํ ์ ์์ธกํ ์ ์์ด ๊ฐ์๊ธฐ ๋ฐ์ํ๊ธฐ ๋๋ฌธ์ ์ปดํ์ผ ๊ณผ์ ์์ ์์ธ์ฒ๋ฆฌ๊ฐ ์๋์ง ๊ฒ์ฌํ์ง ์๋๋ค. ์ฆ, ์ปดํ์ผ ์ ์๋ฌ์ฒดํฌ ์ํจ, RunTimeException์ ํ์ ํด๋์ค ์ปดํ์ผ๋ฌ๊ฐ ์ฒดํฌํ์ง ์..
1. ์ต๋ช
๊ฐ์ฒด (class) : ์ต๋ช
๊ฐ์ฒด๋ ์ด๋ฆ์ด ์๋ ๊ฐ์ฒด๋ฅผ ์๋ฏธํ๋ค. ์ด ๋, ํด๋์ค๋ฅผ ์์ํ๊ฑฐ๋ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํด์ผํ๋ค. ์ต๋ช
๊ฐ์ฒด๋ฅผ ์์ฑํ ๋์๋ ํด๋์ค ์ด๋ฆ์ด ์๋ค. ์ต๋ช
๊ฐ์ฒด๊ฐ ์๋, ์์ ํด๋์ค๋ฅผ ๋ช
์์ ์ผ๋ก ์ ์ธํ๋ ์ด์ ๋ ์ด๋ฏธ ์ ์ธ๋ ์์ ํด๋์ค๋ก ๊ฐ๋จํ ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ ์ ์๋ ์ฌ์ฌ์ฉ์ฑ ๋๋ฌธ์ด๋ค. ํ์ง๋ง, ์ฌ์ฌ์ฉ์ฑ์ด ํ์์๋ ๊ฒฝ์ฐ์๋ ์ต๋ช
์์ ๊ฐ์ฒด๋ฅผ ์์ฑํด์ ์ฌ์ฉํ๋ ๊ฒ์ด ํจ๊ณผ์ ์ด๋ค. ์ต๋ช
๊ฐ์ฒด๋ ์ผ๋ฐ ํด๋์ค์ ๋ฌ๋ฆฌ ์์ฑ์๋ฅผ ์์ฑํ ์ ์๋ค. Parent parent = new Parent(Parameter variable){ // ํ๋ ๋ฉ์๋ ์ ์ธ }; //Parent.java public class Parent { public void parentMethod() { ... } }..
1. ์ค์ฒฉ ํด๋์ค(nested class) : ํด๋์ค ๋ด๋ถ์ ์ ์ธํ ํด๋์ค ์๋ก ์ฝ๊ฒ ์ ๊ทผํ ์ ์๊ณ , ์ธ๋ถ์์๋ ๋ถํ์ํ ๊ด๊ณ๋ฅผ ๊ฐ์ถค์ผ๋ก ์ฝ๋์ ๋ณต์ก์ฑ์ ์ค์ผ ์ ์๋ค. # ๋ฉค๋ฒ ํด๋์ค 1. ์ธ์คํด์ค ๋ฉค๋ฒ ํด๋์ค static ํค์๋ ์์ด ์ค์ฒฉ ์ ์ธ๋ ํด๋์ค ์ธ์คํด์ค ํ๋์ ๋ฉ์๋ ์ ์ธ๋ง ๊ฐ๋ฅ / ์ ์ ํ๋์ ๋ฉ์๋๋ ์ ์ธ ๋ถ๊ฐ๋ฅ class A{ class B{ } } A ํด๋์ค ์ธ๋ถ์์ B ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ ค๋ฉด A ๊ฐ์ฒด๋ฅผ ์์ฑํ ํ์ B ๊ฐ์ฒด๋ฅผ ์์ฑํด์ผ ํ๋ค. A ํด๋์ค ๋ด๋ถ์ ์์ฑ์์ ์ธ์คํด์ค ๋ฉ์๋์์๋ ์ผ๋ฐ ํด๋์ค์ฒ๋ผ B ๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์๋ค. A a = new A(); A.B b = a.new B(); ํ์ง๋ง, ์ผ๋ฐ์ ์ผ๋ก A ํด๋์ค ์ธ๋ถ์์ B ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ ์ผ์ ๊ฑฐ์ ์๋ค. 2. ์ ์ ๋ฉค๋ฒ ํด..
1. ์ถ์ ํด๋์ค - ์ถ์ ํด๋์ค: ์ค์ฒด ํด๋์ค๋ค์ ๊ณตํต์ ์ธ ํน์ฑ์ ์ถ์ถํด์ ์ ์ธํ ํด๋์ค, ์ค์ฒด ํด๋์ค์ ๋ถ๋ชจ ๊ด๊ณ๋ก ๊ตฌํ๋์ด ์์์ ๊ด๊ณ๊ฐ ๋๋ค. ์์ฑํด์ผํ ๋ฉ์๋๊ฐ ๋์ผํ๊ณ , ์ด๋ฆ์ด ํต์ผํด์ผํ๋ค๋ฉด abstract class๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค. public abstract class Parent{...} // abstract ์ ์ธ public class Child extends Parent{...} // abstract ์์ //------------------------------------------------------ /* ์๋จ!! Parent parent = new Parent(); */ ์ถ์ ํด๋์ค๋ new ์ฐ์ฐ์๋ฅผ ํตํด์ ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ง ๋ชปํ๊ณ , ์์์ ํตํด์๋ง ์์ ํด๋์ค๋ฅผ ๋ง๋ค ์ ..