weekendcode
@weekendcode
Students
4,775
Reviews
580
Course Rating
4.8
์๋ ํ์ธ์. @weekendcode ๋ผ๋ ์ ํ๋ธ ์ฑ๋์ ์ด์ํ๊ณ ์์ต๋๋ค.
๋น์ ๊ณต์, ํ๋ก๊ทธ๋๋ฐ์ ๊ด์ฌ ์๋ ํ์๋ค์ ์ํด ์ต๋ํ ์ฝ๊ฒ ์ค๋ช ํ๊ณ ์ ๋ ธ๋ ฅํ๋ ๊ฐ์ฌ์ ๋๋ค.
์ปดํจํฐ ๊ณตํ์ผ๋ก ๋ํ๊ต๋ฅผ ์กธ์ ํ๊ณ , ์ธ๊ฐ-์ปดํจํฐ ์ํธ์์ฉ ์ฐ๊ตฌ๋ถ์ผ๋ก ์์ฌ ํ์๋ฅผ ๋ฐ์์ต๋๋ค.
Java ์ธ์ด๋ก ์๋๋ก์ด๋ ๊ฐ๋ฐ์๋ก์ ์ผํ๊ณ , Python ๊ฐ์ฌ๋ก ํ๋ํ์ต๋๋ค.
๋ช ๋ฒ์ ์ด์ง๊ณผ ์ฐฝ์ ์ ํ๋ ๊ณผ์ ์์ ๋น์ ๊ณต์ ๋ถ๋ค๊ป ์ง์์ ๊ณต์ ํ ๊ธฐํ๊ฐ ์๊ธด ์ดํ,
๋ณธ๊ฒฉ์ ์ผ๋ก ์ง์๊ณต์ ์๋ก ํ๋ํ๊ณ ์์ต๋๋ค.
๋ชจ๋ฅด๋ ๊ฒ์ ์ ๊ทน์ ์ผ๋ก ์ง๋ฌธ ๋ถํ๋๋ฆฝ๋๋ค.
์ต์ ์ ๋คํด์ ๋ต๋ณ ๋๋ฆฌ๊ฒ ์ต๋๋ค.
์ข์ ํ๋ฃจ ๋ณด๋ด์ธ์.
Courses
Reviews
- (2026) Pass the Information Processing Engineer Practical Exam in Just One Week
- (2026) Pass the Information Processing Engineer Practical Exam in Just One Week
- (2026) Pass the Information Processing Engineer Practical Exam in Just One Week
- (2026) Pass the Information Processing Engineer Practical Exam in Just One Week
heungryuncho09034954
ยท
(2026) Pass the Information Processing Engineer Practical Exam in Just One Week(2026) Pass the Information Processing Engineer Practical Exam in Just One Week
Posts
Q&A
์๋์ฆ๊ฐ ๊ด๋ จ ์ง๋ฌธ
์๋ ํ์ธ์,์ง๊ธ ์์ฑ์ ์ธ์คํด์ค๋ฅผ 2๊ฐ๋ฅผ ํ ๊ฒ์ ๋๋ค. ๊ฐ๊ฐ์ ๋ ๋ฆฝ๋ ๊ณต๊ฐ์ ๋๋ค.๊ทธ๋์ ํ ์ฌ๋ผ๊ฐ 50ํฌ๋ก ๋ ๊ฒ์ด๊ณ , ํ๋์ฐจ๊ฐ 30ํฌ๋ก๊ฐ ๋ ๊ฒ์ ๋๋ค.ํ๋์ ์ธ์คํด์ค์ ๋์ ๋๋ ๊ฒ์ด ์๋๋ผ, ๊ฐ๊ฐ์ ์ธ์คํด์ค๋ ๋ ๋ฆฝ์ ์ผ๋ก ์ฌ๋ผ๊ฐ์ผํฉ๋๋ค. ๊ฐ์ ํด๋์ค ๋ด์์ ํ์๋์ด์ ๊ณต์ ๋๋ ๋ณ์๋ ํ์ฌ ์ฝ๋ ์์์๋ totalCars๋ฐ์ ์์ต๋๋ค.
- 0
- 2
- 12
Q&A
์ ํ๋ธ ์ฃผ๋ง์ฝ๋ฉ ์ฑ๋๋ณด๋ฉด์ ์ค๋ ์ธํ๋ฐ ์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ ์ค๊ธฐ ๊ฐ์ ๊ฒฐ์ ๋ฅผ ํ์ฌ ์น์ 1์ ๋ค์์ต๋๋ค... ^^;; (์ด๋ฒ ์ ์ฒ๊ธฐ ์ค๊ธฐ 4๋ฒ์งธ ๋์ ์ค..)
์๋ ํ์ธ์,์ผ๋ง๋ ๋์ด๊ฐ ์์ผ์ ์ง๋ ์ ๋ชจ๋ฅด๊ฒ ์ต๋๋ค๋ง์ ์ฃผ๋ณ์ 30๋ ํ๋ฐ์ ๊ฐ๋ฐ์ ์์ํด์ 40 ์ด๋ฐ์ ์ ์ ์ผ๋ก ์ผํ์๋ ๋ถ๋ ๊ณ์ญ๋๋ค.๋์ ์์ฒด๋ง์ผ๋ก๋ ๋ฉ์๋ค๊ณ ์๊ฐ์ด ๋๋๋ฐ, ๊ฒฐ๊ณผ๊น์ง๋ ์๊ฒจ๋๋ฆฌ๋ฉด ์ข๊ฒ ๋ค์. ์ฐ์ ์ฝ๋๋ ๋ถ์ ๊ณตํ์ จ์ผ๋ C, Java๋ ๋ฌธ๋ฒ์ ์๊ณ ๊ณ์๋ฆฌ๋ผ ์๊ฐํฉ๋๋ค.ํ์ง๋ง Java๋ ์ค์ ๊ฐ๋ฐ์๊น์ง ํ์ง ์์ผ์ จ๋ค๋ฉด ์ ์บ์คํ ์ด๋ ๊ธฐ๋ณธ Java API๊น์ง๋ ์ ๋ชจ๋ฅด์ค ๊ฒ๋๋ค. ์ด๋ฐ ๊ฒ๋ค์ ์ด์ฉ ์ ์์ด ์์ฃผ ๋ณด์ ์ผ์ง ํฉ๊ฒฉ์ด ๊ฐ๋ฅํฉ๋๋ค.(์ ๋ Java ์ธ์ด์ ๊ตฌ์กฐ๋ API๋ฅผ ์๋๋ก์ด๋ ๊ฐ๋ฐ์ํ๋ฉด์ ์ตํ์ผ๋ ๋จ์ํ ํ๊ณผ ์กธ์ ํ๋ค๊ณ ํด์ ์ดํดํ ์ ์๋ค๋ ๊ฒ์ ๋ฌด๋ฆฌ๋ผ๊ณ ์๊ฐ๋ฉ๋๋ค.) ์ปดํจํฐ ์ด๋ก ์ ์๋ ์์ด๋ฒ๋ฆฌ๊ธฐ๋ ํ๊ณ , ํ๊ต์์๋ ์ ์ ์๋ ค์ค๋๋ค.์ ๋ ์ํํธ์จ์ด ๊ณตํ ์์ ์ ๋ฃ๊ธด ํ๋๋ฐ, ์ ๋ณด์ฒ๋ฆฌ๊ธฐ์ฌ์์ ๋์ค๋ ๊ฒ๋ค ๋ค์ ์ฒ์๋ถํฐ ๊ณต๋ถํ๋ ๊ธฐ์ต์ด ๋๋ค์. ๋จผ ๋ฏธ๋์ ๊ธฐ์ ์ฌ ์๊ฒฉ์ฆ์ ์ค๋นํ์ง ์๋ ํ ๋ค์ ์ฒ์๋ถํฐ ์ธ์ฐ๊ธฐ๋ ์ ์ฝ์ง ์๋ค๋ ์๊ฐ์ด ๋ค์์ต๋๋ค. ์ ๋ ๊ทธ๋ ๊ณ , ์ ์ฃผ๋ณ ๋ถ๋ค๋ ๊ทธ๋ ๊ณ ์ด๋ก ์ ๊ทธ๋ฅ ๊ณ์ ๋ณด๊ณ ์ต์ํด์ง๋ ๊ฒ๋ฐ์ ์๋ค๋ ์๊ฐ์ ๋๋ค.์๋ณด๋ฉด ์์ด๋ฒ๋ฆฌ๋ ๊ฒ์ด ๋น์ฐํ์ฃ . ์ ๊ฐ ์์ ์๋ถ๋ถ์ธ๊ฐ์์ ๋ง์๋๋ ธ๋์ง ๋ชจ๋ฅด๊ฒ ๋๋ฐ,์ ์ฃผ๋ณ์ ์ปดํจํฐ๊ณตํ๊ณผ์์ ๊ณผํํ๋ ์น๊ตฌ๋ค์ ์ง๊ธ ๋ค์ด๋ฒ, ํ ์ค, ์นด์นด์ค์์ ์ผํ๊ณ ์์ง๋ง ์ ๋ณด๋ค C์ธ์ด๋ฅผ ์ ๋ชจ๋ฆ ๋๋ค.๊ทธ๋ ๊ทธ๋ด ๊ฒ์ด ์ ๋ ์ค๋๋ C์ธ์ด๋ฅผ ๋ณด๊ณ ์์ผ๋๊น์. ์์ฃผ ๋ณด๊ณ ์ต์ํด์ง์๋ฉด ์ ๋ณด๋ค๋ ํจ์ฌ ๋ ์ํ์๊ฒ ๋๋ฆฌ๋ผ ๋ฏฟ์ต๋๋ค. ์์ํ๊ฒ ์ต๋๋ค. ๋ชจ๋ฅด๋ ๊ฒ์ด ์์ผ๋ฉด ์ง๋ฌธ ์ฌ๋ ค์ฃผ์ธ์.ํ์ ํ๋ ๋๋ฆฌ์๋ฉด ์ง๋ฌธํ์๊ธฐ ์ ์ ์จ๋ผ์ธ์์ ๊ฐ ์ธ์ด์ ์ปดํ์ผ๋ฌ๋ก ์ง์ ์คํํด๋ณด์๊ณ ์ง๋ฌธ ์ฌ๋ฆฌ์๋ ๊ฒ์ ๊ถ์ฅ๋๋ฆฝ๋๋ค. C: https://www.programiz.com/c-programming/online-compiler/Java : https://www.programiz.com/java-programming/online-compiler/Python : https://www.programiz.com/python-programming/online-compiler/
- 0
- 2
- 35
Q&A
๋ฒ์ธ ์ง๋ฌธ
์๋ ํ์ธ์, ๊ฐํ๋!์ฃผ์ ๋ฌธ์ฅ์ผ๋ก๋ง์ ์ง๋ฌธ์ด ์กฐ๊ธ ์ดํด๊ฐ ์ด๋ ต์ต๋๋ค. ๊ทธ๋์ ๋ค์ ์ง๋ฌธ๋๋ฆฝ๋๋ค. int a[3][2]={{1,2}, {3,4}, {5,6}} int *p=a[1]; ๋ผ๊ณ ๋์ด์๊ณ printf๋ฅผ ํ ๋ *a์ **a์ ์ฐจ์ด๊ฐ ์์๊น์?์ฌ๊ธฐ์ printf์ ๋ค์ด๊ฐ๋ ๋ณ์ ๋ถ๋ถ ์์ *a, **a ๊ฐ ๋ค์ด๊ฐ๋ฉด ์ด๋ป๊ฒ ๋๋์ง๋ฅผ ๋ฌผ์ด๋ณด์๋ ๊ฑธ๊น์? ์ ์์ ์ค ์ด๋ ๋ถ๋ถ์์ ์ง๋ฌธ์ด ์๊ฒผ๋์ง๋ ํจ๊ป ์ฃผ์๋ฉด ๋ต๋ณ์ ํฐ ๋์์ด ๋ฉ๋๋ค.
- 0
- 2
- 23
Q&A
์ ์ง์ง ๊ตฌ์กฐ์ฒด ์ดํด ์๋๋๋ฐ์
์๋ ํ์ธ์, ๋ง์ด ์ด๋ ค์ฐ์์ฃ .์์ ์ฝ๋๋ฅผ ์ฒ์ ๋ฐฐ์ฐ์๋ ๋ถ๋ค์ด๋ผ๋ฉด C์ธ์ด ์์ฒด๊ฐ ์ด๋ ค์ธ ์ ์์ต๋๋ค.์ปดํจํฐ๊ณตํ๊ณผ 1ํ๋ ๋ C์ธ์ด๋ฅผ 6๊ฐ์ ๊ฐ ๋ฐฐ์ ๋ ์ ๋ ๊ทธ๋ฌ๊ณ ์.์์์ ๋ถ์ด์ ๊ณผ์ธ์ฒ๋ผ ๊ฐ๋ฅด์ณ์ฃผ์ง ์๋ ํ, ์๋ ์ด๋ ค์ด ๊ฒ์ด ๋ง์ต๋๋ค. ์ฐ์ ๋ฌธ๋ฒ์ ๋์งธ์น๊ณ ,๊ฐ๋ ์์ฒด๊ฐ ์ด๋ ค์ฐ์ ๊ฒ ๊ฐ์ต๋๋ค.์ฒซ๋ฒ์งธ๋ ํฌ์ธํฐ ๊ฐ๋ ์ด๊ณ ๋๋ฒ์งธ๋ "ํจ์๋ฅผ ํธ์ถํ๋ค"๋ผ๋ ๊ฐ๋ ์ ๋๋ค.8:14์ ๋์จ ์ฝ๋ ๊ธฐ์ค์ผ๋ก ์ข ๋ ๊ตฌ์ฒด์ ์ผ๋ก ์ค๋ช ํด๋ณผ๊ฒ์.#include #include // ๊ตฌ์กฐ์ฒด ์ ์ struct Bag { char brand[50]; // ๋ธ๋๋๋ช ์ ์ ์ฅํ ๋ฌธ์์ด ๋ฐฐ์ด int year; // ์ ์ ์ฐ๋๋ฅผ ์ ์ฅํ ์ ์ํ ๋ณ์ float price; // ๊ฐ๊ฒฉ์ ์ ์ฅํ ์ค์ํ ๋ณ์ }; // ๊ตฌ์กฐ์ฒด ํฌ์ธํฐ๋ฅผ ์ธ์๋ก ๋ฐ์์ ์ถ๋ ฅํ๋ ํจ์ ์ ์ void printBag(struct Bag * bag) { printf("Brand: %s\n", bag -> brand); printf("Year: %d\n", bag -> year); printf("Price: %.2f\n", bag -> price); } int main() { struct Bag myBag; // ๊ตฌ์กฐ์ฒด ๋ณ์ ์ ์ธ struct Bag * bagPtr = & myBag; // ๊ตฌ์กฐ์ฒด ํฌ์ธํฐ ์ ์ธ ๋ฐ ์ด๊ธฐํ // ํฌ์ธํฐ๋ฅผ ํตํด ๊ฐ ํ ๋น strcpy(bagPtr -> brand, "Gucci"); bagPtr -> year = 2021; bagPtr -> price = 1500.50; printBag(bagPtr); // ๊ตฌ์กฐ์ฒด ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ์ฌ ํจ์ ํธ์ถ return 0; }
- 0
- 3
- 35
Q&A
6๋ถ 40์ด ์ง๋ฌธ
์๋ ํ์ธ์, ์ง๋ฌธ ๋ง์ด ํ์ ๋ ๊ด์ฐฎ์ต๋๋ค.๋ค๋ง ์ ๊ฐ ๋ฐ๋ก๋ฐ๋ก ๋ต๋ณํ ์ ์์ ์ง๊ฐ ๊ฑฑ์ ์ด๋ค์. ํต์ฌ: A b๋ class B๋ก "๋๋" ๊ฒ ์๋๋๋ค.A b = new B();๋ฅผ ํ์ด์ ์ค๋ช ํ๋ฉด:A b = new B(); //โ โ โ โ //โ โ โ โโ B ํด๋์ค์ ๊ธฐ๋ณธ ์์ฑ์ ํธ์ถ //โ โ โโโโโโ ์๋ก์ด ๊ฐ์ฒด ์์ฑ //โ โโโโโโโโโโ ๋ณ์๋ช (์๋ฌธ์ b) //โโโโโโโโโโโโ ๋ณ์์ ํ์ (ํด๋์ค A) 1. ๋์๋ฌธ์ ๊ตฌ๋ถA, B (๋๋ฌธ์) = ํด๋์ค ์ด๋ฆb (์๋ฌธ์) = ๋ณ์ ์ด๋ฆJava๋ ๋์๋ฌธ์๋ฅผ ์๊ฒฉํ ๊ตฌ๋ถํฉ๋๋ค. b์ B๋ ์์ ํ ๋ค๋ฅธ ๊ฒ์ ๋๋ค. A b = new B(); ์ด ๋ฌธ์ฅ์ ์๋์ ๊ฐ์ด ์ดํดํด์ผํฉ๋๋ค.์ค์ ์์ฑ๋๋ ๊ฐ์ฒด: B ํ์ (์์)๋ณ์ b์ ํ์ : A ํ์ (๋ถ๋ชจ)์๋ฏธ: "B ๊ฐ์ฒด๋ฅผ ๋ง๋ค์์ง๋ง, A ํ์ ๋ณ์๋ก ์ฐธ์กฐํ๊ฒ ๋ค" 2. ์ ์ด๋ ๊ฒ ์ธ๊น์?// ์์ class Animal { // ๋ถ๋ชจ void sound() { System.out.println("..."); } } class Dog extends Animal { // ์์ void sound() { System.out.println("๋ฉ๋ฉ"); } } class Cat extends Animal { // ์์ void sound() { System.out.println("์ผ์น"); } } // ์ฌ์ฉ Animal pet1 = new Dog(); // Dog ๊ฐ์ฒด๋ฅผ Animal ํ์ ์ผ๋ก Animal pet2 = new Cat(); // Cat ๊ฐ์ฒด๋ฅผ Animal ํ์ ์ผ๋ก pet1.sound(); // "๋ฉ๋ฉ" ์ถ๋ ฅ (์ค์ ๋ Dog) pet2.sound(); // "์ผ์น" ์ถ๋ ฅ (์ค์ ๋ Cat)์ด๋ ๊ฒ ํ๋ฉด ๋ค์ํ ์์ ๊ฐ์ฒด๋ค์ ๋ถ๋ชจ ํ์ ํ๋๋ก ๊ด๋ฆฌํ ์ ์์ต๋๋ค. 3. ์ฃผ์์ฌํญA b = new B(); b.๋ฉ์๋(); // A์ ์๋ ๋ฉ์๋๋ง ํธ์ถ ๊ฐ๋ฅ // B์๋ง ์๋ ๋ฉ์๋๋ ํธ์ถ ๋ถ๊ฐ๋ณ์ ํ์ ์ด A์ด๋ฏ๋ก, A์ ์ ์๋ ๋ฉ์๋๋ง ์ฌ์ฉํ ์ ์์ต๋๋ค.(๋จ, ์ค๋ฒ๋ผ์ด๋ฉ๋ ๋ฉ์๋๋ B์ ๊ตฌํ์ด ์คํ๋จ)ํต์ฌ ์์ฝ: A b = new B();๋ "B ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด์ A ํ์ ๋ณ์๋ก ๊ฐ๋ฆฌํจ๋ค"๋ ์๋ฏธ์ ๋๋ค.
- 0
- 2
- 25
Q&A
์น์ 3. 17๊ฐ. 23:00 ์ง๋ฌธ ์์ต๋๋ค.
printf("์ ๋ ฅ๋ ๋ฌธ์์ด: %c\n", str)%c๋ ๋ฌธ์ ๊ทธ ์์ฒด๋ฅผ ์ถ๋ ฅํ๋ ํฌ๋งท์ด๊ณ , ์ฃผ์๊ฐ ์ค๋ฉด ์๋ฉ๋๋ค.๋ฐฐ์ด์ ์ด๋ฆ ๊ทธ ์์ฒด๋ ๋ฐฐ์ด์ ์์ ์ฃผ์๋ฅผ ๊ฐ์ง๋๋ค. str์ ๋ฏ์ด๋ณด๋ฉด ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ผ๋ ๊ฒ์ด์ฃ . ๊ทธ๋์ ๊ฒฐ๋ก ์ ์ผ๋ก๋ ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค.๊ทธ๋ฐ ์ฝ๋๋ ์ํ ๋ฌธ์ ์์ ์ถ์ ๋์ง ์์ต๋๋ค.#include int main() { char str[] = "this is string"; printf("=== 1. %%s์ %%c์ ์ฐจ์ด ===\n"); printf("%%s๋ก ์ถ๋ ฅ: %s\n", str); printf("%%c๋ก ์ถ๋ ฅ: %c\n", str); // โ ๏ธ ๊ฒฝ๊ณ ๋ฐ์! ์ด์ํ ๋ฌธ์ ์ถ๋ ฅ๋จ printf("\n"); printf("=== 2. ์ฌ๋ฐ๋ฅธ %%c ์ฌ์ฉ๋ฒ ===\n"); printf("์ฒซ ๋ฒ์งธ ๋ฌธ์๋ง ์ถ๋ ฅ: %c\n", str[0]); // 't' ์ถ๋ ฅ printf("๋ ๋ฒ์งธ ๋ฌธ์๋ง ์ถ๋ ฅ: %c\n", str[1]); // 'h' ์ถ๋ ฅ printf("\n"); printf("=== 3. ๋ฉ๋ชจ๋ฆฌ ์ฃผ์ ํ์ธ ===\n"); printf("๋ฐฐ์ด ์ด๋ฆ(์ฒซ ๋ฒ์งธ ์์ ์ฃผ์): %p\n", str); printf("str[0]์ ์ฃผ์: %p\n", &str[0]); printf("str[1]์ ์ฃผ์: %p\n", &str[1]); printf("str[2]์ ์ฃผ์: %p\n", &str[2]); printf("str[3]์ ์ฃผ์: %p\n", &str[3]); printf("\n"); printf("=== 4. ๊ฐ ๋ฌธ์ ๊ฐ๊ณผ ์ฃผ์ ์ถ๋ ฅ ===\n"); for (int i = 0; str[i] != '\0'; i++) { printf("str[%d] = '%c', ์ฃผ์: %p\n", i, str[i], &str[i]); } printf("\n"); printf("=== 5. ์ฃผ์ ์ฐจ์ด ํ์ธ ===\n"); printf("str[0]๊ณผ str[1]์ ์ฃผ์ ์ฐจ์ด: %ld ๋ฐ์ดํธ\n", (long)(&str[1] - &str[0])); return 0; } ์จ๋ผ์ธ ์ปดํ์ผ๋ฌ ๊ธฐ์ค์ผ๋ก ์๋ ์ถ๋ ฅ๋ฌธ์ด ๋์ต๋๋ค.๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ ํ๊ฒฝ์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ๋์ค๋๊น ๋ฌด์ํ์๊ณ , ๊ฐ๋ง ๋ณด์๋ฉด ๋ฉ๋๋ค.=== 1. %s์ %c์ ์ฐจ์ด === %s๋ก ์ถ๋ ฅ: this is string %c๋ก ์ถ๋ ฅ: ๏ฟฝ === 2. ์ฌ๋ฐ๋ฅธ %c ์ฌ์ฉ๋ฒ === ์ฒซ ๋ฒ์งธ ๋ฌธ์๋ง ์ถ๋ ฅ: t ๋ ๋ฒ์งธ ๋ฌธ์๋ง ์ถ๋ ฅ: h === 3. ๋ฉ๋ชจ๋ฆฌ ์ฃผ์ ํ์ธ === ๋ฐฐ์ด ์ด๋ฆ(์ฒซ ๋ฒ์งธ ์์ ์ฃผ์): 0x7ffdca154b9d str[0]์ ์ฃผ์: 0x7ffdca154b9d str[1]์ ์ฃผ์: 0x7ffdca154b9e str[2]์ ์ฃผ์: 0x7ffdca154b9f str[3]์ ์ฃผ์: 0x7ffdca154ba0 === 4. ๊ฐ ๋ฌธ์ ๊ฐ๊ณผ ์ฃผ์ ์ถ๋ ฅ === str[0] = 't', ์ฃผ์: 0x7ffdca154b9d str[1] = 'h', ์ฃผ์: 0x7ffdca154b9e str[2] = 'i', ์ฃผ์: 0x7ffdca154b9f str[3] = 's', ์ฃผ์: 0x7ffdca154ba0 str[4] = ' ', ์ฃผ์: 0x7ffdca154ba1 str[5] = 'i', ์ฃผ์: 0x7ffdca154ba2 str[6] = 's', ์ฃผ์: 0x7ffdca154ba3 str[7] = ' ', ์ฃผ์: 0x7ffdca154ba4 str[8] = 's', ์ฃผ์: 0x7ffdca154ba5 str[9] = 't', ์ฃผ์: 0x7ffdca154ba6 str[10] = 'r', ์ฃผ์: 0x7ffdca154ba7 str[11] = 'i', ์ฃผ์: 0x7ffdca154ba8 str[12] = 'n', ์ฃผ์: 0x7ffdca154ba9 str[13] = 'g', ์ฃผ์: 0x7ffdca154baa === 5. ์ฃผ์ ์ฐจ์ด ํ์ธ === str[0]๊ณผ str[1]์ ์ฃผ์ ์ฐจ์ด: 1 ๋ฐ์ดํธ
- 0
- 2
- 19
Q&A
28๊ฐ ์ผ์ด์ค6. (6๋ถ๋ ์ง๋ฌธ)
์ง๋ฌธ์ด ์กฐ๊ธ ๋ํดํฉ๋๋ค.class Parent() โ ์ด๋ ๊ฒ ๊ธฐ๋ณธ ์์ฑ์๋ฅผ ํธ์ถํ์ง๋ ์์ต๋๋ค.์ฝ๋๋ก ํํํ๊ธฐ ์ด๋ ค์ฐ์๋ฉด, ์ด๋ ๋ถ๋ถ์ ์ด๋ป๊ฒ ์ฐ๊ณ ์ถ์ ์ง๋ฅผ ๋ง๋ก ํ์ด์ ์ค๋ช ํด์ฃผ์๋ฉด ์ข์ต๋๋ค. ํน์ ๊ธฐ์กด์ super()๋ฅผ super("name")์ผ๋ก ์ด๋ค๊ณ ํด์ํ๋ฉด ๋ ๊น์?๊ทธ๋ฌ๋ฉด ๊ฐ๋ฅํ๊ธด ํฉ๋๋ค. class Parent { private String name; // ๋งค๊ฐ๋ณ์๊ฐ ์๋ ์์ฑ์๋ง ์ ์ public Parent(String name) { this.name = name; System.out.println("ํ ์คํธ"); } } class Child extends Parent { public Child() { // ์ปดํ์ผ ์๋ฌ ๋ฐ์: ๋ถ๋ชจ ํด๋์ค์ ๊ธฐ๋ณธ ์์ฑ์๊ฐ ์๊ธฐ ๋๋ฌธ์ super() ํธ์ถ์ด ์คํจํจ super("name"); // ์๋์ผ๋ก ์ถ๊ฐ๋๋ ๋ถ๋ชจ ํด๋์ค ์์ฑ์ ํธ์ถ ์ฝ๋. ์ฌ๊ธฐ์ ์ค๋ฅ๋ฐ์ } } public class Main { public static void main(String[] args) { Child child = new Child(); // ์ปดํ์ผ ์๋ฌ ๋ฐ์ } }์ถ๋ ฅ๊ฐ: ํ ์คํธ
- 0
- 2
- 23
Q&A
29๊ฐ ์ ์ฒด์ ์ธ ์ง๋ฌธ
์๋ ํ์ธ์, ์ฐ์ 2๊ฐ์ง๋ฅผ ๊ตฌ๋ณํ์ ์ผ ํฉ๋๋ค.ํฐ๋ฐ์ดํ(" ")๋ก ๊ฐ์ผ ๊ฒ: ๋ฌธ์์ด(String) - ๊ทธ๋๋ก ์ถ๋ ฅ๋จ๋ณ์๋ ์: ๊ทธ ๊ฐ์ด ๊ณ์ฐ๋์ด ์ถ๋ ฅ๋จ ์ฒซ ๋ฒ์งธ๋ "" ์ ๋๋ค.Java์์ ํฐ ๋ฐ์ดํ๋ก ๊ฐ์ผ ๊ฒ์ ๋ฌธ์๋ค์ ํฉ์น '๋ฌธ์์ด'์ด๋ผ๊ณ ๋ถ๋ฆ ๋๋ค.๊ทธ๋ฅ ์ฐ๋ฆฌ๊ฐ ํ์์ ์ฐ๋ ํ ์คํธ์ ์๋ฏธ๋ฅผ ๊ฐ์ง ๋ฐ์ดํฐ ํ์ ์ ๋๋ค.System.out.println()์ ํ๋์ ๊ฐ์ ๋ฐ์์ ์ถ๋ ฅํ๋ ํจ์์ ๋๋ค.ํ๋์ ๊ฐ์ด๋ผ๋ ๊ฒ์, ์ ์ฒด์ ๊ฐ์ ํ๋๋ก ๋ง๋ค์ด์ผ ํ๋ค๋ ๋ป์ด์ฃ . Java์์๋ ๋ฌธ์์ด์ด ํ๋๋ผ๋ ํฌํจ๋ ์ํ์์ + (๋ง์ )์ ํ๋ฉด ๋๋จธ์ง๋ ์ฐ๊ฒฐํด๋ฒ๋ฆฝ๋๋ค.์ซ์๋ boolean ๊ฐ์ด๋ ๋ฌธ์์ด์ฒ๋ผ ํฉ์ณ๋ฒ๋ฆฌ์ฃ .System.out.println("๋์ด: " + 25); // ๋์ด: 25 System.out.println("๊ฒฐ๊ณผ: " + true); // ๊ฒฐ๊ณผ: true System.out.println("์ ์: " + 95.5); // ์ ์: 95.5 System.out.println(100 + "์"); // 100์ System.out.println("ํฉ๊ณ: " + 10 + 20); // ํฉ๊ณ: 1020 (์ฃผ์!) System.out.println("ํฉ๊ณ: " + (10 + 20)); // ํฉ๊ณ: 30 (์ฌ๋ฐ๋ฅธ ๋ฐฉ๋ฒ) ๋ ๋ฒ์งธ๋ ์ฐ์ฐ์์ ๋๋ค.==์ด๋ผ๋ ์๋ค๋ฅผ ๋น๊ตํด์ true์ธ์ง false์ธ์ง๋ฅผ ๋ฆฌํดํฉ๋๋ค.System.out.println("์๋ ํ์ธ์"); // ์๋ ํ์ธ์ ์ถ๋ ฅ System.out.println(5 + 3); // 8 ์ถ๋ ฅ System.out.println(d1 == d2); // true ๋๋ false ์ถ๋ ฅ ์์ฝํ์๋ฉด, ์์์ ์ค๋ช ๋๋ฆฐ ๊ฒ์ฒ๋ผ๋ค์ ==์ผ๋ก ๋น๊ตํ๋ ๊ฒ์ true ํน์ false๊ฐ ๋์ค๊ณ ์์ ๋ฌธ์์ด์ด๊ธฐ ๋๋ฌธ์, ์ถ๋ ฅ ๊ทธ ์์ฒด๋ ๋ ๊ฐ์ง๋ฅผ ์ฐ๊ฒฐ๋ ๊ฐ์ด ์ถ๋ ฅ๋๋ ๊ฒ์ ๋๋ค. โ ์ฃผ์ ํ์ค ๊ฒ์, ์ซ์๋ผ๋ฆฌ ๋ํ๋ฉด ์ค์ ๋ง์ ์ด ๋ฉ๋๋ค.โint a = 5; int b = 3; System.out.println(a + b); // 8 (๋ง์ ) double x = 3.5; double y = 2.1; System.out.println(x + y); // 5.6 (๋ง์ ) // ๋ค๋ฅธ ์ซ์ ํ์ ๋ผ๋ฆฌ๋ ๊ฐ๋ฅ int num1 = 10; double num2 = 5.5; System.out.println(num1 + num2); // 15.5 (int๊ฐ double๋ก ์๋ ๋ณํ) ๋ง๋ถ์ฌ์, ๋ ธ๋ฒ ์ด์ค ํ์ํฉ๋๋ค. ๋ง์ ๋ ธ๋ฒ ์ด์ค ๋ถ๋ค๋ ํฉ๊ฒฉํ์ จ์ต๋๋ค.
- 0
- 2
- 21
Q&A
33๊ฐ 10๋ถ ์ง๋ฌธ
์ง๋ฌธ์ super()๊ฐ ์๋๋ผ super(model, year)๋ฅผ ๋ปํ๋ ๊ฒ์ด์ฃ ? super()๋ ๋ถ๋ชจ์ ๊ธฐ๋ณธ ์์ฑ์๋ฅผ ๋ปํฉ๋๋ค. Q. new ElectricCar("Tesla",2021,75);๋ผ๋ ๋ณ์๊ฐ ์๊ธฐ ๋๋ฌธ์ ์์ ๊ธฐ๋ณธ ์์ฑ์์ธ ๋ถ๋ถ์ ๊ฑด๋๋ฐ๊ณ 2๋ฒ์งธ์ธ ElectricCar(String model, int year, int batteryCapacity)๋ก ๋ฐ๋ก ๋์ด๊ฐ๋ ๊ฑด๊ฐ์?๋ค ๋ง์ต๋๋ค. new๋ผ๋ ๊ฒ ์์ฒด๊ฐ ์์ฑ์๋ฅผ ๋ถ๋ฅด๋ผ๋ ๋ป์ ๋๋ค. ์ง๊ธ new ๋ค์ ํ๋ผ๋ฏธํฐ 3๊ฐ์ง๋ฆฌ (ํ๋ผ๋ฏธํฐ๋ ๊ฐ์๋ง ๋ณด๋ ๊ฒ ์๋๋ผ ํ์ ๋ ๋ณด์ ์ผ ํด์)๋ฅผ ๋ถ๋ฅด๊ณ ์์ฃ ? ๊ทธ๋์ 3๊ฐ์ง๋ฆฌ ์์ฑ์๊ฐ ํธ์ถ๋ฉ๋๋ค.Q. ์ดํ์ ๋ถ๋ชจ ๊ธฐ๋ณธ์์ฑ์ ์ถ๋ ฅํ๊ณ ๋จ์ Capacity๋ฅผ ์ถ๋ ฅํ๋ ์์... ์ด๋ ๊ฒ ์ดํดํ๋ฉด ๋๋๊ฑด๊ฐ์?"์ดํ์"๊ฐ ์๋๋๋ค. ๋ถ๋ชจ์ ์์ฑ์๋ ๋ฌด์กฐ๊ฑด ์์๋ณด๋ค ๋จผ์ ์คํ๋์ด์ผ ํฉ๋๋ค. ๊ทธ๋์ ์ง๊ธ ๋ต์ ๋ณด์๋ฉด Car()๋ก ๋์ค์ฃ ? ๋ถ๋ชจ์ ๊ธฐ๋ณธ ์์ฑ์๋ก ๋ถ๋ชจ์ ํ๋๋ฅผ ๋จผ์ ์ด๊ธฐํ๋์ด์ผ ์์์ด ํ์ด๋ ์ ์์ต๋๋ค!
- 0
- 2
- 18
Q&A
์ฝ 9๋ถ์ฏค ์ง๋ฌธ ์์ต๋๋ค.
์๋ ํ์ธ์!super๋ผ๋ ๊ฒ ์์ฒด๊ฐ ๋ถ๋ชจ์ ์์ฑ์๋ฅผ ๋ถ๋ฅด๋ ๊ฒ์ ๋๋ค.๊ธฐ๋ณธ ์์ฑ์๋ผ๋ ๊ฒ์ ํ๋ผ๋ฏธํฐ๊ฐ ์๋ ์์ฑ์๋ฅผ ์ผ์ปซ๋ ๊ฒ์ด์ฃ . ์์ฑ์๋ฅผ ๋ถ๋ฅด๋๋ฐ ํ๋ผ๋ฏธํฐ๊ฐ ๋ค์ด๊ฐ์๋ค๋ฉด? ๋น์ฐํ ๋ถ๋ชจ์ ๊ธฐ๋ณธ ์์ฑ์๊ฐ ์๋ ๋ค๋ฅธ ๋ถ๋ชจ ์์ฑ์๋ฅผ ๋ถ๋ฅด๋ ๊ฒ์ ๋๋ค. super() ๊ทธ ์์ฒด๋ ๋ถ๋ชจ์ ๊ธฐ๋ณธ ์์ฑ์๋ง ๋ถ๋ฅด๋ ๊ฒ์ ๋๋ค.์์์ ๊ธฐ๋ณธ ์์ฑ์๊ฐ ์ถ๋ ฅ๋ ์ง ์๋์ง๋ ์ต์ด์ main ํจ์์์ ์ด๋ป๊ฒ ๋ถ๋ฆฌ๋ ์ง์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋๋ค.๋จ์ํ ์ ์ง๋ฌธ์ผ๋ก๋ ๋ต๋ณ์ด ์ด๋ ต์ต๋๋ค.
- 0
- 2
- 24




