Eclipse ํ๋ก์ ํธ ์์ฑ
new Java project๋ฅผ ํ๋ฉด ์ฌ๋ฌ ์ ํ์ง๊ฐ ๋์ด.
-
Project layout
- use project folder as root for sources and class files
- ๋น๋ ์ ์์ค์ฝ๋์ ๋น๋ ํ ์์ฑ๋ ๊ฒฐ๊ณผ๋ฌผ์ด root์ ํ๋ฒ์ ์๊น
- Create separate folders for sources and class files
- ๋น๋ ์ ์์ค์ฝ๋์ ๋น๋ ํ ์์ฑ๋ ๊ฒฐ๊ณผ๋ฌผ์ ๋ค๋ฅธ ํด๋์ ์ ์ฅ
- use project folder as root for sources and class files
-
Module
-
Create module-info.java file
-
์๋ก ๋ค๋ฅธ ํ๋ก์ ํธ a,b์ ๋ํด a์์ ์ ์ธํ ํด๋์ค๋ฅผ b์์ ๋ถ๋ฌ์ ์ฌ์ฉํ ์ ์๋๋ก ํ๋ ํ์ผ
// export module common.widget { exports com.logicbig; // ์ธ๋ถ์ ๋ ธ์ถํ๊ณ ์ถ์ ํจํค์ง }// import module data.widget { requires common.widget; // ์ฌ์ฉํ ํจํค์ง requires java.sql; }
-
-
Hello world
-
src์๋HelloWorldApp.javaํ์ผ ์์ฑ -
์๋์ ๊ฐ์ด ์์ฑ
public class HellowWorldApp { public static void main(String[] args) { System.out.println("Hellow World!!"); } }- ํด๋์ค๋ช ์ ํ์ผ๋ช ๊ณผ ๊ฐ์์ผํจ.
- ์คํํ๋ ํ์ผ์์, ํ์ผ๋ช
๊ณผ ๊ฐ์ ํด๋์ค๋ช
์์, ํญ์
mainํจ์๋ ์์ด์ผํจ.
-
Run์ ๋๋ฌ ์คํ
ํ๋ก๊ทธ๋๋ฐ ๊ตฌ์ฑ
์๋ฃํ
- ์์ํ์
- ์ ์ํ : int, long
- ์์ํ : float, double
- ๋ฌธ์ํ : char (โ ๋ก ๋ฌถ์)
- boolean
- ํด๋์คํ์
- String : "" ๋ก๋ง ๋ฌถ์ด์ผํจ. ์์ ""๋ฅผ ์
๋ ฅํ๊ณ ์ถ์ผ๋ฉด \ ์ฌ์ฉ
- .length()
- .replace(a, b) : a๋ฌธ์์ด์ ์ฐพ์ b๋ก ๋ณ๊ฒฝ
- .equals() : ๊ฐ์์ง ํ์ธ
- String : "" ๋ก๋ง ๋ฌถ์ด์ผํจ. ์์ ""๋ฅผ ์
๋ ฅํ๊ณ ์ถ์ผ๋ฉด \ ์ฌ์ฉ
์ซ์์ ์ฐ์ฐ
- Math ํด๋์ค
- ๋ค์ํ ์ฐ์ฐ ๋ฉ์๋, ์์ ์ ๊ณต
์บ์คํ
-
์์
(์๋ฃํ)์ ๋ถ์ฌ์ ํจint e = (int) 1.1; double b = (double) e; -
์ ์ โ String
String f = Integer.toString(1);
๋ฐฐ์ด
-
์ ์ธ
- ๋ฆฌํฐ๋ด :
String[] bear = {"kloud", "Cass", "Guiness"}; String[] bear = new String[3];
- ๋ฆฌํฐ๋ด :
-
์ด์ฐจ์๋ฐฐ์ด
-
๋ฆฌํฐ๋ด
String[][] users = { {"egoing", "1111"}, {"jinhuck", "2222"}, {"youbin", "3333"} } -
new
String[][] users = new String[3][2];
-
-
๋์ ๋ฐฐ์ด :
List์ฌ์ฉ
๋ฐ๋ณต๋ฌธ
-
for
- ์ผ๋ฐ์ ์ฌ์ฉ
double[] dividendRates = { 0.5, 0.3, 0.2 }; double[] dividend = new double[3]; for (int i = 0; i < dividendRates.length; i++) { dividend[i] = income * dividendRates[i]; }- ๋ฐฐ์ด์์ ๊ฐ์ ธ์ค๊ธฐ
int[] score = { 78, 70, 65, 98, 58 }; int sum = 0; for (int i : score) { sum += i; } -
while : ๋ค๋ฅธ ์ธ์ด์ ๊ฐ์.
ํ๋ก๊ทธ๋๋ฐ ์์ํ๊ธฐ
์ ๋ ฅ๊ณผ ์ถ๋ ฅ
-
์ ๋ ฅ ๋ค์ด์ผ๋ก๊ทธ
import javax.swing.JOptionPane; ... String id = JOptionPane.showInputDialog("Enter a Id"); -
Scanner
import java.util.Scanner; ... Scanner in = new Scanner(System.in); int a = in.nextInt(); // intํ ์ ๋ ฅ ๋ฐ ๋ฆฌํด float b = in.nextFloat(); boolean c = in.nextBoolean(); String d = in.next(); // String ํ ์ ๋ ฅ ๋ฐ ๋ฆฌํด (๊ณต๋ฐฑ์ ๊ธฐ์ค) String e = in.nextLine(); // String ํ ์ ๋ ฅ ๋ฐ ๋ฆฌํด (๊ฐํ์ ๊ธฐ์ค)
arguments & parameter
- ๊ฐ๋ณ์ธ์
void sum(String a, String...str)์ ๊ฐ์ด ์์ฑํ์ฌ, ์ฌ๋ฌ๊ฐ ๋ฐ์ ์ ์๋๋ก ํ๋๊ฑฐ.- ๋ด๋ถ์ ์ผ๋ก๋ ๋ฐฐ์ด๋ก ์ฒ๋ฆฌํ๋ค.
- main ํจ์์ args ์ ๊ฐ ๋ฃ๊ณ ์คํํ๋ ๋ฐฉ๋ฒ
Run์์ ํ์ดํ ํด๋ฆญRun configurationํด๋ฆญArgumentsํด๋ฆญ- โJAVA APT 508โ โ123.0โ ๊ณผ ๊ฐ์ด ๋ฃ๊ธฐ. ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ.
์ง์ ์ปดํ์ผ
-
์ปดํ์ผ ํ๊ณ ์ํ๋ ํ์ผ์ด ์๋ ๊ณณ์ผ๋ก ์ด๋.
-
javac [ํ์ผ์ด๋ฆ].javaํ๋ฉด.classํ์ผ ์์ฑ -
ํด๋์ค ํ์ผ ์๋ ๊ณณ์ผ๋ก ์ด๋
-
java [ํ์ผ์ด๋ฆ]ํ๋ฉด ์คํ๋จ-
.classํ์ฅ์๋ฅผ ๋ถ์ด์ง ์์ -
๋๋
.javaํ์ผ์ ์ง์ ์คํ์์ผ๋ ๋๋ค. ์ด๋๋ ํ์ฅ์๋ฅผ ๋ถ์
-
์ง์ ์ปดํ์ผ : ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฌ์ฉ
-
javac -cp ".;lib" OkJavaGoInHome.java-cp:--class-path๋ผ๋ ์๋ฏธ. ๊ตฌ๋ถ์๋ฅผ ํตํด ์ปดํ์ผํ ํด๋๋ฅผ ์ฐ๊ฒฐ ๊ฐ๋ฅ.;lib:;๋ ๊ตฌ๋ถ์..(ํ์ฌํด๋)์lib๋ฅผ ์ปดํ์ผ ํ๋ผ๋ ๋ป.
-
์คํ๋ ๋น์ทํ๊ฒ
java -cp ".;lib" OkJavaGoInHome์ผ๋ก ์คํ.
์ง์ ์ปดํ์ผ : arguments
java OkJavaGoInHomeInput "JAVA APT 507" 15.0
์๋ฐ์ฉ์ด
-
ํจํค์ง, ํด๋์ค, ๋ฉ์๋, ๋ณ์
- ํจํค์ง : ๋น์ทํ ์ฑ๊ฒฉ์ ํด๋์ค๋ฅผ ๋ชจ์๊ฒ
- java.lang : import ์์ด ์ฌ์ฉ๊ฐ๋ฅ
- ํด๋์ค : ์๋ก ์ฐ๊ด๋ ๋ณ์์ ๋ฉ์๋๋ฅผ ๋ชจ์ ์ด๋ฆ์ ๋ถ์ธ ๊ฒ
- ํจํค์ง : ๋น์ทํ ์ฑ๊ฒฉ์ ํด๋์ค๋ฅผ ๋ชจ์๊ฒ
-
์ธ์คํด์ค : ํด๋์ค๋ฅผ ์ปดํจํฐ ์์์ ์ค์ฒดํ ํ ๊ฒ
PrintWriter p1 = new PrintWriter("result1.txt")
-
์์
-
throws : ๋ฉ์๋ ์์ ๋ถ์ฌ ์ด๋ค ์๋ฌ๋ฅผ ๋์ง ์ ์๋์ง๋ฅผ ํ์
public static void main(String[] args) { Test test = new Test(); try { test.test("1", "r"); } catch(NumberFormatException e) { System.out.println("์ ๋ ฅํ์ ๊ฐ์ ์ซ์๊ฐ ์๋๋๋ค."); } } class Text { public void test(String a, String b) throws NumberFormatException { try { int sum = Integer.parseInt(a) + Integer.parseInt(b); // ์ซ์๊ฐ ์๋์ NumberFormatException ๋ฐ์ System.out.pringln("ํฉ์ " + sum); } catch(NumberFormatException e) { throw e; } } }
ํด๋์ค
-
์์ฑ์ : public + ํด๋์ค์ด๋ฆ์ผ๋ก ์ ์ธ
public class AccountingMethodApp { public double valueOfSupply; public double vatRate; public double expenseRate; public AccountingMethodApp(double valueOfSupply, double VatRate, double expenseRate) { this.valueOfSupply = valueOfSupply; this.vatRate = VatRate; this.expenseRate = expenseRate; } ... -
static : ์ ์ ๋ฉค๋ฒ ์ ์ธ.(static ๋ณ์ : ์ ์ ํ๋, static ๋ฉ์๋ : ์ ์ ๋ฉ์๋)
-
๊ฐ์ฒด(์ธ์คํด์ค)์ ์์๋ ๋ฉค๋ฒ๊ฐ ์๋๋ผ ํด๋์ค์ ๊ณ ์ ๋ ๋ฉค๋ฒ.
-
ํด๋์ค๋ก๋๊ฐ ํด๋์ค๋ฅผ ๋ก๋ฉํด์ ๋ฉ์๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์ ์ฌํ ๋, ํด๋์ค๋ณ๋ก ๊ด๋ฆฌํ๋ค.
-
์ ์ ๋ฉค๋ฒ๋ heap์ด ์๋ static ์์ญ์ ํ ๋น๋จ. ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ๋ ๋๊น์ง ํ ๋น๋ ์ํ์ด๋ฏ๋ก, static์ ๋จ๋ฐํ ์ ํ๋ก๊ทธ๋จ ์ฑ๋ฅ์ ์ ์ํฅ์ ๋ผ์นจ
-
์ธ์คํด์ค๋ฅผ ์์ฑํ์ง ์์๋ ํธ์ถ ๊ฐ๋ฅํ๋ค.
public class AccountingMethodApp { public static double valueOfSupply; public static double vatRate; public static double expenseRate; public static void print() { System.out.println("Value of supply : " + valueOfSupply); System.out.println("VAT : " + getVAT()); System.out.println("Total : " + getTotal()); System.out.println("Expense : " + getExpense()); System.out.println("Income : " + getIncome()); } public static double getIncome() { return valueOfSupply - getExpense(); } public static double getExpense() { return valueOfSupply * expenseRate; } public static double getTotal() { return valueOfSupply + getVAT(); } public static double getVAT() { return valueOfSupply * vatRate; } } public class Test { public static void main(String[] args) { AccountingMethodApp.valueOfSupply = 10000.0; AccountingMethodApp.vatRate = 0.5; AccountingMethodApp.expenseRate =0.1; AccountingMethodApp.print(); } } -
static ๋ฉ์๋์์๋ static ๋ฉ์๋์ ๋ณ์๋ง ์ฐธ์กฐ๊ฐ๋ฅํ๋ค.
-
์ ์ด๋ฌธ
๋น๊ต
-
์ผ๋ฐ์ ์ธ ์ํฉ์์๋ == ๋ฑ์ ๋น๊ต์ฐ์ฐ์ ์ฌ์ฉ
-
String์
equals()๋ฉ์๋ ์ฌ์ฉ.-
==๋ก ๋น๊ต์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๋น๊ต..equals()๋ก ๋น๊ตํด์ผ ๋ด์ฉ์ ๋น๊ตํ๋ค. -
์ด์
-
์์๋ฐ์ดํฐ ํ์ ์ผ ๊ฒฝ์ฐ, ๋ณ์๊ฐ ์ ์ธ๋๋ฉด stack์ ๊ณต๊ฐ์ด ํ ๋น๋๊ณ , ๊ทธ ๊ณณ์ ์ค์ ๊ฐ์ด ๋ค์ด๊ฐ๊ฒ ๋๋ค. ๊ทธ๋์
==์ฐ์ฐ์๋ ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ ๋น๊ตํ๋ค. -
ํ์ง๋ง String๊ณผ ๊ฐ์ด
java.lang.Object์์ ํ์๋ ํด๋์ค๋ค์ ์์ ๋ฐ์ดํฐ ํ์ ์ด ์๋๋ค.new๋ก ์์ฑ๋๋ฉดheap์ ์๋ก์ด ๊ณต๊ฐ์ด ํ ๋น๋์ด ๊ฐ์ ์ ์ฅํ๊ณ , ๋ณ์๋ ๊ทธ ๊ฐ์ด ์ ์ฅ๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ๋๋ค. ๋ฐ๋ผ์ ํด๋์ค๋ฅผ==๋ก ๋น๊ตํ๋ฉด ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๋น๊ตํ๊ฒ ๋๋ ๊ฒ์ด๋ค. -
ํ์ง๋ง
๋ฌธ์์ด ๋ฆฌํฐ๋ด๋ก String์ ์์ฑํ ๊ฒฝ์ฐ, ์ด๋ฏธ ๊ฐ์ ๋ฌธ์์ด์ ์์ฑํ ์ ์ด ์๋ค๋ฉด ์๋ก ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ ๋นํ์ง ์๊ณ ์๋ก์ด ๋ณ์๋ ๊ธฐ์กด ๋ฌธ์์ด์ด ์ ์ฅ๋ ๋ฉ๋ชจ๋ฆฌ์ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ๋๋ค. ๋ฐ๋ผ์==์ฐ์ฐ์ true๊ฐ ๋์จ๋ค. ๊ทธ๋๋ ๋ด์ฉ์ ๋น๊ตํ๋ ค๋ฉด ์ผ๋จ.equals()๋ก ๋น๊ตํ์.
// ๊ฒฐ๊ณผ : False String a = new String("1234"); String b = new String("1234"); if (a == b) { System.out.println("TRUE"); } else { System.out.println("False"); } // ๊ฒฐ๊ณผ : TRUE (๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์์ด๊ธฐ์) String c = "1234"; String d = "1234"; if (c == d) { System.out.println("TRUE"); } else { System.out.println("False"); } // ๊ฒฐ๊ณผ : False (๋ค๋ฅธ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์์ด๊ธฐ๋๋ฌธ) if (a == c) { System.out.println("TRUE"); } else { System.out.println("False"); } -
-
instanceof
-
๊ฐ์ฒด๊ฐ ํด๋์ค์ ์ธ์คํด์ค๋.
a instanceof A -
๋คํ์ฑ์ ๋ฐ๋ผ,
์์ ํด๋์ค์ ๊ฐ์ฒด instanceof ๋ถ๋ชจ ํด๋์คํ๋ฉดtrue๊ฐ ๋์จ๋ค. ๋ฐ๋๋ false
๋ฉ์๋
์ ๊ทผ์ ์ด์
- public : ํด๋์ค ์ธ๋ถ์์ ์ ๊ทผ ๊ฐ๋ฅ
- private : ํด๋์ค ์ธ๋ถ์์ ์ ๊ทผ ๋ถ๊ฐ๋ฅ
- protected : ๊ฐ์ ํจํค์ง ๋ด์ ์๊ฑฐ๋, ์์๋ฐ์ ๊ฒฝ์ฐ์๋ง ์ ๊ทผ ๊ฐ๋ฅํจ.
- package-private : ํจํค์ง ๋ด์์๋ง ์ ๊ทผ ๊ฐ๋ฅ
๊ฐ์ฒด์งํฅํ๋ก๊ทธ๋๋ฐ
ํด๋์ค(ํ์)
- ํ ํ์ผ์ ์ฌ๋ฌ๊ฐ๋ฅผ ๋ฃ์ ์ ์์ง๋ง, public ํด๋์ค๋ ํ์ผ์ด๋ฆ๊ณผ ๊ฐ์ ํด๋์ค์ ํ๋๋ง ์์ฑ๊ฐ๋ฅ.
- ์๋ฐ์ ์์ค์ฝ๋๋ฅผ ์คํํ ๋, ์์ค์ฝ๋ ํ์ผ๋ช ๊ณผ ๋์ผํ public ํด๋์ค๋ฅผ ์ปดํ์ผํด์ ๊ทธ ํด๋์ค์ main ๋ฉ์๋๋ฅผ ์คํํ๋ ๊ฑธ๋ก ์ฝ์ ๋์ด์๋ค.
- ์์ค์ฝ๋๋ฅผ ์ปดํ์ผํ ๋ ๊ทธ ์์ ๋ค์ด์๋ ํด๋์ค๋ ๋ฐ๋ก๋ฐ๋ก
.classํ์ผ๋ก ์ปดํ์ผ๋๋ค.- ํ ํ์ผ ์์ ์ฌ๋ฌ ๊ฐ์ ํด๋์ค๊ฐ ์์ผ๋ฉด, ๊ฐ๊ฐ ๋ฐ๋ก
.classํ์ผ์ด ๋์ค๋๋ก ์ปดํ์ผ ๋๋ค๋ ๊ฒ
- ํ ํ์ผ ์์ ์ฌ๋ฌ ๊ฐ์ ํด๋์ค๊ฐ ์์ผ๋ฉด, ๊ฐ๊ฐ ๋ฐ๋ก
์์ฑ์์ this
-
์์ฑ์ : ๋ฆฌํดํ์ ์์ค ๋ฉ์๋ ํ์. ์ ๊ทผ์ ์ด์๋ public์ด์ด์ผํจ.
class Print { public String delimiter = ""; public Print(String delimiter) { this.delimiter = delimiter; } ... -
this
- ์ธ์คํด์ค๋ฅผ ๊ฐ๋ฆฌํค๋ ์์ฝ์ด.
OOP
์์
extends
class Cal {
public int sum(int v1, int v2) {
return v1 + v2;
}
}
class Cal3 extends Cal{
public int minus(int v1, int v2) {
return v1 - v2;
}
}override
class Cal3 extends Cal{
@Override
public int sum(int v1, int v2) {
System.out.println("Cal3!!!");
return v1 + v2;
}
// overloading
public int sum(int v1, int v2, int v3) {
return v1 + v2 + v3;
}
}- ์ด๋ฆ, ๋งค๊ฐ๋ณ์๊ฐ ๊ฐ์ ๋ฉ์๋์ ๊ตฌํ๋ง ๋ค๋ฅด๊ฒ ํ๋ ๊ฒ.
- @Override ์ด๋ ธํ ์ด์ ์ ๋ถ์ด๋ ๊ฒ์ด ์ข๋ค.
- vs overload
- ์ด๋ฆ์ ๊ฐ์ผ๋ ๋งค๊ฐ๋ณ์๊ฐ ๋ค๋ฅธ ๋ฉ์๋.
- ๊ฐ์ ํด๋์ค ๋ด์์๋ ์ ์ธ๊ฐ๋ฅ
- ์์ฑ์๋ ์ด์ ๊ฐ์ด ์ค๋ฒ๋ก๋ฉ ๊ฐ๋ฅ
this super
- super : ๋ถ๋ชจ ํด๋์ค๋ฅผ ๊ฐ๋ฆฌํค๋ ํค์๋.
- ์์ํด๋์ค์์ super๋ฅผ ์ด์ฉํ์ฌ ์ ๊ทผ ๊ถํ์ด ๋ถ์ฌ๋ ๋ถ๋ชจํด๋์ค์ ๋ณ์์ ๋ฉ์๋์ ์ ๊ทผํ ์ ์๋ค.
class Cal {
public int sum(int v1, int v2) {
return v1 + v2;
}
}
class Cal3 extends Cal{
@Override
public int sum(int v1, int v2) {
System.out.println("Cal3!!!");
return super.sum(v1, v2);
}
}-
super() ๋ฅผ ํตํด ๋ถ๋ชจ ํด๋์ค์ ์์ฑ์ ํธ์ถ๊ฐ๋ฅ
-
์์ ํด๋์ค์์ ์์ฑ์๊ฐ ์์ผ๋ฉด ์๋ฌต์ ์ผ๋ก ๋ถ๋ชจ ํด๋์ค์ ์์ฑ์๊ฐ ํธ์ถ๋จ
-
ํ์ง๋ง ์๋์ ๊ฐ์ด ์ธ์๋ฅผ ๋ฐ๋ ์์ฑ์๋ง ๋ถ๋ชจํด๋์ค์ ์๋ค๋ฉด, ์์ ํด๋์ค์์๋ ์์ฑ์๋ฅผ ๋ช ์์ ์ผ๋ก ํธ์ถํ์ฌ ๋ถ๋ชจ ํด๋์ค์ ์์ฑ์๋ฅผ ํธ์ถํด์ผํ๋ค.
- super() ๋ ์ธ์๊ฐ ์๋ ์์ฑ์๋ฅผ ํธ์ถํ๋ ๊ฒ์ด๋ฏ๋ก.
- ๋ง์ฐฌ๊ฐ์ง๋ก ์ด๋ค ํด๋์ค์ ์ธ์๋ฅผ ๋ฐ๋ ์์ฑ์๋ง ์๋๋ฐ, ์ธ์๋ฅผ ๋ฃ์ง์๊ณ ์ธ์คํด์ค๋ฅผ ์์ฑํ๋ฉด ์ปดํ์ผ ์ค๋ฅ๊ฐ ๋๋ค.
-
class Cal {
int v1, v2;
public Cal(int v1, int v2) {
this.v1 = v1;
this.v2 = v2;
}
public int sum() {
return this.v1 + this.v2;
}
}
class Cal2 extends Cal {
int v3;
public Cal2(int v1, int v2, int v3) {
super(v1, v2);
this.v3 = v3;
}
@Override
public int sum() {
return super.sum() + this.v3;
}
}Java ์ธํฐํ์ด์ค
์ธํฐํ์ด์ค
-
์์ผ๋ก ๋ง๋ค ํด๋์ค์ ๋ฉ์๋ ๊ท๊ฒฉ์ ์ ์ธํ ์ ์์
interface Calculable { int sum(int v1, int v2); } class RealCal implements Calculable { @Override public int sum(int v1, int v2) { return v1 + v2; } }- ์ด๋๋
@Override์ด๋ ธํ ์ด์ ์ ๋ค์ด๊ฐ๋ค.
- ์ด๋๋
-
์ฌ๋ฌ๊ฐ์ ์ธํฐํ์ด์ค๋ฅผ ๋์์ ์ ์ฉํ ์ ์์
interface Calculable { int sum(int v1, int v2); } interface Printable { void print(); } class RealCal implements Calculable, Printable { -
interface ๋ด๋ถ์์ ๋ณ์๋ฅผ ์ ์ํ ์ ์์. ๋ค๋ง ์ด๋๋ ๋ฐ๋์ ์ด๊ธฐํ ๋์ด์ผํจ. ์ธํฐํ์ด์ค๋ฅผ ์ ์ฉํ ํด๋์ค๋ ๋ณ์๋ฅผ ๋ค์ ๋์ ํ ์ ์์
interface Calculable { double PI = 3.14; int sum(int v1, int v2); } class RealCal implements Calculable { public int sum(int v1, int v2) { return v1 + v2; } } public class InterfaceApp { public static void main(String[] args) { RealCal c = new RealCal(); System.out.println(c.sum(2, 1)); System.out.println(c.PI); } } -
interface๋ ์์์ด ๊ฐ๋ฅ
interface Calculable { double PI = 3.14; int sum(int v1, int v2); } interface Printable extends Calculable { void print(); }
๋คํ์ฑ
-
ํด๋์ค์ ์ธ์คํด์ค๋ฅผ ๋ณ์๋ก ์ ์ธํ ๋, ํด๋น ํด๋์ค์ ๋ฐ์ดํฐํ์ ์ผ๋ก ์ ์ธํ์ง ์๊ณ
๋ถ๋ชจ ํด๋์ค๋ ์ธํฐํ์ด์ค๋ฅผ ๋ฐ์ดํฐ ํ์ ์ผ๋ก ์ ์ธํ ์ ์๋ค. ์ด๋ฌํ ํน์ฑ์ ๋คํ์ฑ์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค.interface Calculable { double PI = 3.14; int sum(int v1, int v2); } interface Printable { void print(); } class RealCal implements Calculable, Printable { public int sum(int v1, int v2) { return v1 + v2; } public void print() { System.out.println("this is RealCal!!!"); } }- RealCal ์ธ์คํด์ค๋ฅผ Calculable ํ์ ์ผ๋ก ์ ์ธํ๋ฉด, Printable ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์๋ค. ๋ฐ๋๋ ๋ง์ฐฌ๊ฐ์ง.
-
์์ ํด๋์ค์ ๊ฐ์ฒด instanceof ๋ถ๋ชจ ํด๋์คํ๋ฉดtrue๊ฐ ๋์จ๋ค.
์ถ์ํด๋์ค
-
์ธํฐํ์ด์ค์ ์ผ๋ถ ๋ฉ์๋๋ฅผ ํด๋์ค ๋ด์์ ๊ตฌํ์์ผฐ์๋ ์ฌ์ฉ.
-
๊ตฌํํ์ง ์์ ๋ฉ์๋์ ๋ฆฌํด๊ฐ ์๊ณผ ํด๋์ค ์์
abstract๋ฅผ ๋ถ์ฌ์ผํ๋คinterface Calculable { double PI = 3.14; int sum(int v1, int v2); int minus(int v1, int v2); } abstract class RealCal implements Calculable { public int sum(int v1, int v2) { return v1 + v2; } public abstract int minus(int v1, int v2); // ๋ฉ์๋๋ ์์ด๋ ๋๊ธดํจ }
enum
- ์์์ ์งํฉ. class ์ ์ธ์ class ๋์ ์ enum์ ์ ์ด์ฃผ๋ฉด ๋๋ค.
- ์์๋ฅผ ์ ์ ๋, ํ์ ์ด๋ ๊ฐ์ ์ง์ ํ ํ์์์.
- ์์๋ค์ ์ด๋ฆ๋ง ์ฝค๋ง๋ก ๊ตฌ๋ถํ๊ณ ๊ฐ์ฅ ๋ง์ง๋ง์ ์ธ๋ฏธ์ฝ๋ก ์ ๋ฃ์ด์ฃผ์.
- Enum์ ๋ถ๋ชจ๋ ๋ฌด์กฐ๊ฑด
java.lang.Enum๋ฐ๋ผ์ ๋ค๋ฅธ ๊ฒ์ ์์๋ฐ์ผ๋ฉด ์๋จ.
final
- ํด๋์ค, ๋ฉ์๋, ๋ณ์์ ์ ์ธํ ์ ์์.
- ์์, override, ๋ณ๊ฒฝํ ์ ์๋ค๋ ์๋ฏธ.
const๊ฐ์ ๊ฑฐ. - ๋ณ์์์๋ ๋ ์ด์ ๋ณ๊ฒฝํ ์ ์๋ค๋ ์๋ฏธ
- ์ธ์คํด์ค, ํด๋์ค ๋ณ์์ final๋ฅผ ์ธ๋, ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํ ํด์ผํจ.
- ๋งค๊ฐ๋ณ์, ์ง์ญ๋ณ์์ final์ ์ธ ๋, ๊ตณ์ด ์ด๊ธฐํํ์ง ์์๋ ๋๋ค.(์ง์ญ๋ณ์์ ๊ฒฝ์ฐ ์ฒซ ์ด๊ธฐํ์ ๊ฐ์ด ๊ณ ์ ๋จ.)
์์ธ
์์ธ ์ฒ๋ฆฌ
-
try - catch๋ก ๊ฐ๋ฅ
try { System.out.println(2); System.out.println(scores[3]); //ArrayIndexOutOfBoundsException // ์ฌ๊ธฐ๊น์ง ์คํ -> catch(ArrayIndexOutOfBoundsException e)๋ฌธ์ผ๋ก ์ด๋ System.out.println(3); System.out.println(2/0); //ArithmeticException System.out.println(4); } catch(ArithmeticException e) { System.out.println("์๋ชป๋ ๊ณ์ฐ์ด๋ค์."); } catch(ArrayIndexOutOfBoundsException e) { System.out.println("์๋ ๊ฐ์ ์ฐพ๊ณ ๊ณ์๋ค์ ^^"); } catch(Exception e) { System.out.println("์์ ์๋ ์๋ฌ"); } finally { System.out.println("๋ฌด์กฐ๊ฑด ์คํ") }- catch๋ ์์์๋ถํฐ ๋จผ์ ๊ฒ์ฌํ์ฌ, ์๋ฌ์ ํ์ ์ด ์ฒ์ ๋ง๋ ๊ณณ์ ๋ค์ด๊ฐ๋ค.
- ์ผ์นํ๋ ๊ณณ์ด ์์ผ๋ฉด throw ๋จ.
- Exception ํด๋์ค๋ ๋ชจ๋ ์๋ฌํด๋์ค์ ๋ถ๋ชจ๋ก, ๋ง์ง๋ง catch ๋ฌธ์ Exception์ ์ถ๊ฐํ๋ฉด ๊ทธ ๊ณณ์ ๋ค์ด๊ฐ๋ค.
- Exception ํด๋์ค๋
Throwableํด๋์ค๋ฅผ ์์๋ฐ๊ณ ์์ด, Throwable ํด๋์ค์ ๋ฉ์๋๋ ์ฌ์ฉ๊ฐ๋ฅํ๋ค. - finally ๋ก try๊ฐ ๋๋ ์, ๋๋ catch๊ฐ ๋๋ ์ ์คํ๋ ์ฝ๋๋ฅผ ์์ฑํ ์ ์๋ค.
uncheked Exception vs checked Exception
- unchecked exception : ์ปดํ์ผ์ ๋์ง๋ง, runtime ์ค์ ๋ฐ์ํ ์ ์๋ exception.
RuntimeExceptionํด๋์ค๋ก๋ถํฐ ์์๋ ์์ธ - cheked Exception : try-catch๋ก ์ก์ง ์์ผ๋ฉด ์ปดํ์ผ์ด ์๋๋ ์๋ฌ.
Throwable๋ฅผ ์์๋ฐ์ ํด๋์ค ์คRuntimeException์ ์ ์ธํ ๋ชจ๋ ์๋ฌ์ ์์ธ๋ค.
try-with-resource
-
Java SE7 ๋ถํฐ ์ถ๊ฐ๋ ๊ตฌ๋ฌธ
-
์์์ ์ก๊ณ , ๋์์ฃผ๋ ๊ณผ์ ์ try-catch-finally๋ก ํ๋ฉด ๋ณต์กํ๊ธฐ์ ์ด๋ฅผ ๊ฐ๋จํ ํด์ฃผ๋ ๊ตฌ๋ฌธ
-
์๋์ ๊ฐ์ด try ๋ฌธ์ ๊ดํธ๋ฅผ ์ถ๊ฐํ์ฌ ๊ทธ ์์ ์ฌ์ฉํ ์์์ ์ ์ํ๋ค.
- ์์์ ์ฌ๋ฌ๊ฐ ๋ฃ์ ์ ์์ผ๋ฉฐ, ์ธ๋ฏธ์ฝ๋ก (;)์ผ๋ก ๊ตฌ๋ถํ๋ค. ๋ง์ง๋ง ๊ฐ์ฒด์๋ ๋ฃ์ง ์์.
- ์ ์ฒด try๋ฌธ์ด ์ข ๋ฃ๋๋ฉด ์์ฑ๋ ์ธ์คํด์ค๋ ์๋์ผ๋ก ์ข ๋ฃ๋๊ธฐ์ ๋ช ์์ ์ผ๋ก close๋ฅผ ์ด์ฉํ์ง ์์๋ ๋๋ค.
// ์ try { f = new FileWriter("data.txt"); f.write("Hello"); } catch(IOException e) { e.printStackTrace(); } finally { if (f != null) { try { f.close(); } catch (IOException e) { e.printStackTrace(); } } } // ํ try (FileWriter f = new FileWriter("data.txt")) { f.write("Hello"); } catch (IOException e) { e.printStackTrace(); }
throw
-
์์ธ๋ฅผ ์์๋ก ๋ฏธ๋ฃจ์ด ์ฒ๋ฆฌํ๋ ๊ฒ.
public void test(String a, String b) throws NumberFormatException { int sum = Integer.parseInt(a) + Integer.parseInt(b); System.out.println("ํฉ : " + sum); } public void test(String a, String b) throws NumberFormatException { try { int sum = Integer.parseInt(a) + Integer.parseInt(b); System.out.println("ํฉ : " + sum); } catch(NumberFormatException e) { System.out.println("์ซ์ํ ๋ฌธ์๊ฐ ์๋๋๋ค.") throw e; } }
์์ธ์ฒ๋ฆฌ ์ ๋ต
- ์ปค์คํ ์์ธ ํด๋์ค๋ฅผ ๋ง๋ค๋๋, ๊ผญ try-catch๋ก ๋ฌถ์ด์ค ํ์๊ฐ ์์ ๋๋ง Exception ํด๋์ค๋ฅผ ํ์ฅํ๋ค.
- ์ผ๋ฐ์ ์ผ๋ก ์คํ์ ์์ธ๋ฅผ ์ฒ๋ฆฌํ ์ ์๋ ๊ฒฝ์ฐ์๋ง RuntimeException์ ํ์ฅํ๋ค.
- catch ๋ธ๋ก์ ๊ณต๋ฐฑ์ผ๋ก ๋๋์ง ์๋๋ค.
์ต๋ช ํด๋์ค
๋ค์๊ณผ ๊ฐ์ ๊ฒฝ์ฐ ์ฌ์ฉํจ
- ํ๋ก๊ทธ๋จ๋ด์์ ์ผ์์ ์ผ๋ก ์ฌ์ฉ๋์ด์ผํ๋ ๊ฐ์ฒด
- ์ฌ์ฌ์ฉ์ฑ์ด ์๊ณ , ํ์ฅ์ฑ์ ํ์ฉํ๋ ๊ฒ์ด ์ ์ง๋ณด์์์ ๋ ๋ถ๋ฆฌํ ๋
๋ฌธ๋ฒ
๋ถ๋ชจ ํด๋์ค [ํ๋|๋ณ์] = new ๋ถ๋ชจํด๋์ค(๋งค๊ฐ๊ฐ,...) {
};๊ตฌํ๋ฒ
- ํ๋์ ์ด๊ธฐ๊ฐ
- ๋ก์ปฌ๋ณ์์ ์ด๊ธฐ๊ฐ
- ๋งค๊ฐ๋ณ์์ ๋งค๊ฐ
์์
class Insect {
void attack(){
System.out.println("๊ณค์ถฉ์ ๊ณต๊ฒฉ์ ํ๋ค");
}
}
public class Anonymous {
//โ
โ
๋ฐฉ๋ฒ 1 : ํ๋์ ์ต๋ช
์์ ๊ฐ์ฒด๋ฅผ ์์ฑ
Insect spider1 = new Insect(){
String name = "๋ฌด๋น๊ฑฐ๋ฏธ";
void cobweb(){
System.out.println("์ฌ๊ฐํ์ผ๋ก ๊ฑฐ๋ฏธ์ค์ ์น๋ค.");
}
@Override
void attack() {
System.out.println(name + " ๋
์ ๋ฐ์ฌํ๋ค.");
}
};
//โ
โ
๋ฐฉ๋ฒ2 : ๋ก์ปฌ๋ณ์์ ์ด๊ธฐ๊ฐ์ผ๋ก ๋์
void method1(){
Insect spider2 = new Insect(){
String name = "๋๋๊ฑฐ๋ฏธ";
//๊ฑฐ๋ฏธ์ค์ ์น๋ค.
void cobweb(){
System.out.println("์ก๊ฐํ์ผ๋ก ๊ฑฐ๋ฏธ์ค์ ์น๋ค.");
}
@Override
void attack() {
System.out.println(name + " ์๋๋ก ๋ฌธ๋ค.");
}
};
//๋ก์ปฌ๋ณ์์ด๊ธฐ ๋๋ฌธ์ ๋ฉ์๋์์ ๋ฐ๋ก ์ฌ์ฉ
spider2.attack();
// ์๋ ์ฐธ๊ณ . ์ ๊ทผ ๋ถ๊ฐ๋ฅ
spider2.cobweb();
}
//โ
โ
๋ฐฉ๋ฒ3 : ์ต๋ช
๊ฐ์ฒด ๋งค๊ฐ๋ณ์๋ก ๋์
void method2(Insect spider){
spider.attack();
}
}์ฐธ๊ณ
- ์ต๋ช ์์๊ฐ์ฒด์์ ์๋กญ๊ฒ ์ ์๋ ํ๋์ ๋ฉ์๋๋ ์์๊ฐ์ฒด ๋ ๋ฒจ์์๋ง ์ฌ์ฉ๋๊ธฐ ๋๋ฌธ์ ์ธ๋ถ์์๋ ์ฌ์ฉํ ์ ์์
- ์ต๋ช ๊ฐ์ฒด๋ฅผ ๋ฐ์์ค ๋ณ์๋ ๋ถ๋ชจํ์ ์ ํด๋์ค์ด๊ธฐ ๋๋ฌธ์ ๋ถ๋ชจ๋ ๋ฒจ์์ ์ ์๋ ํ๋๋ ๋ฉ์๋๋ง ์ฌ์ฉ์ด ๊ฐ๋ฅ
์๋ฐ์ ์
ํจํค์ง
- import ๋ฌธ์ ํตํด ํจํค์ง ์ฌ์ฉ ๊ฐ๋ฅ
- ์๋ฐํ์ผ์ด ์ปดํ์ผ ๋ ๋, import ๋ ํด๋์ค๋ ๊ฐ์ด ์ปดํ์ผ ๋๋ค.
- import๋ก ๋ค๋ฅธ ํจํค์ง ์ ๊ทผํ๊ธฐ.
- import (๋ฃจํธ๋๋ ํ ๋ฆฌ์ ์ธ) ๊ฒฝ๋ก.ํด๋์ค์ด๋ฆ; //ํ ํด๋์ค๋ง ์ฐธ์กฐ
- import (๋ฃจํธ๋๋ ํ ๋ฆฌ์ ์ธ) ๊ฒฝ๋ก.*; //๋ง์ง๋ง ํด๋ ์๋ ๋ชจ๋ ํด๋์ค ์ฐธ์กฐ
String
- StringBuffer : Thread safe, ์๋ ๋๋ฆผ, ์ฌ๋ฌ ์ฐ๋ ๋๊ฐ ๊ทธ ๋ณ์๋ฅผ ์ ๊ทผํ ์ผ์ด ์์๋.
- StringBuilder : Thread unsafe, ์๋ ๋น ๋ฆ, ํ๋์ ๋ฉ์๋ ์์์ ์ ์ธํ๊ณ ๋ํ ๊ฒฝ์ฐ.
- ๋ฌธ์์ด์ ํฉ์น ๋, StringBuilder์ append ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด String์์
+์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ ๋๋ณด๋ค ์๋๊ฐ ๋น ๋ฅด๋ค.
- ๋ฌธ์์ด์ ํฉ์น ๋, StringBuilder์ append ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด String์์
์ ๋ค๋ฆญ
-
ํด๋์ค, ๋ฉ์๋๋ฅผ ๋ค์ํ ํ์ ์์ ์ฌ์ฉํ ์ ์๋๋ก ํด์ฃผ๋ ๊ฒ
// ํด๋์ค์์ public class GenericDTO<T> implements Serializable { private T object; public void setObject(T obj) { this.object = obj; } public T getObject() { return object; } } //ํธ์ถ GenericDTO<String> dto1 = new GenericDTO<String>(); GenericDTO<StringBuffer> dto2 = new GenericDTO<StringBuffer>(); //๋ฉ์๋์์ //์ ๋ค๋ฆญ ๋ฉ์๋ public <T> T genericMethod(T c, T addValue) { System.out.println(addValue); System.out.println(c); return c; } //Bounded Generic ๋ฉ์๋ public <T extends Car> void genericMethod(WildcardGeneric<T> c, T addValue) { c.setWildcard(addValue); T value = c.getWildcard(); System.out.println(value); } //๋ ๊ฐ์ด์์ ์ ๋ค๋ฆญ ๋ฉ์๋ public <S, T extends Car> void genericMethod(WildcardGeneric<T> c, T addValue, S another) { c.setWildcard(addValue); T value = c.getWildcard(); System.out.println(value); } -
<?>: ์์ผ๋์นด๋-
๋งค๊ฐ๋ณ์์์ ์ฌ์ฉํ ๋, ์ด๋ค ํ์ ์ด ์ฌ์ง ๋ชจ๋ฅด๋ ๊ฒฝ์ฐ ์ฌ์ฉ
public void wildcardStringMethod(WillcardGeneric<?> c);
-
-
<? extends Car>- Car๋ Car ์์๋ค๋ง ๋ค์ด๊ฐ ์ ์์.
-
<? super T>- T๋ T ์กฐ์๋ง ๋ค์ด๊ฐ ์ ์์.
์๋ฃํ
- Collection ์ธํฐํ์ด์ค
- List : ๋์ ์ผ๋ก ๋ณํ๋ ๋ฐฐ์ด. ํ์ ํด๋์ค์ ๋ถ๋ชจ
- ArrayList : ํ์ฅ๊ฐ๋ฅํ ๋ฐฐ์ด. Thread safe ํ์ง ์์
- Vector : ํ์ฅ ๊ฐ๋ฅํ ๋ฐฐ์ด. Thread safe ํจ.
- Stack : LIFO. Vector ํ์ฅ
- LinkedList : ํ ๋ฐ์ดํฐ๊ฐ ์์ ์ ์ ๋ค์ ๋ฌด์์ด ์๋์ง ์๊ณ ์์.
- Set : ์ค๋ณต ๋ฐฉ์ง. ์ํ๋ ๊ฐ์ด ์๋์ง ํ์ธํ๋๊ฒ ์ฃผ์๋ฌด
- HashSet : ์์๊ฐ ์ ํ ํ์์๋ ๋ฐ์ดํฐ๋ฅผ ํด์ฌ ํ ์ด๋ธ์ ์ ์ฅํจ. ์ฑ๋ฅ์ด ๊ฐ์ฅ ์ข์
- TreeSet : red-black tree. Hash๋ณด๋จ ๋๋ฆผ
- LikedHashSet : ์ฐ๊ฒฐ๋ ๋ชฉ๋ก ํ์ ์ผ๋ก ๊ตฌํ๋ ํด์ํ ์ด๋ธ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ. ์ ์ฅ๋ ์์์ ๋ฐ๋ผ ๊ฐ์ด ์ ๋ ฌ๋๋ฉฐ ์ฑ๋ฅ์ด ๊ฐ์ฅ ๋๋ฆผ.
- Queue : FIFO
- PriorityQueue
- Deque : ๋งจ์, ๋งจ๋ค์ ๊ฐ์ ๋ฃ๊ฑฐ๋ ๋บ ์ ์์
- List : ๋์ ์ผ๋ก ๋ณํ๋ ๋ฐฐ์ด. ํ์ ํด๋์ค์ ๋ถ๋ชจ
- Map ์ธํฐํ์ด์ค : key-value๋ก ์ด๋ฃจ์ด์ ธ์์.
- HashMap : key-velue๋ก ์ ์ฅ๋ง ํจ.
- TreeMap : ๊ฐ์ ์ ์ฅํ๋ฉด์ ํค๋ฅผ ์ ๋ ฌํ๋ค.
- LinkedHashMap
- Hashtable
// ์ดํ๋ก๋ ํค์๋๋ง
์ฐ๋ ๋
- ํ ์ฝ์ด์ ํ๋์ ์ฐ๋ ๋ ์คํ
- Runnable ์ธํฐํ์ด์ค, Thread ํด๋์ค๋ก ์์ฑ๊ฐ๋ฅ
ํ์ผ IO
- File, Files
- File ํด๋์ค : ํ์ผ ๋ฐ ํ์ผ ๊ฒฝ๋ก์ ๋ณด ํฌํจ. ์ฌ๋ณผ๋ฆญ๋งํฌ ๊ฐ์ด ์ ๋์ค๊ณ์ด์์ ์ฌ์ฉ๊ฐ๋ฅํ ๊ธฐ๋ฅ์ ์ ๊ณตํ์ง ์์
- Files ํด๋์ค : JDK 7 ์ด์. ๋ชจ๋ ๋ฉ์๋๊ฐ static์ด๋ผ ๋ณ๋์ ๊ฐ์ฒด ์์ฑ์ด ์์ด ๋ ํธ๋ฆฌํ๋ค.
- InputStream, OutputStream
- Stream์ byte๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํ ๊ฒ. ๋คํธ์ํฌ๋ฅผ ์ฒ๋ฆฌํ ๋ ๋ง์ด ์ฌ์ฉํ๋ค.
- Reader, Writer
- char ๊ธฐ๋ฐ์ ๋ฌธ์์ด์ ์ฒ๋ฆฌํ๊ธฐ ์ํ ํด๋์ค.
- ์ผ๋ฐ์ ์ธ ํ ์คํธ ์๋ํฐ๋ก ๋ณผ ์ ์๋ ํ์ผ๋ค์ ์ํ ํด๋์ค.
- ํ
์คํธ ํ์ผ ์ฝ๊ธฐ, ์ฐ๊ธฐ
- FileReader, BufferedReader : ํ ์คํธ ํ์ผ ์ฝ๊ธฐ
- FileWriter : ํ ์คํธ ํ์ผ ์ฐ๊ธฐ
- Scanner
- ํ ์คํธ ๊ธฐ๋ฐ ๊ธฐ๋ณธ ์๋ฃํ์ด๋ ๋ฌธ์์ด ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํ ํด๋์ค
- ์ฌ์ฉ์๋ก๋ถํฐ ์ ๋ ฅ์ ๋ฐ์ ์ ์๋ค.
Serializable ์ธํฐํ์ด์ค
- ๊ฐ๋ฐ์๊ฐ ๋ง๋ ํด๋์ค๊ฐ ํ์ผ์ ์ฝ๊ฑฐ๋ ์ธ ์ ์๋๋ก ํ๊ฑฐ๋, ๋ค๋ฅธ ์๋ฒ๋ก ๋ณด๋ด๊ฑฐ๋ ๋ฐ์ ์ ์๋๋กํ๋ ค๋ฉด ๋ฐ๋์ ๊ตฌํํด์ผํจ.
- ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ๋ค์์ serialVersionUID๋ฅผ ์ง์ ํ๋ ๊ฑธ ๊ถ์ฅ๋ฐ์. ํด๋น ํด๋์ค์ ๋ฒ์ ์ ๋ช
์ํ๋ ๊ฒ.
- UID๊ฐ ๋ค๋ฅธ ํด๋์ค๋ ์ด๋ฆ์ด ๊ฐ์ ํด๋์ค์ฌ๋ ๋ค๋ฅธ ํด๋์ค๋ก ์ธ์.
- ๋ณ๋๋ก ์ง์ ํ์ง ์์ผ๋ฉด ์ปดํ์ผ์ ์๋ ์ง์ ๋จ.
- ๊ฐ์ฒด ์ ์ฅ : ObjectOutputStream ํด๋์ค ์ฌ์ฉ
- ๊ฐ์ฒด ์ฝ๊ธฐ : ObjectInputStream ํด๋์ค ์ฌ
์๋ฐ NIO
- ์คํธ๋ฆผ์ด ์๋ ์ฑ๋๊ณผ ๋ฒํผ๋ฅผ ์ฌ์ฉํจ
- ์ฑ๋ : ๋ฌผ๊ฑด์ ์ค๊ฐ์์ฒ ์ฒ๋ฆฌํ๋ ๋๋งค์
- ๋ฒํผ : ๋๋งค์ํํ ๋ฌผ๊ฑด์ ์ฌ๊ณ , ์๋น์์๊ฒ ํ๋ ์๋งค์
๋คํธ์ํฌ
-
TCP ํต์
- Socket ํด๋์ค
- ๋ฐ์ดํฐ๋ฅผ ๋ณด๋ด๋ ์ชฝ(ํด๋ผ์ด์ธํธ)์์ ๊ฐ์ฒด๋ฅผ ์์ฑํ์ฌ ์ฌ์ฉํจ.
- ๋ฐ์ดํฐ๋ฅผ ๋ฐ๋ ์ชฝ(์๋ฒ)์์ ํด๋ผ์ด์ธํธ ์์ฒญ์ ๋ฐ์ผ๋ฉด, ์์ฒญ์ ๋ํ socket ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํจ.
- Socket ๊ฐ์ฒด๋ฅผ ์ง์ ์์ฑํด์ผํจ.
- SeverSocket ํด๋์ค
- ์๋ฒ์์ ์ฌ์ฉํ๋ ํด๋์ค. ๊ฐ์ฒด๋ ํด๋ผ์ด์ธํธ ์์ฒญ์ด ์๊ธฐ๋ฉด Socket ๊ฐ์ฒด๋ฅผ ์์ฑํ์ฌ ์ ๋ฌํด์ค.
- ์์ฑ์์ 2๊ฐ์ ๋ฉ์๋๋ง ์์๋ ๋คํธ์ํฌ ํ๋ก๊ทธ๋๋ฐ์ด ๊ฐ๋ฅํ๋ค.
- ํด๋ผ์ด์ธํธ์์ ์ ์์ ํ๋ฉด Socket ๊ฐ์ฒด๋ฅผ ์์ฑํจ.
- Socket ํด๋์ค
-
UDP ํต์
- DatagramSocket ํด๋์ค
- ๋ณด๋ด๋ ์ญํ ๊ณผ ๋ฐ๋ ์ญํ ๋ชจ๋ ์ํํ ์ ์์.
- DatagramPacket ํด๋์ค
- ์คํธ๋ฆผ์ ์ฌ์ฉํ์ง ์๊ณ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ์.
- DatagramSocket ํด๋์ค
-
Http ์์ฒญ
- URL ํด๋์ค : ์์ฃผ ๊ฐ๋จํ ์์ฒญ ์ฒ๋ฆฌ๊ฐ๋ฅ. ๋ณ๋ก ์ถ์ฒํ์ง ์์
- Apache์ HttpComponents : ์ผ๋ฐ์ ์ผ๋ก ๋ง์ด ์ฌ์ฉํจ
์๋ฐ ๋ฒ์ ๋ณ
Java 7
-
์ซ์ํํ๋ฐฉ๋ฒ
- ์ง์
- 2์ง์ : 0b
- 8์ง์ : 0
- 16์ง์ : 0x
- ์ฒ๋จ์ ์ธ๋๋ฐ : 1_000_000
- ์ง์
-
switch ๋ฌธ์์ String ์ฌ์ฉ๊ฐ๋ฅ
-
์ ๋ค๋ฆญ์ ์ฝ๊ฒ ์ฌ์ฉํ ์ ์๋ Diamond
GenericDTO<String> dto1 = new GenericDTO<>();- ์ด๋ ๊ฒ ๋ค๋ ์๋ต๊ฐ๋ฅํ๊ฒ ํ๋ ๊ฑฐ
-
์์ธ ์ฒ๋ฆฌ์ ๋ค์ค ์ฒ๋ฆฌ๊ฐ๋ฅ
catch(IllegalArgumentException | FileNotFoundException | NullPointException e){ e.printStackTrace(); }- ์์ ๊ฐ์ด ๋ค์ค์ผ๋ก ์๋ฌ๋ฅผ ๋ฐ์ ์ ์์.
-
fork/join ๊ด๋ จ ํด๋์ค
- cpu ๋ฉํฐ์ฝ์ด๋ฅผ ์ฝ๊ฒ ์ฌ์ฉํ๊ธฐ ์ํด ๋ง๋ค์ด์ง. ์ฌ๋ฌ๊ฐ๋ก ๋๋์ด ๊ณ์ฐํ ํ ๊ฒฐ๊ณผ๋ฅผ ๋ชจ์๋ค.
- ์ฐ๋ ๋ ์ ๊ฒฝ ์์จ๋ JVM์ด ์๋์ผ๋ก ์ฒ๋ฆฌํ๊ณ , worker์ ๊ฐ์๋ CPU์ ๊ฐ์๋งํผ ์ฆ๊ฐํ๋ค.
-
NIO2
- ํ์ผ์ ์์ฑ, ์ฌ๋ณผ๋ฆญ ๋งํฌ๊น์ง ์ฒ๋ฆฌ๊ฐ๋ฅ. ์ด๋ค ํ์ผ์ด ๋ณ๊ฒฝ๋์๋์ง ํ์ธํ ์ ์๋ WatchService ํด๋์ค ์ ๊ณต
- File์ ๋์ฒดํ๋ ํด๋์ค : java.nio.file ์ ์์
- Paths
- Files : ๊ธฐ์กด File ํด๋์ค๋ฅผ ๋ณด์.
- FileSystems : ํ์ผ์์คํ ์ ๋ํ ์ ๋ณด๋ฅผ ์ฒ๋ฆฌ
- FileStore : ํ์ผ์ ์ ์ฅํ๋ ๋๋ฐ์ด์ค, ํํฐ์ , ๋ณผ๋ฅจ ๋ฑ์ ๋ํ ์ ๋ณด๋ฅผ ์ฒ๋ฆฌ
- SeekableByteChannel(random access) : ๋ฐ์ดํธ๊ธฐ๋ฐ ์ฑ๋์ ์ฒ๋ฆฌ
- NetworkChannel ๋ฐ MulticastChannel
- AsynchronousFileChannel : ๋น๋๊ธฐ ์ฒ๋ฆฌ ํ์ผ ์ฑ๋
-
JDBC 4.1 : SQL Query๋ฅผ ์ฝ๊ฒ ์ํํ ์ ์๋ RowSet์ ๊ฐ์ฒด๋ฅผ ์ฝ๊ฒ ๋ง๋ค์ด์ฃผ๋ ํด๋์ค ํฌํจ
-
TransferQueue : ๋ฉ์ธ์ง์ฒ๋ฆฌ์ ์ฌ์ฉ
-
Objects ํด๋์ค : Object์ ๊ฐ์ staticํ ๋ฉ์๋ ์ ๊ณต. ๋์ด์จ ๊ฐ์ฒด๊ฐ null์ด์ด๋ ์์ธ๊ฐ ๋ฐ์ํ์ง ์์
Java8
-
Lambda ํํ์
- ์ต๋ช ํด๋์ค์ ๊ฐ๋ ์ฑ์ ์ฌ๋ฆฌ๊ธฐ ์ํด ์ฌ์ฉ๋จ.
- ๊ตฌํํด์ผํ ํจ์๊ฐ ํ๋์ผ๋๋ง ์ฌ์ฉ๊ฐ๋ฅ. (default, static ์ ์ธ)
- js ํ์ดํํจ์์ฒ๋ผ ์ฌ์ฉ.
// ์ด์ private void calculateClassic() { Calculate claculateAdd = new Calculate() { //Calculate ๋ Functional ์ธํฐํ์ด์ค @Override public int operation(int a, int b) { return a+b; } }; System.out.println(calculateAdd.operation(1,2)); } // ์ดํ private void calculateLambda() { Calculate calculateAdd = (a,b) -> a+b; System.out.println(calculateAdd.operation(1,2)); } // ์ด์ new Thread(new Runnable() { @Override public void run() { System.out.println("Thread run"); } }).start(); // ์ดํ new Thread(()->System.out.println("Thread run")).start(); // Thread ์์ฑ์๋ก๋ Runnable์ ๋ฃ์ด์ค์ผํ๋ฏ๋ก ์ด๋ ๊ฒ ํด์ค๋ ์์์ Runnable๋ก ๋ค์ด๊ฐ. -
Functional ์ธํฐํ์ด์ค : java.util.function ํจํค์ง์ ์ํจ. ์ถ์๋ฉ์๋๊ฐ ์ค์ง ํ๋์ธ ์ธํฐํ์ด์ค๋ฅผ ๋ปํ๋ฏ๋ก ๋๋ค์๊ณผ ํธํก์ด ์ข์.
- Predicate : test()๋ผ๋ ๋ฉ์๋ ์กด์ฌ. ๋ ๊ฐ์ ๊ฐ์ฒด๋ฅผ ๋น๊ตํ ๋ ์ฌ์ฉํ๊ณ boolean์ ๋ฆฌํดํจ.
- Supplier : get() ๋ฉ์๋ ์กด์ฌ. ๋ฆฌํด๊ฐ์ generic์ผ๋ก ์ ์ธ๋ ํ์ ์ ๋ฆฌํดํจ
- Consumer : accept()๋ผ๋ ๋งค๊ฐ๋ณ์๋ฅผ ํ๋ ๊ฐ๋ ๋ฉ์๋๊ฐ ์กด์ฌ. ๋ฆฌํด๊ฐ์ ์์.
- Function : apply()๋ผ๋ ํ๋์ ๋งค๊ฐ๋ณ์๋ฅผ ๊ฐ๋ ๋ฉ์๋ ์กด์ฌ. ๋ฆฌํด๊ฐ ์กด์ฌ.
- UnaryOperator : apply()๋ผ๋ ํ๋์ ๋งค๊ฐ๋ณ์๋ฅผ ๊ฐ๋ ๋ฉ์๋๊ฐ ์์. ๋ฆฌํด๊ฐ ์กด์ฌ.
- BinaryOperator : apply()๋ผ๋ ๋ ๊ฐ์ ๋งค๊ฐ๋ณ์๋ฅผ ๊ฐ๋ ๋ฉ์๋๊ฐ ์์. ๋ฆฌํด๊ฐ ์กด์ฌ.
-
Stream : ์ฐ์๋ ์ ๋ณด๋ฅผ ์ฒ๋ฆฌํ ๋ ์ฌ์ฉํจ.
- ๋ฐฐ์ด์๋ ์ฌ์ฉํ ์ ์์ง๋ง, ์ปฌ๋ ์ ์๋ ์ฌ์ฉ๊ฐ๋ฅ. ๋ฐ๋ผ์ ๋ฐฐ์ด์ List๋ก ๋ฐ๊พผ๋ค์ ์ฌ์ฉ.
- .stream() : ์คํธ๋ฆผ ์์ฑ. ์ปฌ๋ ์ ์ ์คํธ๋ฆผ ๊ฐ์ฒด๋ก ๋ณํํจ. ๋ณํ ํ ์ค๊ฐ, ์ค๋จ ์ฐ์ฐ ์ฌ์ฉ
- ์ค๊ฐ์ฐ์ฐ : filter(), map(), flatMap(), sorted()
- ์ข ๋จ์ฐ์ฐ : forEach(), toArray(), anyMatch(), allMatch(), nonMatch(), findFirst(), any(), reduce(), collector()
- ๋ฉ์๋ ์ฐธ์กฐ. ๋ฐ์ดํฐ๊ฐ ๋ฐ๋ก ๋ฉ์๋์ ๋งค๊ฐ๋ณ์๋ก ๋ค์ด๊ฐ๋๋ก ํ๋ ๋ฒ
.forEach(System.out::println),.forEach(ContainingClass::staticMethodName)
-
Optional : null์ด ์ฌ ์ ์๋ ๊ฐ์ ๊ฐ์ธ๊ธฐ ์ํด ์ฌ์ฉ. ๊ฐ์ด null์ด๋๋ผ๋ NPE์ด ๋ฐ์ํ์ง์์
// Java8 ์ด์ List<String> names = getNames(); List<String> tempNames = names != null ? names : new ArrayList<>(); // Java8 ์ดํ List<String> nameList = Optional.ofNullable(getNames()) .orElseGet(() -> new ArrayList<>()); // Java8 ์ด์ public String findPostCode() { UserVO userVO = getUser(); if (userVO != null) { Address address = user.getAddress(); if (address != null) { String postCode = address.getPostCode(); if (postCode != null) { return postCode; } } } return "์ฐํธ๋ฒํธ ์์"; } public String findPostCode() { // ์์ ์ฝ๋๋ฅผ Optional๋ก ํผ์ณ๋์ผ๋ฉด ์๋์ ๊ฐ๋ค. Optional<UserVO> userVO = Optional.ofNullable(getUser()); Optional<Address> address = userVO.map(UserVO::getAddress); Optional<String> postCode = address.map(Address::getPostCode); String result = postCode.orElse("์ฐํธ๋ฒํธ ์์"); // ๊ทธ๋ฆฌ๊ณ ์์ ์ฝ๋๋ฅผ ๋ค์๊ณผ ๊ฐ์ด ์ถ์ฝํด์ ์ธ ์ ์๋ค. String result = user.map(UserVO::getAddress) .map(Address::getPostCode) .orElse("์ฐํธ๋ฒํธ ์์"); }- ๊ฒฐ๊ณผ๊ฐ null์ด ๋ ์ ์์ผ๋ฉฐ, null์ ์ํด ์ค๋ฅ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ๋งค์ฐ ๋์ ๋ ๋ฐํ๊ฐ์ผ๋ก๋ง ์ฌ์ฉ
-
์ธํฐํ์ด์ค์ ๊ธฐ๋ณธ ๋ฉ์๋
public interface Vehicle { public default void doSomething(int n) { System.out.println("doSomething(Vehicle)"); } }- ์์ ๊ฐ์ด
defaultํค์๋์ ํจ๊ป ์ธํฐํ์ด์ค์ ๋ํดํธ๋ฉ์๋ ์ ์ธ๊ฐ๋ฅ - ๋ค์ค implements ์ ๊ฐ์ ๋ฉ์๋๊ฐ default๋ผ๋ฉด,
- ์ปดํ์ผ ์ค๋ฅ ๋ฐ์. override ํด์ค์ผํ
- ์์, implements ์ ๊ฐ์ ๋ฉ์๋๊ฐ ๊ตฌํ๋์ด์๋ค๋ฉด
- ์์ ๋ฉ์๋๊ฐ ์ฌ์ฉ๋จ.
- ์์ ๊ฐ์ด
-
๋ ์ง ๊ด๋ จ ํด๋์ค ์ถ๊ฐ
- ๋ถ๋ณ ํด๋์ค ์ถ๊ฐ : java.time.ZonedDateTime, java.time.LocalDate
- java.time.format.DateTimeFormatter : thread safeํ๊ณ ๋น ๋ฅธ ํด๋์ค
-
๋ณ๋ ฌ๋ฐฐ์ด ์ ๋ ฌ
- Arrays ํด๋์ค : ๋ฐฐ์ด์ ์ฒ๋ฆฌํ๊ธฐ์ ์ข์ ์ฌ๋ฌ static ๋ฉ์๋๋ฅผ ๊ฐ์ง๊ณ ์์.
- binarySearch(), fill(), sort() ๋ฑ
- parallelSort() : Fork-Join ํ๋ ์์์ด ๋ด๋ถ์ ์ผ๋ก ์ฌ์ฉ๋จ. ์ฌ๋ฌ ์ฐ๋ ๋๋ก ์ํ๋์ด ์๋๋ ๋ ๋น ๋ฅด๋ค.
- Arrays ํด๋์ค : ๋ฐฐ์ด์ ์ฒ๋ฆฌํ๊ธฐ์ ์ข์ ์ฌ๋ฌ static ๋ฉ์๋๋ฅผ ๊ฐ์ง๊ณ ์์.
-
StringJoiner : ์์ฐจ์ ์ผ๋ก ๋์ด๋๋ ๋ฌธ์์ด์ ์ฒ๋ฆฌํ ๋ ์ฌ์ฉํจ.
์ถ์ฒ
https://www.boostcourse.org/cs128
์๋ฐ์ ์