์์ ๋ ์ง / ์ ๋ฆฌ๋ ์ง
2022.03.15 / 2022.03.19-20
ํ์ต ์ฃผ์
- 02 ์๋ฐ ํ๋ก๊ทธ๋๋ฐ ๊ธฐ์ด
- 03 ์ ํ๊ณผ ๋ฐ๋ณต
- 04 ๋ฐฐ์ด
ํ์ต ๋ด์ฉ
Eclips์์ ๊ธฐ์กด ํ์ผ ๋ถ๋ฌ์ค๊ธฐ
File → Import → General > Existing Projects into Workspace → Browse์์ ํ์ผ ์ฐพ๊ธฐ
(Projects ๋ด โก์ ์ฒดํฌ ํ์ํด์ผ ๋ถ๋ฌ์ฌ ์ ์์)
02 ์๋ฐ ํ๋ก๊ทธ๋๋ฐ ๊ธฐ์ด
Hello ์์ ๋ถ์
public class Hello{
public static void main(String[] arg){
System.out.println("Hello World!");
}
}
01~05: ํด๋์ค๋ฅผ ์ ์ํ๋ ๋ฌธ์ฅ
02~04: ๋ฉ์๋๋ฅผ ์ ์ํ๋ ๋ฌธ์ฅ
์์ค ํ์ผ๊ณผ ํด๋์ค ์ด๋ฆ
- ํ์ผ๋ช ๊ณผ public ํด๋์ค์ ์ด๋ฆ์ด ์ผ์นํด์ผ ํจ
- ํ๋์ ํ์ผ ์์ public ํด๋์ค๊ฐ 2๊ฐ ์ด์์ด๋ฉด ์ค๋ฅ
- ์ผ๋ฐ์ ์ผ๋ก public ํด๋์ค์ main method๊ฐ ์์น
๋ฉ์๋
: ํน์ ํ ์์ ์ ์ํํ๋ ์ฝ๋์ ๋ฌถ์(ํจ์)
public static void main(String[] args){
๋ฌธ์ฅ1;
๋ฌธ์ฅ2;
...
}
public: ์ ๊ทผ์ ์ด, ๋๊ตฌ๋ ํธ์ถ ๊ฐ๋ฅํ๋ค.
statcic: ์ ์ ๋ฉ์๋
void: return ํ์
, ๊ฒฐ๊ณผ๊ฐ์ ๋ฐํํ์ง ์๋๋ค.
main: ๋ฉ์๋ ์ด๋ฆ
String[] args: ์ธ๋ถ์์ ์ฃผ์ด์ง๋ ๋ฐ์ดํฐ๋ฅผ ๋ฐ๋ ๋งค๊ฐ ๋ณ์
public static void main(String[] args)๋ ๋ฉ์๋์ ์ ์ธ๋ถ๋ก ๊ทธ๋๋ก ์ ์ด์ฃผ์ด์ผ ํ๋ค!
โป ๋ชจ๋ ํด๋์ค๊ฐ main() ๋ฉ์๋๋ฅผ ๊ฐ์ง๊ณ ์๋ ๊ฒ์ ์๋๋, ํ๋์ ์๋ฐ ํ๋ก๊ทธ๋จ์๋ main() ๋ฉ์๋๋ฅผ ๊ฐ์ง๊ณ ์๋ ํด๋์ค๊ฐ ๋ฐ๋์ ํ๋๋ ์์ด์ผ ํ๋ค.
๋ฌธ์ฅ
: ์ฌ์ฉ์๊ฐ ์ปดํจํฐ์๊ฒ ์์ ์ ์ง์ํ๋ ๋จ์
public class Hello{
public static void main(String[] args){
System.out.println("Hello World!");
}
}
System.out.println("Hello World!");
ํ๋ฉด์ ์ถ๋ ฅํ ๋ ์ฌ์ฉํ๋ ๋ฉ์๋
๋ฌธ์ฅ์ ๋์ ํญ์ ์ธ๋ฏธ์ฝ๋ก (;)์ผ๋ก ๋๋๊ฒ ๋จ
์๋ฃํ์ ์ข ๋ฅ
๊ธฐ์ดํ | ์ฐธ์กฐํ | |||
์ค์ ๊ฐ์ด ์ ์ฅ | ์ค์ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๋ ์ฃผ์ ์ ์ฅ | |||
์ ์ํ | ์ค์ํ | ๋ ผ๋ฆฌํ | ๋ฌธ์ํ | ํด๋์ค, ์ธํฐํ์ด์ค, ๋ฐฐ์ด |
byte, shrot, int, long | float, double | boolean | char |
๋ฌธ์ํ
- ์ ๋์ฝ๋ ๊ท๊ฒฉ ์ค UTF-16 ๊ท๊ฒฉ ์ฌ์ฉ
char ch1 = '๊ฐ'; // ์๋ฐ์์ ๋ถ๊ฐ๋ฅ → ํ๊ธ์ ํ๋์ ๋ฌธ์๋ก ์ทจ๊ธํ์ง ์์(๊ฐ์ ๊ฒฝ์ฐ, ์บ๋ฆญํฐ ๋ณ์ 2๊ฐ ํ์)
char ch2 = ‘\uac00'; // '๊ฐ'๋ฅผ ๋ํ๋
๋ฌธ์์ด
- ๋ฌธ์๋ค์ ๋ชจ์
- ๋ฌธ์์ด "Hello"๋ 5๊ฐ์ ์ ๋์ฝ๋ ๋ฌธ์๋ก ๊ตฌ์ฑ
- String ํด๋์ค ์ ๊ณต
public class StringTest{
public static void main(String args[]){
String s1 = "Hello World!"; // ๊ฐ์ฒดs1
String s2 = "I'm a new Java programmer!"; // ๊ฐ์ฒดs2
System.out.println(s1 + "\n" + s2);
}
}
์ ๋ ฅ๊ณผ ์ถ๋ ฅ
์
๋ ฅ: Scanner ํด๋์ค ์ฌ์ฉ
โ ํ๋ก๊ทธ๋จ์ ์ฒซ ์ค์ ๋ค์๊ณผ ๊ฐ์ ๋ฌธ์ฅ์ ์ถ๊ฐํ๋ค.
import java.util.*; // Scanner ํด๋์ค ํฌํจ
java.util : ํจํค์ง๋ช (Scanner๊ฐ ๋ค์ด์๋ ํจํค์ง ์ด๋ฆ)(์ด๋ฌํ ํจํค์ง๋ฅผ ์๋ฐ ํด๋์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ผ ๋ถ๋ฆ)
* : "๋ชจ๋ "์ด๋ผ๋ ๋ป
โก System.in์ ์ฐ๊ฒฐ๋ Scanner ๊ฐ์ฒด๋ฅผ ๋ค์๊ณผ ๊ฐ์ ๋ฌธ์ฅ์ผ๋ก ์์ฑํ๋ค.
Scanner input = new Scanner(System.in);
โข Scanner๊ฐ ์ ๊ณตํ๋ ๋ค์ํ ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ์ ๋ ฅ์ ๋ฐ๋๋ค.
System.out.print("๋ฌธ์ฅ์ ์
๋ ฅํ์์ค: ");
String line = input.nextLine(): // ํ ์ค์ ์ฝ๋๋ค.
03 ์ ํ๊ณผ ๋ฐ๋ณต
์ ์ด๋ฌธ
์ ์ด๋ฌธ์ ์ฌ์ฉํ๊ฒ ๋๋ฉด ์กฐ๊ฑด์ ์ํ์ฌ ๋ฌธ์ฅ๋ค์ ์คํ ์์๋ฅผ ๋ณ๊ฒฝํ ์ ์๋ค.
- ์กฐ๊ฑด๋ฌธ: ์กฐ๊ฑด์ ๋ฐ๋ผ์ ์ฌ๋ฌ ๊ฐ์ ์คํ ๊ฒฝ๋ก ๊ฐ์ด๋ฐ ํ๋๋ฅผ ์ ํํ๋ ๊ฒฝ์ฐ์ ์ฌ์ฉ → if-else ๋ฌธ์ฅ, switch ๋ฌธ์ฅ
- ๋ฐ๋ณต๋ฌธ: ์กฐ๊ฑด์ด ์ ์ง๋๋ ํ ๋๋ ์ ํด์ง ํ์๋งํผ ์ฒ๋ฆฌ๋ฅผ ๋ํ์ดํ๋ ๋ฌธ์ฅ→ for ๋ฌธ์ฅ, while ๋ฌธ์ฅ
04 ๋ฐฐ์ด
๋ฐฐ์ด
- ์ฌ๋ฌ ๊ฐ์ ๋ณ์๋ฅผ ํ๋๋ก ๋ฌถ์ด ๋ฃ๋ ๊ฒ
- ๋์ผํ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ์ฌ๋ฌ ๊ฐ ์ ์ฅํ ์ ์๋ ์ ์ฅ ์ฅ์
- ์๋ฐ์์ ๋ฐฐ์ด์ ๊ฐ์ฒด(object)์ด๋ค.
1. ์๋ฐ์ ๋ฐฐ์ด๋ ๊ธฐ๋ณธ ๊ฐ๋ ์ C++๊ณผ ๊ฐ๋ค.
2. ์๋ฐ ๋ฐฐ์ด์์ ๊ณ ์ ํ๊ฒ ์ฌ์ฉํ ์ ์๋ ๊ธฐ๋ฅ๋ค์ด ์๋ค. (ex. ๋ฐ๋ณต ์ ์ด๋ฌธ ์ค ๋ฐฐ์ด์ ์ํ ์ ์ด๋ฌธ์ด ๋ฐ๋ก ์๋ค.)
3. ์๋ฐ์ ๋ฐฐ์ด์ ๊ฐ์ฒด ์ทจ๊ธ๋๊ธฐ ๋๋ฌธ์ ์ด ๊ฐ์ฒด๋ค์ ์ํด์ ์ค๋น๋ ๋ค๋ฅธ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ์กด์ฌํ๋ค.
๋ฐฐ์ด์ ๋ง๋๋ ์ ์ฐจ
โ ๋ฐฐ์ด ์ฐธ์กฐ ๋ณ์ ์ ์ธ
int[] s; // size ์๋ต ๊ฐ๋ฅ
โก new ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌ ์์ฑ
s = new int[10];
โป ์ฐธ๊ณ
1. โ ๊ณผ โก ๊ณผ์ ์ ํ๋์ ๋ฌธ์ฅ์์ ํ์ฌ๋ ๋๋ค. ์ฆ, ๋ฐฐ์ด ์ ์ธ๊ณผ ๋์์ ๋ฐฐ์ด ์์ฑ์ด ๊ฐ๋ฅํ๋ค.
int[] s = new int[10];
2. ๋ฐฐ์ด์ ์์ฑํ ๋ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ๋ณ์๋ก ํ์ฌ๋ ๋๋ค. ์๋ฐ์์ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ ๋ฐ๋์ ์์์ผ ํ์๋ ์๋ค.
int size = 10;
int[] s = new int[size];
3. ์ฐธ์กฐ ๋ณ์ ์ ์ธ ๋ฐฉ๋ฒ - ์๋ฐ์์๋ C์ธ์ด์ ์ ์ฌํ๊ฒ ๋ฐฐ์ด ์ฐธ์กฐ ๋ณ์๋ฅผ ์ ์ธํ ์๋ ์๋ค.
int[] values; // ์๋ฐ ๋ฐฉ์
int values[]; // C์ธ์ด ์ ์ฌ ๋ฐฉ์
โป ๊ฒฝ๊ณ
์๋ฐ์์๋ ์๋ฃํ์ ์ ์ธํ ๋ ๋ฐฐ์ด ํฌ๊ธฐ๋ฅผ ์ง์ ํ ์ ์๋ค.
int array[5]; // ์ค๋ฅ
int array[] = new int[5]; // OK
๋ฐฐ์ด์ ์ด๊ธฐํ
public class ArrayTest3{
public static void main(String[] args){
int[] scores = {10, 20, 30, 40, 50};
for(int i = 0; i < scores.length; i++)
System.out.print(scores[i] + " ");
}
}
โป ๋ฐฐ์ด์ ์ด๊ธฐ๊ฐ: ์ซ์ ๋ฐฐ์ด์ 0, boolean ๋ฐฐ์ด์ false, ๋ฌธ์์ด ๋ฐฐ์ด์ null๋ก ์ด๊ธฐํ๋๋ค.
๋ฌด๋ช ๋ฐฐ์ด(anonymous arrays)
- ๋ฐฐ์ด์ ์ด๋ฆ์ ์ง์ ํ์ง ์๊ณ ์ด๊ธฐ๊ฐ๋ง์ผ๋ก ๋ฐฐ์ด ์์ฑ
- ์ฆ์ ๋ฐฐ์ด์ ๋ง๋ค์ด์ ํจ์์ ์ธ์๋ก ์ ๋ฌํ ๋ ์ฌ์ฉ
new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} // ๋ฐฐ์ด ์ด๋ฆ์ด ์๋ค. ์ฃผ์ด์ง ์ด๊ธฐ๊ฐ์ ๊ฐ์ง๋ ๋ฐฐ์ด์ด ์์ฑ๋๋ค.
for-each ๋ฃจํ
for( ๋ณ์ : ๋ฐฐ์ด ) { // ๋ณ์์ ๋ฐฐ์ด์์์๊ฐ ์ฐฐ๋๋ก ๋์
๋๋ฉด์ ๋ฐ๋ณต๋จ
...
}
์ผ๋ฐ์ ์ธ for๋ฌธ : for(์ด๊ธฐํ; ์กฐ๊ฑด์; ์ฆ๊ฐ(ํ์ถ)์) { }
for-each ๋ฃจํ๋ for ๋ฃจํ๋ณด๋ค ์ฌ์ฉํ๊ธฐ ์ฝ๋ค.
1. for-each ๋ฃจํ์์๋ ๋ฐฐ์ด์ ํฌ๊ธฐ์ ์ ๊ฒฝ ์ฐ์ง ์์๋ ๋๊ณ ์ธ๋ฑ์ค ๊ฐ์ ์ ์ฅํ๋ ๋ณ์๋ฅผ ์์ฑํ ํ์๋ ์๋ค.
2. ์ฌ์ฉ๋ฒ์ด ๊ฐ๊ฒฐํด ์ค๋ฅ ๋ฐ์ ๊ฐ๋ฅ์ฑ์ด ์ ๋ค.
→ ๋ฐฐ์ด์ ์์๋ฅผ ํ๋์ฉ ์ฒ๋ฆฌํ๋ ๊ฒฝ์ฐ, for-each ๋ฃจํ ์ฌ์ฉ ๊ถ์ฅ
for-each ๋ฃจํ๋ฅผ ์ฌ์ฉํ ์ ์๋ ๊ฒฝ์ฐ (→ ์ ํต์ ์ธ for ๋ฃจํ ์ฌ์ฉ)
1. ๋ฐฐ์ด ์์์ ๊ฐ์ ๋ณ๊ฒฝํ๋ ๊ฒฝ์ฐ
2. ์ญ์์ผ๋ก ๋ฐฐ์ด ์์๋ฅผ ์ฒ๋ฆฌํ๋ ๊ฒฝ์ฐ
3. ์ ์ฒด๊ฐ ์๋๊ณ ์ผ๋ถ ์์๋ง ์ฒ๋ฆฌํ๋ ๊ฒฝ์ฐ
4. ํ๋์ ๋ฐ๋ณต ๋ฃจํ์์ ๋ ๊ฐ ์ด์์ ๋ฐฐ์ด์ ์ฒ๋ฆฌํ๋ ๊ฒฝ์ฐ
โป ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ์ถ๋ ฅํ๋ ๋ฐฉ๋ฒ
System.out.println(Array.toString(numbers)); // Array ํด๋์ค์ toString() ๋ฉ์๋ ์ฌ์ฉ
๋ฐฐ์ด์ ๋ณต์ฌ
int [] list = {10, 20, 30, 40, 50};
int [] numbers = list;
์ด ๊ฒฝ์ฐ์ 2๊ฐ์ ๋ณ์๊ฐ ๋์ผํ ๋ฐฐ์ด์ ์ฐธ์กฐํ๊ฒ ๋๋ค.
๋ฐฐ์ด ๋ณ์์ ๊ฒฝ์ฐ, ๋ฐฐ์ด์ ์ฐธ์กฐ๊ฐ(์ฃผ์)์ด ์ ์ฅ๋์ด ์์์ ๋ช
์ฌํด์ผ ํ๋ค. (๋ฐฐ์ด์ด ์ ์ฅ๋์ด ์๋ ๊ฒ์ด ์๋!)
ํ ๋ฐฐ์ด์ ๋ชจ๋ ๊ฐ์ ๋ค๋ฅธ ๋ฐฐ์ด๋ก ๋ณต์ฌํ๊ณ ์ถ๋ค๋ฉด Arrays ํด๋์ค์ copyOf() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค.
int [] list_copy = Array.copyOf(list, list.length); // ex.ํ์ฌ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ 2๋ฐฐ๋ก ๋ณ๊ฒฝํ ๊ฒฝ์ฐ list = Arrays.copyOf(list, 2 * list.length);โ
main()์ ๋ช ๋ นํ ๋งค๊ฐ๋ณ์
์๋ฐ ํ๋ก๊ทธ๋จ์๋ main() ๋ฉ์๋๊ฐ ์๊ณ main()์ String[] args ๋งค๊ฐ ๋ณ์๋ฅผ ๊ฐ์ง๊ณ ์๋ค. ์ด ๋งค๊ฐ ๋ณ์๋ ๋ฐ๋ก ๋ฌธ์์ด ๋ฐฐ์ด์ด๋ค.
public class CommandLine{
public static void main(String[] args){
if(args.length > 0){
for(int i = 0; i < args.length; i++)
System.out.print(" " + args[i]);
if(args[0].equals("-h"))
System.out.print("HELP");
}
}
}
์ด ํ๋ก๊ทธ๋จ์ ์ฐ๋ฆฌ๊ฐ ๋ช
๋ น์ด ํ๋กฌํํธ์์ ์ฃผ๋ ์ธ์๋ค์ ์ถ๋ ฅํ๋ค.
Eclips์์ Run → Run Configuration → Argument ํญ์ ์ด์ฉํด ์ธ์๋ค์ ์ค์ ํ ์ ์๋ค.
๋ฐฐ์ด ์ ๋ ฌ
๋ฐฐ์ด ์ ๋ ฌ ์ Arrays.sort()๋ฅผ ์ฌ์ฉํ๋ค.
int[] a = new int[100];
a[0] = 32;
a[1] = 21;
...
Arrays.sort(a);
โป ์ฐธ๊ณ - ๋๋คํ ์๋ฅผ ์ ๋ ฌํ ๋ (๊ต์ฌ 169์ชฝ)
random() ๋ฉ์๋๋ Math ํด๋์ค์ ์๋ค.
int r = (int)(Math.random() * 100);
2์ฐจ์ ๋ฐฐ์ด
int[][] s = new int[3][5]; // 3ํ 5์ด
// 2์ฐจ์ ๋ฐฐ์ด์ ์ด๊ธฐํ
int[][] array = {
{10, 20, 30, 40},
{50, 60, 70, 80},
{90, 100, 110, 120}
};
'Study > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์๋ฐํ๋ก๊ทธ๋๋ฐ 6์ฃผ์ฐจ ์ ๋ฆฌ (0) | 2022.04.16 |
---|---|
์๋ฐํ๋ก๊ทธ๋๋ฐ 5์ฃผ์ฐจ ์ ๋ฆฌ (0) | 2022.04.09 |
์๋ฐํ๋ก๊ทธ๋๋ฐ 4์ฃผ์ฐจ ์ ๋ฆฌ (0) | 2022.04.03 |
์๋ฐ ๊ณต๋ถ ์ค ๊ถ๊ธํ ์ (0) | 2022.04.03 |
์๋ฐํ๋ก๊ทธ๋๋ฐ 3์ฃผ์ฐจ ์ ๋ฆฌ (0) | 2022.03.27 |