어려울 거 같아서 미뤄뒀던 프로그래밍 공부 이번에 숨 딱 참고 Java 다이브 💦
오버로드로 메서드의 다양성을 지켜줄 수 있어요.
메서드간의 파라미터가 서로 달라야해요.
- 파라미터의 데이터 타입이 다른경우. (데이터 형이 동일하고 변수의 이름이 다른 경우는 동일한 파라미터로 인식돼요.)
- 파라미터의 개수가 다른 경우.
- 파라미터들의 전달 순서가 다른 경우
리턴형이 다른 경우는 오버로드의 성립에 아무런 영향을 주지 않아요.
class Hello{
Hello(){
System.out.println("Hello");
}
Hello(String msg){ // 생성자의 Overload
System.out.println(msg);
}
}
public class Main01 {
public static void main(String[] args) {
// 기본 생성자 출력
Hello h1 = new Hello();
// Overload된 생성자 출력
Hello h2 = new Hello("안녕하세요");
}
}
/*
출력결과)
Hello
안녕하세요.
*/
public class Article {
private int seq;
private String subject;
private String writer;
public Article(int seq, String subject, String writer) {
super();
this.seq = seq;
this.subject = subject;
this.writer = writer;
}
public Article(int seq) {
//this.seq = seq;
//this.subject = "제목없음";
//this.writer = "익명";
this(seq, "제목없음", "익명");
}
public Article(int seq, String subject) {
//this.seq = seq;
//this.subject = subject;
//this.writer = "익명";
this(seq, subject, "익명");
}
@Override
public String toString() {
return "Article [seq=" + seq + ", subject=" + subject
+ ", writer=" + writer + "]";
}
}
Parent parent = new Child();
class Unit{ .. }
class Army extends Unit{ .. }
public class Main{
public static void main(String[] args){
Unit u = new Army();
}
}
서로 다른 클래스 유형으로부터 나온 객체 참조변수들 간의 대입에는 일정한 규칙이 있어요.
- 왼쪽 항(부모 클래스)과 오른쪽 항(자식 클래스)의 객체 유형이 서로 다른 경우, 두 유형이 서로 상속 관계에 있고 왼쪽 객체(부모 클래스)가 오른쪽 객체(자식 클래스)의 상위 클래스인 경우에만 암묵적 형변환이 일어나요.
- 하위 클래스에서 상위클래스 유형으로 할당하는 것은 가능하나 그 반대의 경우에는 명시적 형변환을 해야해요. 그러나 상위 클래스 유형을 하위 클래스 유형으로 강제 형변환하는 경우에는 할당되는 객체의 유형에 따라서 실행 오류가 발생할 수 있어요.
A a1 = new B(); // 암묵적 형변환 가능
A a2 = new X(); // 암묵적 형변환 가능
A a3 = new C(); // 암묵적 형변환 가능
A a4 = new Y(); // 암묵적 형변환 가능
---------------
B b1 = new C(); // 암묵적 형변환 가능
X x1 = new Y(); // 암묵적 형변환 가능
---------------
C c = new C();
B b2 = c; // 암묵적 형변환 가능
---------------
Y y = new Y();
X x2 = y; // 암묵적 형변환 가능
---------------
class Unit{
public void attack(){ .. }
}
class Army extends Unit{
public void tank(){ .. }
}
class Navy extends Unit{
public void nucleus(){ .. }
}
class AirForce extends Unit{
public void bombing(){ .. }
}
public class Main{
public static void main(String[] args){
Unit u1 = new Army();
Unit u2 = new Navy();
Unit u3 = new AirForce();
// 오버라이드 된 메서드 사용 가능
u1.attack();
u2.attack();
u3.attack();
// 추가적으로 구현한 메서드 사용 불가능
//u1.tank();
//u2.nucleus();
//u3.bumbing();
}
}
ChildCalss child = (ChildClass)parent;
ChildClass child1 = new ChildClass();
PartentClass parent= child; //암묵적 형변환
ChildClass child2 = (ChildClass)parent; //명시적 형변환
(1)
Army arm1 = new Army();
Unit u = army1;
Army army2 = (Army)u;
(2)
Unit u = new Navy();
Navy navy = (Navy)u;
(1) : 최초 객체 생성이 부모 형태로 만들어진 경우에 불가능해요.
Unit u = new Unit();
Army army = (Army)u;
(2) : 최초 생성된 것과 다른 형식으로 변환하는 것은 불가능해요.
Army army= new Army();
Unit u = army;
Navy navy = (Navy)u;
위의 두 경우 모두 문법적인 오류는 없기 때문에, 이클립스에서는 에러를 검출하지 못해요. 하지만 프로그램을 실행시켰을 경우에는 에러가 발생해요.
class Unit{
public void attack(){ .. }
}
class Army extends Unit{
public void tank(){ .. }
}
class Navy extends Unit{
public void nucleus(){ .. }
}
class AirForce extends Unit{
public void bombing(){ .. }
}
public class Main{
public static void main(String[] args) {
// 자식 클래스로 객체 생성
AirForce af = new AirForce("공군");
Navy nv = new Navy("해군");
Army am = new Army("육군");
// 각각의 객체는 자신들의 고유 기능을 사용할 수 있다.
af.bombing();
nv.nucleus();
am.tank();
System.out.println("--------------------");
// 암묵적 형변환
Unit temp1 = af;
Unit temp2 = nv;
Unit temp3 = am;
// 형변환이 되더라도 상속받거나 재정의한(Override)
// 자신들의 기본 특성은 그대로 유지함
temp1.attack();
temp2.attack();
temp3.attack();
// 상위 클래스 형태로 형변환이 되면, 자신들의 독립 기능은 사용하지 못함
//temp1.bombing();
//temp2.nucleus();
//temp3.tank();
System.out.println("--------------------");
// 다시 원래의 기능을 되돌리기 위해서는 하위 클래스 형태로 명시적 형변환이 필요
AirForce re1 = (AirForce)temp1;
Navy re2 = (Navy)temp2;
Army re3 = (Army)temp3;
re1.bombing();
re2.nucleus();
re3.tank();
}
}
다음 다이브에서 또 만나요 🌊
출처
https://media.giphy.com/media/l2Je1bFuOpkNpyqYM/giphy.gif
https://media.giphy.com/media/Jbb3KS22397YQ/giphy.gif