/*=====================================================
■■■ 메소드 중복정의 (Method Overloading) ■■■
=====================================================*/
// 클래스영역 안에 같은 메소드를 여러 개 정의할 수 있을까? 외부에서 Test() {}
// 이름이 같더라도 매개변수가 다르면 구분하도록 하자(매개변수의 타입이나 개수)
// 메소드 오버라이딩과 구분해야 함 오버로딩과 오버라이딩의 차이를 구분해야 한다.
/* ● 메소드 중복정의의 개요
메소드 중복정의 (Method Overloading) 란 메소드가 처리하는 기능은 같고(혹은 매우 유사하고)
메소드 괄호 속에 넘겨주게 되는 인수(인자, 매개변수, 파라미터)의 개수가 다르거나
자료형(Data type)이 다른 경우 메소드의 이름을 동일한 이름으로 사용해도
이들을 서로 구분(식별)할 수 있기 때문에 동일한 이름을 부여하여
메소드를 정의할 수 있도록 문법적으로 허용하게 되는데 이를 『메소드 오버로딩』이라고 한다.*/
/*
System.out.pritnln();
System.out.pritnln('C');
System.out.pritnln(30);
System.out.pritnln(12.3455);
System.out.pritnln("옴뇸뇸");
과연 이게 모두 같은 메소드일까? 아니다!
(이름만 같은) 모두 다른 메소드이다.
System.out.println() 은 같지만 어떤 매개변수를 넣느냐에 따라서 출력결과가 달라진다.
*/
public class Test076
{
public static void main(String[] args)
{
Test076 ob = new Test076();
/* ob.drawLine(); //-==>> ====================
ob.drawLine('+'); //-==>> ++++++++++++++++++++
ob.drawLine('-',20); //-==>> --------------------
*/
ob.drawLine(); //====================
ob.drawLine('>'); //>>>>>>>>>>>>>>>>>>>>
ob.drawLine('*',40); //****************************************
}// end main()
// 선을 그리는 메소드 정의
public void drawLine()
{
System.out.println("===================="); // =가 20개있음
}
//선의 형태를 바꾸어 그리는 메소드
//public void drawLine2(char c) → 메소드의 이름을 drawLine2, drawLine3로 하지 않아도 4
//인수의 타입이나 개수가 다르기 때문에 구분이 된다. 따라서 이름이 같아도 구분이 가능해진다.
public void drawLine(char c)
{
for (int i =0; i<20; i++)
{
System.out.print(c);
}
System.out.println();
}
//public void drawLine3(char c, int n)
public void drawLine(char c, int n)
{
for (int i=0; i<n; i++)
{
System.out.print(c);
}
System.out.println();
}
}
/*==========================================
■■■ 클래스와 인스턴스 ■■■
- 생성자 (Constructor)
===========================================*/
public class Test077
{
int x;
// ※ 생성자의 이름은 항상 예외없이 클래스의 이름과 동일해야 하며 필요할 경우 인수를 받아들이는 것도 가능하고
// 같은 이름의 메소드를 정의하는 중복정의가 가능하지만 리턴 값(반환 값)은 가질 수 없다.
// ※ 생성자는 다른 일반 메소드들처럼 호출될 수 없고, new 연산자를 이용하여 객체를 생성하기 위해 호출되며
// 생성된 객체의 멤버를 초기화시키는 작업을 수행한다.
Test077()
{
int x = 10;
System.out.println("생성자 호출 - 인자가 없는 생성자");
}
Test077(int x)
{
//x = x; // 이건 가능할까? x가 위의 x인지 인자로 받은 인수인지 모르는데?
//문법적으로는 가능하다. 컴파일도 된다.
//앞의 x는 멤버변수 x이고, 뒤 x는 매개변수 int x임 . 둘을 구분하기 위해서 this를 쓴다!!!!!
//여기서 this의 의미, 즉 이곳! 은 이 클래스이다.
this.x = x;
System.out.println("생성자 호출 - 인자가 있는 생성자");
}
//이름이 같은 메소드 Test077
public static void main(String[] args)
{
//Test077 클래스 기반의 인스턴스 생성
Test077 ob1 = new Test077();
Test077 ob2 = new Test077(100);
/*생성자 호출 - 인자가 없는 생성자
생성자 호출 - 인자가 있는 생성자
계속하려면 아무 키나 누르십시오 . . .*/
// ※ 생성자는 new연산자를 이용하여 객체를 생성하기 위해 호출되며
//클래스 객체에 대한 인스턴스가 생성되면 이 객체는 비로소 메모리를 할당 받게 된다.
System.out.println("main 에서 ob1.x : " + ob1.x); //-=>> main 에서 ob1.x : 0
System.out.println("main 에서 ob2.x : " + ob2.x); //-==>> main 에서 ob2.x : 100
/*==========================================
■■■ 클래스와 인스턴스 ■■■
- 생성자 (Constructor)
===========================================*/
public class Test078
{
int val1;
double val2;
Test078()
{
val1=0;
val2=0;
System.out.println("매개변수 없는 생성자 호출!");
}
Test078(int val1)
{
this.val1=val1;
val2=0;
System.out.println("int형 매개변수를 넘겨받는 생성자 호출!!");
}
Test078(double val2)
{
val1=0;
this.val2=val2;
System.out.println("double형 매개변수를 넘겨받는 생성자 호출!!");
}
Test078(int val1, double val2)
{
this.val1=val1;
this.val2=val2;
System.out.println("int 와 double형 매개변수를 넘겨받는 생성자 호출!!");
}
public static void main(String[] args)
{
Test078 ob1 = new Test078();
Test078 ob2 = new Test078(9);
Test078 ob3 = new Test078(9.0);
Test078 ob4 = new Test078(9, 9.0);
System.out.println(ob1.val1 + " , " + ob1.val2);
System.out.println(ob2.val1 + " , " + ob2.val2);
System.out.println(ob3.val1 + " , " + ob3.val2);
System.out.println(ob4.val1 + " , " + ob4.val2);
}
/*
매개변수 없는 생성자 호출!
int형 매개변수를 넘겨받는 생성자 호출!!
double형 매개변수를 넘겨받는 생성자 호출!!
int 와 double형 매개변수를 넘겨받는 생성자 호출!!
0 , 0.0
9 , 0.0
0 , 9.0
9 , 9.0
계속하려면 아무 키나 누르십시오 . . .
*/
}
/*========================================================
■■■ 클래스와 인스턴스 ■■■
- 생성자 (Constructor) 와 초기화 블럭 (Initialized Block)
========================================================*/
public class Test079
{
int n;
int m;
//n=100;
//m=200;
// ↑ 이렇게 하는거 당연히 될 것 같은 데 왜 안되지?
// 그런데 int n=100; 이렇게 선언과 동시에 초기화하는 것은 된다!
// ★ 지금 작업하고 있는 영역은 클래스영역임을 잊지않기로
{
n=100;
m=200;
System.out.println("초기화 블럭 실행...");
}
// 그런데 이건 또 된다,,!
// 이 블레이스가 바로 초기화블럭이다 (Initialized Block)
// 인스턴스 생성만 하고 나서 컴파일 해보면 출력구문이 나온다.
// 컴파일 과정에서 초기화블럭이 실행된다는 의미
Test079()
{
n=0;
m=20;
System.out.println("생성자 실행");
}
void write()
{
System.out.println("n : " + n + " m : " + m);
}
/*초기화 블럭 실행...
생성자 실행
계속하려면 아무 키나 누르십시오 . . .*/
//컴파일 하면 이렇게 된다. 생성자의 위치와 초기와 블럭의 위치를 바꿔도 출력결과는 같다..
//즉, 인스턴스를 생성하면 ★생성자보다 초기화블럭이 먼저 실행된다!!!!!!!! 왜 그럴까?
//초기화블럭이 더 중요해서? 초기화 블럭이 힘들게 초기화시켜놔도 생성자가 설정한 값들로 설정이 되는 것이다.
//생성자가 나중에 실행되는 이유는, 생성자 실행 내용이 더 비중이 크기 때문이다.
Test079(int n, int m)
{
this.n=n;
this.m=m;
System.out.println("인자가 있는 생성자 실행");
}
public static void main(String[] args)
{
Test079 ob = new Test079();
ob.write();
System.out.println("\n"); //두 줄 개행
Test079 ob2 = new Test079(123,234);
ob2.write();
/*
초기화 블럭 실행...
생성자 실행
n : 0 m : 20
초기화 블럭 실행...
인자가 있는 생성자 실행
n : 123 m : 234
계속하려면 아무 키나 누르십시오 . . .
*/
}
}