Java1 day06

[6일차 수업 내용]

1. 오버로딩(Overloading)

2. 생성자(constructor)

3. 변수의 초기화

====================================================================1. 오버로딩( Overloading )

       1-1 ) 오버로딩이란?

             - 한 클래스 내에 같은 이름의 메소드를 여러 개 정의하는 것을

               '메소드 오버로딩( method overloading )' 또는 간단히 오버로딩(overloading)이라고 함

             - 하나의 메소드 이름으로 여러 기능을 구현하기 위해 사용

 

       1-2 ) 오버로딩의 장점

             - 하나의 이름을 사용하고 기억하면 되므로

               '이 메소드는 이름이 같으니 같은 기능을 하겠구나' 라고 예측이 가능

             - 메소드 이름을 절약할 수 있음

             ==> 작명고민을 덜 할 수 있는 동시에 사용되었어야 할 메소드 이름을

                   다른 메소드의 이름으로 사용할 수 있음

 

       1-3 ) 오버로딩의 조건

             ① 메소드의 이름이 같아야 함 ex ) println

             ② 매개변수의 개수 또는 타입이 달라야 함

                   - 메소드의 이름이 같더라도 매개변수가 다르면 서로 구별될 수 있기 때문

                   ==> 오버로딩이 가능

                   - 반환타입은 오버로딩을 구현하는데 아무런 영향도 주지 못함

 

====================================================================

 

package example01;

public class OverloadingEx {
       public static void main(String[] args) {
             MyMath mm = new MyMath();
             System.out.println(mm.add(3, 3));
             System.out.println(mm.add(3, 3L));
             System.out.println(mm.add(3L, 3));
             System.out.println(mm.add(3L, 3L));

             int[] arr = {10, 20, 30};
             System.out.println(mm.add(arr));
       }
}

 

class MyMath{
       int add(int a, int b) {        // 10, 10
       System.out.print("int add(int a, int b) - ");
       return a + b;
       }

       long add(int a, long b) {        // 10, 10L
              System.out.print("long add(int a, long b) - ");
             return a + b;        // 산술변환 int + long ==> long + long ==> long
       }

       long add(long a, int b) {        // 10L, 10
             System.out.print("long add(long a, int b) - ");
             return a + b;
       }

       long add(long a, long b) {
             System.out.print("long add(long a, long b) - ");
             return a + b;
       }

       int add(int[] ar) {
             System.out.print("int add(int[] ar) - ");
             int sum = 0;
             for(int i : ar) {
                   sum += i;
             }
             return sum;
       }

}

 

====================================================================

2. 생성자( Constructor )

       2-1 ) 생성자란?

             - 생성자는 인스턴스가 생성될 때 호출되는 '인스턴스 초기화 메소드'

             - 즉, 인스턴스 변수의 초기화 작업이 주로 사용되며, 

               인스턴스 생성 시에 실행되어야 할 작업을 위해서도 사용

             - 생성자의 조건은 다음과 같음

                   ① 생성자의 이름은 클래스의 이름과 같음

                   ② 생성자는 리턴값이 없다.

 

             Data d = new Data();

             - new 연산자가 인스턴스를 생성, Data();과 같은 생성자가 생성하는 것이 아님

                   ① 연산자 new에 의해서 메모리(Heap)에 Data 클래스의 인스턴스가 생성

                   ② 생성 후 생성자 Data()가 호출되어 수행

                   ③ 연산자 new의 결과로 생성된 Data인스턴스의 주소가 반환되어 참조변수 d에 저장

 

       2-2 ) 기본 생성자( default constructor )

             - 지금까지는 생성자를 모르고도 프로그래밍을 해왔지만

               사실 모든 클래스에는 반드시 하나 이상의 생성자가 정의되어 있어야 함

             - 지금까지 클래스에 생성자를 정의하지 않고도 인스턴스를 생성할 수 있었던 이유는

               컴파일러가 제공하는 기본생성자 덕분이었다. ==> 클래스이름(){ }Data(){ }

             - 기본생성자가 컴파일러에 의해서 자동으로 추가되는 경우는

               클래스에 정의된 생성자가 하나도 없을 때 뿐

 

       2-3 ) 매개변수가 있는 생성자

             - 생성자도 메소드처럼 매개변수를 선언하여 호출 시 값을 넘겨받아

               인스턴스의 초기화 작업에 사용할 수 있음

             - 인스턴스마다 각기 다른 값으로 초기화되어야 하는 경우가 많은데

               매개변수를 사용한 초기화는 매우 유용

 

       2-4 ) 생성자에서 다른 생성자 호출하기 - this(), this <- 둘은 다른 것

             - 같은 클래스에서 멤버들 간에 서로 호출이 가능한 것처럼

               생성자 간에도 서로 호출이 가능

             - 단, 다음 두 조건을 만족시켜야 함

                   ① 생성자의 이름으로 클래스이름 대신 this()를 사용

                   ② 한 생성자에서 다른 생성자를 호출할 때는 반드시 첫줄에서만 호출이 가능

             - this()는 생성자를 의미, this는 참조변수로써 인스턴스 자기 자신을 가리킴

====================================================================
package example01;

public class CarEx01 {
       public static void main(String[] args) {
             Car car = new Car();              // 만들 때마다 public Car() 계속 호출
             car.color = "white";
             car.gearType = "auto";
             car.door = 4;

             Car myCar = new Car("black", "auto", 2); // 생성과 동시에 초기화
             Car myCar2 = new Car("while", "auto", 2); // 생성과 동시에 초기화
             Car myCar3 = new Car("gray", "auto", 4); // 생성과 동시에 초기화

             System.out.println("car.color : " + car.color);
             System.out.println("myCar.color : " + myCar.color);
             System.out.println("myCar2.color : " + myCar2.color);
             System.out.println("myCar3.color : " + myCar3.color);
       }
}

