๋ฉ์๋ ์ค๋ฒ๋ก๋ฉ(Method Overloading)
๋์ผํ ๋ฉ์๋ ์ด๋ฆ์ ๊ฐ์ง ์ฌ๋ฌ ๋ฉ์๋๋ฅผ ์ ์ํ๋ ๊ธฐ๋ฅ์ด๋ค.
๊ฐ ๋ฉ์๋๋ง๋ค ๋งค๊ฐ๋ณ์์ ํ์ , ๊ฐ์ ๋๋ ์์๊ฐ ๋ฌ๋ผ์ผ ํ๋ค.
โ ์ ์จ โ
- ์ฝ๋์ ๊ฐ๋ ์ฑ โฌ
- ๋ฉ์๋ ์ด๋ฆ์ ๊ธฐ์ตํ๊ณ ํธ์ถํ๊ธฐ ์ฉ์ดํด์ง
int add(int a, int b) {
return a + b;
}
String add(String a, String b) {
return a + b;
}
float add(float a, float b) {
return a + b;
}
add(1,4);
add("aaa", "bbb");
add(2.3f, 5.6f);
๊ฐ๋จํ๊ฒ ์ด๋ ๊ฒ ๋ง๋ค ์ ์๋ค.
๋ง์ฝ ๋ฉ์๋ ์ค๋ฒ๋ก๋ฉ์ด ์์๋ค๋ฉด, ๋ฐ๊ณผ ๊ฐ์ด ๋ง๋ค์ด์ค์ผ ํ์ ๊ฒ์ด๋ค.
int add_int(int a, int b){
return a + b;
}
String add_String(String a, String b){
return a + b;
}
float add_float(float a, float b){
return a+b;
}
add_int(1, 4);
add_String("aaa", "bbb");
add_float(2.3f, 5.6f);
๋์ค์ ํจ์ ํธ์ถํ๊ธฐ ์ ๊ท์ฐฎ์์ง..
package prj;
class Member{
String name;
String tel;
String addr;
Member(String n, String t, String a) {
name = n;
tel = t;
addr = a;
}
Member() {
name = "hyunsik";
tel = "010-1111-2222";
addr = "๋ฏธ๊ตญ";
}
void print() {
System.out.println("name : " + name);
System.out.println("tel : " + tel);
System.out.println("addr : " + addr);
}
}
public class ConstructorTest{
public static void main(String args[]) {
Member m = new Member("minhyun", "010-0000-1111", "๋ํ๋ฏผ๊ตญ");
m.name = "seongjae";
m.tel = "010-7777-8888";
m.addr = "์บ๋๋ค";
m.print();
// name : seongjae
// tel : 010-7777-8888
// addr : ์บ๋๋ค
Member m2 = new Member();
m.print();
// name : hyunsik
// tel : 010-1111-2222
// addr : ๋ฏธ๊ตญ
}
}
์ด๋ฐ ์์ผ๋ก ์ฌ์ฉํ ์ ์๋ค.
this
ํ์ฌ ๊ฐ์ฒด์ ์ฐธ์กฐ๊ฐ์ ๊ฐ๋ ์ฐธ์กฐ ๋ณ์.
ํ์ฌ ํด๋์ค์ ์ธ์คํด์ค๋ฅผ ์๋ฏธํ๋ค.
this๋ ์ฃผ๋ก ์์ฑ์์ ๋ฉ์๋์ ๋งค๊ฐ๋ณ์ ์ด๋ฆ์ด ํ๋์ ๋น์ทํ๊ฑฐ๋ ๊ฐ์ ๊ฒฝ์ฐ,
ํท๊ฐ๋ฆฌ์ง ์๋๋ก ์ธ์คํด์ค ๋ฉค๋ฒ์ธ ํ๋์์ ๋ช ์ํ๊ณ ์ ํ ๋ ์ฌ์ฉ๋๋ค.
๋ฉค๋ฒ ๋ณ์์ ์ง์ญ ๋ณ์ ์ด๋ฆ์ด ๊ฐ์ ๋ ๋ฉค๋ฒ ๋ณ์๋ฅผ ๊ตฌ๋ถํ๊ธฐ ์ํด์ ์ฌ์ฉํ๋ค.
class Member {
private String name;
private String tel;
public Member(String name, String tel) {
this.name = name;
this.tel = tel;
}
}
์ญํ
1๏ธโฃ ์๊ธฐ ์์ ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ๋ฆฌํจ๋ค.
2๏ธโฃ ์์ฑ์์์ ๋ค๋ฅธ ์์ฑ์๋ฅผ ํธ์ถํ ๊ฒฝ์ฐ ์ฌ์ฉํ๋ค.
3๏ธโฃ ์ธ์คํด์ค ์์ ์ ์ฃผ์๋ฅผ ๋ฐํํ ๋ ์ฌ์ฉํ๋ค.
https://choicode.tistory.com/24
์ ๊ทผ ์ ์ด์
ํด๋์ค, ๋ฉ์๋, ๋ฉค๋ฒ ๋ณ์๋ค์ ์ด๋๊น์ง ์ ๊ทผํ ์ ์๋๋ก ํ์ฉํ ๊ฒ์ธ์ง ๊ฒฐ์
ํด๋์ค : default
๋ฉ์๋, ๋ฉค๋ฒ ๋ณ์ : private, default, public, protected
โ ์ ์จ โ
1๏ธโฃ ๋ฐ์ดํฐ์ ๋ณดํธ
์ธ๋ถ์์ ๋ฌด๋ถ๋ณํ ์ ๊ทผ์ ๋ง์ ์ ์๋ค.
์ด๋ ๊ฒ ํ๋ฉด ํด๋์ค์ ๋ด๋ถ ๊ตฌํ์ ์จ๊ธฐ๊ณ , ์ธ๋ถ์์ ๋ถํ์ํ ๊ฐ์ ์ ๋ฐฉ์งํ ์ ์๋ค.
2๏ธโฃ ๋ฌด๊ฒฐ์ฑ ์ ์ง
(๋ฌด๊ฒฐ์ฑ : ๋ฐ์ดํฐ์ ์ ํ์ฑ๊ณผ ์ผ๊ด์ฑ์ ์ ์งํ๊ณ ๋ณด์ฆํ๋ ๊ฒ์ ์๋ฏธํ๋ค.)
๋ฐ์ดํฐ์ ๋ํ ์๋ชป๋ ๋ณ๊ฒฝ์ ๋ฐฉ์งํ ์ ์๋ค.
์๋ฅผ ๋ค์ด, ์์๊ฐ์ ํ์ฉํ์ง ์๋ ๋ฐ์ดํฐ์ ๋ํ ์ ๊ทผ์ ์ ํํ๋ฉด ๋ฐ์ดํฐ์ ๋ฌด๊ฒฐ์ฑ์ ๋ณด์ฅํ ์ ์๋ค.
(์ : ์ ์ฅ, ์๋์ฐจ์ ์๋ ฅ, ๋์ด ๋ฑ๋ฑ)
3๏ธโฃ ์บก์ํ
๋ฐ์ดํฐ์ ๊ทธ ๋ฐ์ดํฐ๋ฅผ ์กฐ์ํ๋ ๋ฉ์๋๊ฐ ํจ๊ป ๋ฌถ์ฌ์์ด ๋ฐ์ดํฐ์ ์ผ๊ด์ฑ์ ์ ์งํ๊ธฐ ์ฝ๋ค.
4๏ธโฃ ํ๋ก๊ทธ๋จ ์ ์ง ๋ฐ ํ์ฅ
ํด๋์ค ๋ด๋ถ์ ๋ณ๊ฒฝ์ ์ํฅ์ ์ฃผ์ง ์์ผ๋ฉด์ ํด๋์ค ์ธ๋ถ ์ธํฐํ์ด์ค๋ฅผ ๋ณ๊ฒฝํ ์ ์๋ค.
class PrivateTest{
private int a; // ์๋์ฑ ์ ๊ณต -> ํด๋์ค ์์์๋ง ๋ณด์ธ๋ค
int b; // default -> ํ์ฌ ํจํค์ง ๋ด์์๋ง
public int c; // -> ๋ค๋ฅธ ํจํค์ง์์๋ ๋ณด์ธ๋ค. ๋จ ๋ค๋ฅธ ํจํค์ง๋ ์์๊ด๊ณ์ ํด๋์ค์์๋ง ๋ณด์
}
getter & setter
๊ฐ์ฒด ์งํฅ ํ๋ก๊ทธ๋๋ฐ์์๋ ๋ฉ์๋๋ฅผ ํตํด ๋ฐ์ดํฐ๋ฅผ ๋ณ๊ฒฝํ๋ ๋ฐฉ๋ฒ์ ์ ํธํ๋ค.
setter
์ฃผ๋ก ๊ฐ์ฒด์ private ๋ฉค๋ฒ ๋ณ์์ ๊ฐ์ ํ ๋นํ๋ ๋ฐ ์ฌ์ฉ๋๋ค.
์ธ๋ถ์์ ์ง์ private ๋ฉค๋ฒ ๋ณ์์ ์ ๊ทผํ์ง ๋ชปํ๋๋ก ํ๋ฉฐ, ์ด๋ฅผ ํตํด ๋ฐ์ดํฐ ์บก์ํ๋ฅผ ๊ฐํํ๋ค.
setter ๋ฉ์๋ ๋ด์์ ์ ๋ ฅ ๊ฐ์ ์ ํจ์ฑ ๊ฒ์ฌ์ ๋ฐ์ดํฐ ๋ฌด๊ฒฐ์ฑ์ ๋ณด์ฅํ๋ ๋ก์ง์ ์ถ๊ฐํ ์ ์๋ค.
public void setAge(int age) {
if (age>=0) {
this.age = age;
} else {
throw new IllegalArgumentException("Age cannot be negative.");
}
}
getter
์ฃผ๋ก ๊ฐ์ฒด์ private ๋ฉค๋ฒ ๋ณ์ ๊ฐ์ ๋ฐํํ๋ ๋ฐ ์ฌ์ฉ๋๋ค.
๊ฐ์ฒด ์ธ๋ถ์์ private ๋ฉค๋ฒ ๋ณ์์ ์ง์ ์ ๊ทผํ์ง ์๊ณ , ๊ฐ์ ์ฝ์ด์ค๋ ์ญํ ์ ํ๋ค.
getter ๋ฉ์๋๋ฅผ ํตํด ๊ฐ์ ์ฝ์ด์ฌ ๋, ํ์ํ ๊ฒฝ์ฐ ๊ฐ์ ๊ฐ๊ณตํ๊ฑฐ๋ ๊ณ์ฐํ์ฌ ๋ฐํํ ์ ์๋ค.
public int getAge() {
return age;
}
๋คํ์ฑ
๋ค์ํ ํํ๋ฅผ ์๋ฏธํ๋ฉฐ,
ํ๋์ ์ฝ๋ ๋๋ ๊ฐ์ฒด๊ฐ ๋ค์ํ ์ํฉ์์ ๋ค์ํ ํํ๋ก ๋์ํ ์ ์๋ ๋ฅ๋ ฅ์ ๋ํ๋ธ๋ค.
๋คํ์ฑ์ ์ค๋ฒ๋ก๋ฉ(overloading), ์ค๋ฒ๋ผ์ด๋ฉ(overriding), ์ ์บ์คํ (upcasting), ๋ค์ด์บ์คํ (downcasting) ๋ฑ์ ํตํด ๊ตฌํ๋๋ค.
์ค๋ฒ๋ก๋ฉ : ๊ฐ์ ๋ฉ์๋ ์ด๋ฆ์ ์ธ ์ ์์ (๋จ, ๋ณ์ ํ์ ์ด๋ ๊ฐ์, ์์๊ฐ ๋ฌ๋ผ์ผ ํจ)
์ค๋ฒ๋ผ์ด๋ฉ : ๋ถ๋ชจ ํด๋์ค์ ๋ฉ์๋๋ฅผ ํ์ ํด๋์ค์์ ์ฌ์ ์ํ์ฌ ๋ค์ํ ๋์์ ์ํํ๋ ๊ฒ
์ ์บ์คํ : ํ์ ํด๋์ค์ ๊ฐ์ฒด๋ฅผ ์์ ํด๋์ค์ ๊ฐ์ฒด๋ก ๋ณํ
(๋คํ์ฑ์ ์คํํ๊ธฐ ์ํด)
๋ค์ด์บ์คํ : ์์ ํด๋์ค์ ๊ฐ์ฒด๋ฅผ ํ์ ํด๋์ค์ ๊ฐ์ฒด๋ก ๋ณํ
(์ ์บ์คํ ๋ ๊ฐ์ฒด๋ฅผ ์๋ ํํ๋ก ๋ณต์ํ๊ธฐ ์ํด)
class Animal {
void makeSound() {
System.out.println("๋๋ฌผ์ด ์๋ฆฌ๋ฅผ ๋ด๊ณ ์์ต๋๋ค.");
}
}
class Dog extends Animal {
@Override
void makeSound() {
System.out.println("๊ฐ๊ฐ ์ง๊ณ ์์ต๋๋ค.");
}
}
class Cat extends Animal {
@Override
void makeSound() {
System.out.println("๊ณ ์์ด๊ฐ ์ธ๊ณ ์์ต๋๋ค.");
}
}
public class PolymotphismExample {
public static void main(String[] args) {
Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal1.makeSound(); // ๊ฐ๊ฐ ์ง๊ณ ์์ต๋๋ค.
animal2.makeSound(); // ๊ณ ์์ด๊ฐ ์ธ๊ณ ์์ต๋๋ค.
}
}
์์ธ์ฒ๋ฆฌ
ํ๋ก๊ทธ๋จ์ด ๋ฐํ์์ ์ค๋จ๋๋ ๊ฒ์ ์๋ฐฉํ๊ธฐ ์ํ ์ฝ๋
ํ๋ก๊ทธ๋จ์ ๋๊น์ง ๋์๊ฐ ์ ์๊ฒ ๋ง๋ค๊ธฐ ์ํด์,
ํ๋ก๊ทธ๋จ ์ข ๋ฃ๋ฅผ ํ๊ธฐ ์ํด์,
ํ๋ก๊ทธ๋จ์ ๊ฐ์์ค๋ฐ ๋น์ ์ ์ข ๋ฃ๋ฅผ ๋ง๊ธฐ ์ํด์ ์์ธ์ฒ๋ฆฌ๋ฅผ ํ๋ ๊ฒ์ด๋ค.
try-catch ๋ธ๋ก์ ์ด์ฉํด์ ์์ธ๊ฐ์ฒด๋ฅผ ์ก์ ์์ธ๋ฅผ ์ฒ๋ฆฌํ ์ ์๋๋ก ํ๋ ๋ฐฉ๋ฒ์ด ์์ธ์ฒ๋ฆฌ์ด๋ค.
Exception e
try {
// ์์ธ ๋ฐ์์ด ์์๋๋ or ๊ฐ์ ๋ก ์์ธ์ฒ๋ฆฌ๋ฅผ ์๊ตฌํ๋ ์ฝ๋
} catch(์์ธ๊ฐ์ฒด1) {
// ์์ธ์ฒ๋ฆฌ์ฝ๋
} catch(์์ธ๊ฐ์ฒด2) {
// ์์ธ์ฒ๋ฆฌ์ฝ๋
} catch(Exception e) {
// ์์ธ์ฒ๋ฆฌ์ฝ๋
}
Exception e๋ ๋ชจ๋ ์์ธ ์ฒ๋ฆฌ๋ฅผ ๋ฐ๋๋ค.
์์๋๋ก try catch๋ฅผ ํ๊ธฐ ๋๋ฌธ์ ๋ง์ง๋ง์ ๋ฌ์ผ ํ๋ค.
finally ๋ธ๋ญ
try {
// ์์ธ ๋ฐ์์ด ์์๋๋ or ๊ฐ์ ๋ก ์์ธ์ฒ๋ฆฌ๋ฅผ ์๊ตฌํ๋ ์ฝ๋
} catch(์์ธ๊ฐ์ฒด1) {
// ์์ธ์ฒ๋ฆฌ์ฝ๋
} catch(์์ธ๊ฐ์ฒด2) {
// ์์ธ์ฒ๋ฆฌ์ฝ๋
} catch(Exception e) {
// ์์ธ์ฒ๋ฆฌ์ฝ๋
} finally {
// ์คํํ ์ฝ๋
}
์ ์ ์คํ, ์์ธ ์ฒ๋ฆฌ๊ฐ ๋๋ ์ ๋๋ ๊ฐ์ ์๊ด์์ด ์ ์ด๋ ์ผ์ด์ค์๋ ๋ฌด์กฐ๊ฑด ์คํ๋๋ ๋ธ๋ญ์ด๋ค.
โ ์ธ์ ์จ โ
์ฌ์ฉํ์๋ ์์์ ํด์ ํ ๋ ์ฌ์ฉํ๋ค.
ํ์ผ์ ์ด์๋ค๊ฐ ๋ซ์ง ๋ชปํ๊ณ ์ค๋จ๋๋ค๋์ง, ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์ด๊ณ ๋ชป ๋ซ์๋ค๋์ง, ๊ทธ๋ด ๋ ํด์ ํด์ผ ์์ ์ฑ์ด ๋์์ง๋ค.
(์ฌ์ฉํ์๋ ์์์ ํด์ ํ๊ธฐ ์ํด์ ๋ฃ์ด์ค๋ค.)
'๐น๐๐๐' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํผ์ ๋์ ์ฌ๋ณด๋... ์๋ฐ ๊ณต๋ถ (3) (0) | 2023.10.15 |
---|---|
jstl.jar ๋ค์ด๋ฐ๊ธฐ (1) | 2023.10.14 |
ํผ์ ๋์ ์ฌ๋ณด๋... ์๋ฐ ๊ณต๋ถ (1) (1) | 2023.10.05 |
[Java] String reverse ์๋ฐ ๋ฌธ์์ด ๋ค์ง๊ธฐ - StringBuffer reverse() (0) | 2023.09.19 |
[Java] 2์ฐจ์ ๋ฐฐ์ด์ ์ด ํฌ๊ธฐ๋ฅผ ๋ค๋ฅด๊ฒ ์ง์ ํ๊ธฐ / ๋ฌธ์์ด ๋ง์ง๋ง์ ๋ํ๋ด๋ ๋ฌธ์ null (\n) (0) | 2023.09.14 |