1.๋ฉ๋ชจ๋ฆฌ์ ์ ์ ๊ณต๊ฐ 2๊ฐ๋ฅผ ํ๋ณดํ์ฌ ๊ฐ๊ฐ 5,7์ ๊ธฐ์ต์ํค๊ณ ๊ทธ ์์ ๋ง์
์์ ํ๋ฉด์ ํ์ํด๋ณด์ธ์.
2.๋ฉ๋ชจ๋ฆฌ์ ์ ์ ๊ณต๊ฐ 2๊ฐ๋ฅผ ํ๋ณดํ์ฌ ๊ฐ๊ฐ 3.141592, 2.71828์ ๊ธฐ์ต์ํค๊ณ ๊ทธ ์์ ๊ณฑ์
์์ ํ๋ฉด์ ํ์ํด๋ณด์ธ์.
3. ๋ฐ์ง๋ฆ์ด 5.1์ธ ์์ ๋ฉด์ ์ ๊ตฌํ์ฌ ํ๋ฉด์ ํ์ํด๋ณด์ธ์.
4.๋ฐ์ง๋ฆ์ด 2.8์ธ ์์ ๋๋ ๋ฅผ ๊ตฌํ์ฌ ํ๋ฉด์ ํ์ํด๋ณด์ธ์.
์ ์ ํ์
๋ณ์ int ์ ์ค์ ํ์
๋ณ์ double๋ฅผ ์ด์ฉํ์ฌ ๊ฐ๋จํ ์ฐ์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์๋ค.
๋ณด์ํด์ผํ ์ ++++) ์ ์ ํฌ๊ธฐ๊ฐ ์์ผ๋ฏ๋ก int ๋์ ์ byte ๋ณ์๋ฅผ ์จ์ผ ๊ณต๊ฐ์ ๋์ฐจ์งํ๋ ๋ฐฉํฅ์ผ๋ก ์ฝ๋ฉํด์ผํ๋๋ฐ, ๋ฌด์์์ ์ผ๋ก int๋ฅผ ๋จผ์ ์ผ๋ค. ใ
,ใ
์ ์ฅ๋๋ ๊ฐ์ ๋ฒ์๋ฅผ ์ ๊ณ ๋ คํด์ ๋ณ์๋ฅผ ์ ํด์ค์ผ๊ฒ ๋ค!
์์(format) ๋ฌธ์์ด ์ถ๋ ฅ System.out.printf("%d +%d =%d \n", b1, b2, b3); printf ์ f๋ format์ f๋ค d๋ 10์ง์ ์ ์๋ฅผ ์๋ฏธ
float a1 = 3.141592; ๊ฐ ์๋ฌ๊ฐ ๋จ๋ ์ด์ : ์ค์๊ฐ ๋ฉ๋ชจ๋ฆฌ์ load๋ ๋ ๋ฌด์กฐ๊ฑด 64๋นํธ๋ก ๋ก๋๋๊ฒ ๋์ด์๋ค. float๋ 32๋นํธ๋ผ์ ์๋ฌ๊ฐ ๋ฌ๋ค
float a1 = 3.141592 ์ ์ค์๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ loadํ ๋๋ถํฐ 32๋นํธ๋ก ์ฌ๋ ค๋ฌ๋ผ๊ณ ํ๊ธฐ ์ํด์ float a1 = 3.141592F; ๋ผ๊ณ ํ๋ฉด๋๋ค.
*2๋ฒ ๋ฌธ์ ๋ฅผ ๋ฌธ์์ด ์ถ๋ ฅ์ผ๋ก ์์ ๋ํ๋ธ๋ค๋ฉด*
float f3 = 3.141592F;
float f4 = 2.71828F;
float f5 = (f3 * f4);
System.out.printf("%f * %f = %f \n", f3, f4, f5);
์ฝ์ ํ์ ๊ฐ: 3.141592 * 2.718280 = 8.539727
*3๋ฒ ๋ฌธ์ ๋ฅผ ๋ฌธ์์ด ์ถ๋ ฅ์ผ๋ก ์์ ๋ํ๋ธ๋ค๋ฉด*
float r = 5.1F;
final float pi1 = (float) Math.PI;
//final ์ ๋ณ์๊ฐ ์๋ ์์๋ผ๊ณ ํ๋ค Constants
System.out.printf("%f * %f * %f= %f \n", r, r, pi1, r*r*pi1);
์ฝ์ ํ์ ๊ฐ: 5.100000 * 5.100000 * 3.141593= 81.712822
๋
ผ๋ฆฌ์ฐ์ฐ์(Logical Operator) : &&, ||, &, |, !
&& ๋จ์ถ๋
ผ๋ฆฌ์ค๋ : System.out.println(false && true);
false์ &&๋ง ๋ณด๊ณ ๋ค์ ture๋ ํ์ธ์กฐ์ฐจ ์ํจ ์ด์ฐจํผ ๊ฐ์ false๋ก ์ ํด์ ธ ์์ผ๋๊น
& ๋น๋จ์ถ๋
ผ๋ฆฌ์ค๋ : false์ฌ๋ ๋ค์ ๊ฐ๊น์ง ํ์ธํ๋ค.
String uid; // ๋ฌธ์์ด์ ๋ค๋ฃจ๊ธฐ ์ํ ์ ๋ณด, ๊ธฐ๋ฅ์ ํฌํจํ ๊ฐ์ฒด
uid = "smith";
uid.equals("smith"); //uid์ ์๋ ๋ฌธ์์ด๊ณผ ()์์ ์๋ ๋ฌธ์์ด์ด ๋์ผํ๋ฉด true๋ฅผ returnํ๋ค.
//equals๋ method๋ผ ํ๋ฉฐ ๊ธฐ๋ฅ์ด๋ผ ํ๋ค. uid.equals("smith");๋ ๋
ผ๋ฆฌ ํํ์์ด๋ผ ํ ์ ์๋ค.
boolean logon = uid.equals("smith");
String result = logon ? "๋ก๊ทธ์ธ ์ฑ๊ณต" : "๋ก๊ทธ์ธ ์คํจ"; //3ํญ์ฐ์ฐ์
//์ฒซ๋ฒ์งธ ์นํฐ๋ ๋ฌด์กฐ๊ฑด boolean๊ฐ์ด ๋ค์ด๊ฐ์ผํ๋ค. true๋ฉด ? ๋ค์ ๊ฑธ ๋ฆฌํดํ๊ณ false๋ฉด : ๋ค์๊ฑธ ๋ฆฌํดํ๋ค.
์กฐ๊ฑด์ด 2๊ฐ ์ผ๋ ์ด๋ค. ex) ํด์ผ/ํ์ผ , ์ฑ์ธ/๋ฏธ์ฑ๋
์ , ํ์/๋นํ์ , ์ฌ์/๋จ์
System.out.println(result);
์ฝ์ ํ์ ๊ฐ: ๋ก๊ทธ์ธ ์ฑ๊ณต
char ch, ch2;
// char <- ๋ฐ์ดํฐ ํฌ๊ธฐ์ ์ข
๋ฅ๋ฅผ ๊ฒฐ์ ํด์ค๋ค.
ch = 'a'; //" " ์ ๋ฌธ์์ด ' ' ์ ๋ฌธ์ ํ๊ธ์๋ง ๊ฐ๋ฅํ๋ค. literal: ์ฝ๋์์ ๋ฐ์ดํฐ์ ์ง์ ์ ์ธ ํํ
//ex) true ํ๋๋ง ์์ผ๋ฉด boolean literal ์ด์ง๋ง !true , true && true ๋ boolean expression (ํํ์)์ด๋ผ ํ๋ค.
ch2 = 'z';
System.out.printf("%c -> %d, %c -> %d \n" , ch, (int)ch, ch2, (int)ch2);
System.out.println("๊ทธ ์ฐจ์ด๋" + (((int)ch2)-((int)ch)) + "์
๋๋ค.");
์ฝ์ ํ์ ๊ฐ : a -> 97, z -> 122
๊ทธ ์ฐจ์ด๋25์
๋๋ค.
๋ฌด์์ ์ซ์ ์ถ์ถ
Random rd = new Random();
// ^ (์ฐธ์กฐ๋ถ๋ถ) ^
//Random์ ์ฐธ์กฐํ ๋ณ์ํ
// ์๋ก์ด ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋ new๋ฅผ ์ด๋ค
//๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น (ํ๋ก๊ทธ๋จ์ด ์๋ํ ๋ load๋๋ค.) heap์ด๋ผ๋ ์์ญ์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ ๋น๋๋ค.
System.out.println( rd );
rd.nextInt(5); //0~4๊น์ง ๋์จ๋ค
int rdn = rd.nextInt(5);
System.out.println("๋ฌด์์ ์ถ์ถ๋ ๊ฐ"+ rdn);
์ฝ์ ๊ฐ : ๋ฌด์์ ์ถ์ถ๋ ๊ฐ1
ํ์๋ฒํธ 11~20 ์ค์์ 3๋ช
์ ๋ฌด์์๋ก ์ถ์ถํด๋ผ
int num = rd.nextInt(10)+11;
System.out.println("ํ์๋ฒํธ ์ถ์ฒจ"+ num);
์ฝ์ ๊ฐ: ํ์๋ฒํธ ์ถ์ฒจ13
๋ฌด์์ ์, ํ์์ธ์ง ์ง์์ธ์ง ํ์
ํ๊ธฐ
System.out.println(5/2); //๋ชซ ์ ์๋ง ๋์ค๋ ๋๋๊ธฐ
System.out.println(5%2); //๋๋จธ์ง ์ ์๋ง ๋์ค๋ ๋๋๊ธฐ
/ ๋๋๊ธฐ ์ฐ์ฐ์๋ ์ ์ ๋๋๊ธฐ ์ ์๋ฅผ ํด์ ๋ชซ ๊ฐ๋ง์ ๋ํ๋ด์ค๋ค.
%๋๋๊ธฐ ์ฐ์ฐ์๋ ๋๋๊ณ ๋์ ๋์จ ๋๋จธ์ง ๊ฐ์ ๋ํ๋ด์ค๋ค.
๋ฌด์์ ์ ์ ์ถ์ถํ์ฌ ๊ทธ์๊ฐ ํ์์ธ์ง ์ง์์ธ์ง๋ฅผ ๋ฌธ์์ด๋ก ํ์ํ๋ ๊ธฐ๋ฅ์ ์์ฑํด ๋ณด์ธ์.
int x = rd.nextInt(100);
boolean v = ((x%2)==1 );
String result2 = v ? "ํ์" : "์ง์";
System.out.printf("%d, %s \n" , x, result2);
์ฝ์ ๊ฐ : 90, ์ง์
๋
ผ๋ฆฌ ๋ณ์ ์ ์ฉ๊ณผ ๋๋จธ์ง๋ฅผ ๋ํ๋ด๋ ๋๋๊ธฐ ์ด์ฉ!
๋ ์งง๊ฒ ๋ํ๋ด๋ ๋ฐฉ๋ฒ
x = rd.nextInt(100);
System.out.printf("%d, %s \n" , x, x%2==1 ? "ํ์" : "์ง์");
๋๊ธ