class Car{
       String color;
       String gearType;
       int door;

// Car() {
       // System.out.println("Car클래스 생성자 호출");        // 없애면 안되고 나둬야 함
// } // 생성자가 정의되어 있지 않으면 자바에서 Car(){} 자동적으로 추가해줌

Car() {}        // 이렇게라도 남겨두어야 함        <- Car car = new Car()의 생성자

/* 
Car(String c, String g, int d){ 
       color = c; 
       gearType = g;
       door = d;

}
*/ // 위의 것보다는 아래 꺼를 더 쓴다.
Car(String color, String gearType, int door){
       this.color = color;
       this.gearType = gearType;
       this.door = door;
       }        // 만들어 놓아서 기본생성자를 자동으로 생성하지 않는다.
}
-----------------------------------------------

package example01;

public class CarEx02 {
       public static void main(String[] args) {
             Car2 c1 = new Car2();
             System.out.println("c1.color : " + c1.color);        // white

             Car2 c2 = new Car2();
             System.out.println("c2.gearType : " + c2.gearType);        // auto

             Car2 c3 = new Car2("green");
             System.out.println("c3.door : " + c3.door);         // 4

             Car2 c4 = new Car2("black", "auto", 2);
             System.out.println("c4.color : " + c3.color);        // black

             Car2 c5 = new Car2(c4);
             System.out.println("c5.door : " + c5.door);
       }
}

class Car2{
       String color;
       String gearType;
       int door;

       Car2(Car2 c){        // 주소 참조, 참조형 매개변수 복사법 'call by reference'
              this.color = c.color;
             this.gearType = c.gearType;
              this.door = c.door;
       }

       Car2() {
             this("white", "auto", 4);
       }

       Car2(String color, String gearType, int door){        // 값 호출 'call by value'
              this.color = color;
              this.gearType = gearType;
             this.door = door;
       }

       Car2(String color){
             this(color, "auto", 4);
       }
}

====================================================================
3. 변수의 초기화
       3-1 ) 변수의 초기화
             - 변수를 선언하고 처음으로 값을 저장하는 것을 '변수의 초기화'라고 함
             - 멤버변수는 초기화하지 않아도 자동적으로
               변수의 자료형에 맞는 기본값으로 초기화가 이루어 지지만
               지역변수는 사용하기 전에 반드시 초기화해야 함
             - 멤버변수의 초기화 방법은 아래와 같음
             ① 명시적 초기화( explicit initialization )
             ② 생성자 ( constructor)
             ③ 초기화블록( initialization block )
             - 인스턴스 초기화 블록 : 인스턴스 변수를 초기화 하는데 사용
             - 클래스 초기화 블록 : 클래스 변수를 초기화 하는데 사용

       3-2 ) 명시적 초기화
             - 변수를 선언과 동시에 초기화 하는 것을 명시적 초기화라고 함
             - 가장 기본적이면서도 간단한 초기화 방법이므로 여러 초기화 방법 중에서
               가장 우선적으로 고려되어야 함

       3-3 ) 초기화 블록
             - 초기화 블록에는 '클래스 초기화 블록'과 '인스턴스 초기화 블록' 두 가지 종류
             - 클래스 초기화 블록은 클래스 변수(static)의 초기화에 사용되고,
              인스턴스 초기화 블록은 인스턴스 변수의 초기화에 사용됨
             - 초기화 블록 작성 시 인스턴스 초기화 블록은 단순히 클래스 내에 블록{}을 만들고
              그 안에 코드를 작성
             - 클래스 초기화 블록은 인스턴스 초기화 블록 앞에 단순히 static을 덧붙이기
             - 클래스 초기화 블록은 클래스가 메모리에 로딩될 때 단 한번만 수행되지만, 
              인스턴스 초기화 블록은 인스턴스가 생성될 때마다 수행되며 
              생성자보다 인스턴스 초기화 블록이 먼저 실행

     3-4 ) 멤버변수의 초기화 시점과 순서

             클래스변수의 초기화 시점 클래스가 처음 로딩될 때 단 한번만 초기화
             인스턴스변수의 초기화 시점  인스턴스가 생성될 때마다 각 인스턴스별로 초기화가 이루어짐

             클래스변수의 초기화 순서 기본값 -> 명시적 초기화 -> 클래스초기화 블록 
             인스턴스변수의 초기화 순서 기본값 -> 명시적 초기화 -> 인스턴스초기화 블록 -> 생성자

====================================================================

package example01;

public class BlockTest {
     static int[] arr = new int[10];      // 클래스 변수

 

     // 생성자
     public BlockTest() {
         System.out.println("생성자입니다.");
     }

     // 인스턴스 초기화 블록
     {
     System.out.println("인스턴스초기화 블록입니다.");
     }

 

     // 클래스 초기화 블록
     static {
         System.out.println("클래스초기화 블록입니다.");      // 실행됨과 동시에 바로 초기화
         for(int i = 0; i < arr.length; i++) {
             arr[i] = (int)(Math.random() * 10) + 1;
         }
     }

 

     public static void main(String[] args) {
         System.out.println("[첫번째 인스턴스 생성]");
         BlockTest bt = new BlockTest();
         System.out.println("[두번째 인스턴스 생성]");
         BlockTest bt2 = new BlockTest();

 

         for(int i = 0; i < arr.length; i++) {
             System.out.print(arr[i] + " ");
         }
     }
}