1.  생성자 선언과 호출

📄  '생성자 constructor' 객체가 생성될 때 객체를 초기화하는 특수한 메서드. ( = 인스턴스 초기화 메서드 )

 

클래스 변수 = new 클래스();

 

  • new 연산자는 객체를 생성한 후 생성자를 호출해서 객체를 초기화하는 역할을 한다
  • 생성자가 성공적으로 실행이 끝나면 new 연산자는 객체의 주소를 리턴
  • 리턴된 주소는 클래스 변수에 대입되어 객체의 필드나 메소드에 접근 할 때 이용

1)  기본 생성자

  👾  모든 클래스는 생성자가 존재하며 하나 이상을 가질 수 있다.

  👾  클래스에 생성자 선언이 없으면 컴파일러는 다음과 같은 기본 생성자를 바이트코드 파일에 자동으로 추가시킨다.

         ➡️  그렇기 때문에 new 연산자 뒤에 기본 생성자를 호출할 수있다.

         ➡️  개발자가 명시적으로 선언한 생성자가 있다면 컴파일러는 기본 생성자를 추가하지 않는다.

[public] 클래스() { }
  • 클래스가 public class로 선언되면 기본 생성자도 public이 붙지만, 클래스가 public 없이 class로만 선언되면 기본 생성자에도 public이 붙지 않는다.


2)  생성자 선언

클래스(매개변수,...) {
  // 객체의 초기화 코드
}

 

  👾  생성자는 메소드와 비슷한 모양을 가지고 있으나, 리턴 타입이 없고 클래스 이름과 동일

  👾  매개변수는 new 연산자로 생성자를 호출할 때 매개값을 생성자 블록 내부로 전달하는 역할

public class Car {
    // 생성자 선언
    Car(String model, String color, int maxSpeed) { }
}
public class CarExample {
  public static void main(String[] args) {
    Car myCar = new Car("그랜저", "검정", 250);
    // Car myCar = new Car(); // 기본 생성자 호출 못함
  }
}

 

필드 초기화

 

  📍  객체마다 동일한 값을 갖고 있다면 필드 선언 시 초기값을 대입

  📍  객체마다 다른 값을 가져야 한다면 생성자에서 필드를 초기화

class Pizza {
    int size;
    String type;

    public Pizza() { // 매개변수가 없는 생성자
        size = 12;
        type = "슈퍼슈프림";
    }
    public Pizza(int s, String t) { // 매개변수가 있는 생성자
        size = s;
        type = t;
    }
}
public class PizzaTest {
    public static void main(String[] args) {
        Pizza pizza1 = new Pizza();
        System.out.println("(" + pizza1.type + ", " + pizza1.size + ")"); // (슈퍼슈프림, 12)

        Pizza pizza2 = new Pizza(24,"포테이토");
        System.out.println("(" + pizza2.type + ", " + pizza2.size + ")"); // (포테이토, 24)
    }
}

 

 

this 키워드

 

  📍 매개변수명이 필드명과 동일한 경우 필드임을 구분하기 위해 ths 키워드를 필드명 앞에 붙여줌

  📍 this는 현재 객체를 말하며, this.name은 현재 객체의 데이터(필드)로서의 name을 뜻함

public class Korean {
    // 필드 선언
    String nation = "대한민국";
    String name;
    String ssn;
    
    // 생성자 선언
    public Korean(String name, String ssn) {
        this.name = name;
        this.ssn = ssn;
    }    
}

 


3)  생성자 오버로딩 Overloading

  👾  매개값으로 객체의 필드를 다양하게 초기화하려면 생성자 오버로딩이 필요

  👾  생성자 오버로딩이란 매개변수를 달리하는 생성자를 여러 개 선언하는 것을 말함

public class Car {
    Car() { ... }
    Car(String model) { ... }
    Car(String model, String color) { ... }
    Car(String model, String color, int maxSpeed) { ... }
}

 

  • 매개변수의 타입, 개수, 순서가 다르게 여러 개의 생성자 선언
  • new 연산자로 생성자를 호출할 때 제공되는 매개값의 타입과 수에 따라 실행될 생성자가 결정됨.
// 오버로딩 아닌 경우
Car(String model, String color) { ... }
Car(String color, String model) { ... }

 

public class Car {
	//필드 선언
	String company = "현대";
	String model;
	String color;
	int maxSpeed;
	
	//생성자 선언
	Car() {}
	
	Car(String model) { 
		this.model = model; 
	}
	
	Car(String model, String color) {
		this.model = model;
		this.color = color;
	}
	
	Car(String model, String color, int maxSpeed) {
		this.model = model;
		this.color = color;
		this.maxSpeed = maxSpeed;
	}
}
public class CarExample {
	public static void main(String[] args) {
		Car car1 = new Car();
		System.out.println("car1.company : " + car1.company);
		System.out.println();

		Car car2 = new Car("자가용");
		System.out.println("car2.company : " + car2.company);
		System.out.println("car2.model : " + car2.model);
		System.out.println();
		
		Car car3 = new Car("자가용", "빨강");
		System.out.println("car3.company : " + car3.company);
		System.out.println("car3.model : " + car3.model);
		System.out.println("car3.color : " + car3.color);
		System.out.println();
		
		Car car4 = new Car("택시", "검정", 200);
		System.out.println("car4.company : " + car4.company);
		System.out.println("car4.model : " + car4.model);
		System.out.println("car4.color : " + car4.color);
		System.out.println("car4.maxSpeed : " + car4.maxSpeed);
	}
}

 

다른 생성자 호출

 

  📍 생성자 오버로딩이 많아질 경우 생성자 간의 중복된 코드가 발생할 수 있다.

  📍 이 경우 공통 코드를 한 생성자에만 집중적으로 작성하고, 나머지 생성자는 this(...)를 사용하여 공통 코드를 가지고 있는 생성자를 호출하는 방법으로 개선

Car(String model) { 
	this.model = model; 
	this.color = "은색";
	this.maxSpeed = 250;
}
	
Car(String model, String color) {
	this.model = model;
	this.color = color;
	this.maxSpeed = 250;
}
	
Car(String model, String color, int maxSpeed) {
	this.model = model;
	this.color = color;
	this.maxSpeed = maxSpeed;
}

 

Car(String model) {
    this(model, "은색", 250);
}

Car(String model, String color) {
    this(model, color, 250);
}

Car(String model, String color, int maxSpeed) {
    // 공통 초기화 코드
    this.model = model;
    this.color = color;
    this.maxSpeed = maxSpeed;
}

 

  • this( 매개값, ... )는 생성자의 첫 줄에 작성되며 다른 생성자를 호출하는 역할을 한다.
  • 호출하고 싶은 생성자의 매개변수에 맞게 매개값을 제공하면 됨.
  • this() 다음에는 추가적인 실행문을 작성할 수 있는데, 호출되는 생성자의 실행이 끝나면 원래 생성자로 돌아와서 다음 실행문을 실행한다. 

 

응용 문제
  1. 학생을 나타내는 클래스 Student를 만든다.
  2. 학생은 이름(name)과 학번(rollNo), 나이(age)를 가진다.
  3. 메서드는 생성자만 가진다.
  4. 생성자를 실행하면 아래의 결과값이 출력된다.
   학생의 이름 : Kim
   학생의 학번 : 0001
   학생의 나이 : 20
   Student 객체가 생성되었습니다.
class Student{
    String name;
    String rollNo;
    int age;

    public Student(String name, String rollNo, int age){
        this.name = name;
        this.age = age;
        this.rollNo = rollNo;

        System.out.println("학생의 이름 : " + name); // 학생의 이름 : Kim
        System.out.println("학생의 학번 : " + rollNo); // 학생의 학번 : 0001
        System.out.println("학생의 나이 : " + age); // 학생의 나이 : 20

        System.out.println("Student 객체가 생성되었습니다.");
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student("Kim", "0001", 20);
    }
}

 

 

 

* 내용 참고 - 책 '이것이 자바다'


1.  클래스  Class

간단하게 보면 클래스는 변수와 함수의 모음. 그룹화할 수 있는 변수와 함수를 한 군데에 모아 놓고 사용하기 쉽게 이름을 붙여놓은 것을 클래스 라고 이해하면 된다.


1) 코틀린에서 사용되는 클래스의 기본 구조

    class 클래스 이름 {
       var 변수
       fun 함수() {
           코드
       }
   }


 2) 클래스 코드 작성하기


👻  클래스를 만들기 위해서는 먼저 클래스의 이름을 정하고, 이름 앞에 class 키워드를 붙여서 만들 수 있음
👻  클래스 이름 다음에는 클래스의 범위를 지정하는 중괄호({}) 가 있어야 함
        ➡️  이 중괄호를 스코프 Scope라고 하는데, 클래스에서 사용했기 때문에 클래스 스코프라고 함

 class 클래스 이름 {  // 클래스 스코프 class scope   }


    ✓  '몇몇 예외'는 있지만 대부분의 코드는 클래스 스코프 안에 작성.

 

👻  작성된 클래스를 사용하기 위해서는 생성자라고 불리는 함수가 호출되어야 함

👻  코틀린은 프라이머리 primary와 세컨더리 Secondary 2개의 생성자를 제공


2. 생성자

1) 프라이머리 생성자

 class Person 프라이머리 생성자() { }


함수에 있는 코드를 실행하려면 함수를 호출해야 함. 클래스도 마찬가지로 클래스를 사용한다는 것은 곧 클래스라는 이름으로 묶여 있는 코드를 실행하는 것이기 때문에 함수 형태로 제공되는 생성자를 호출해야지만 클래스가 실행

  ⚡️ 프라이머리 Primary 생성자는 마치 클래스의 헤더처럼 사용할 수 있으며, constructor 키워드를 사용해서 정의하는데 조건에 따라 생략할 수 있음
  ⚡️ 프라이머리 생성자도 결국 함수이기 때문에 파라미터를 사용할 수 있음

   class Person constructor(value: String) {    // 코드   }

 

  📍 생성자에 접근 제한자나 다른 옵션이 없다면 constructor 키워드를 생략할 수 있음

  class Person(value: String) {   // 코드   }

 
   📍 클래스의 생성자가 호출되면 init 블록의 코드가 실행되고, init 블록에서는 생성자를 통해 넘어온 파라미터에 접근할 수 있음

fun main() {
    class Person1 constructor (str: String) {
        init {
            println("생성자로부터 전달받은 값은 ${str}입니다.")
        }
    }
    var person1 = Person1("1") // 생성자로부터 전달받은 값은 1입니다.
}

 

  📍   init 초기화 작업이 필요하지 않으면 init 블록을 작성하지 않아도 됨
          ➡️ 대신 파라미터로 전달된 값을 사용하기 위해서는 파라미터 앞에 변수 키워드인 val을 붙여주면 클래스 스코프 전체에서 해당 파라미터를 사용할 수 있음

fun main() {
    class Person2(val str: String) {
        fun process() {
            println("생성자로 생성된 변수의 값은 ${str}입니다.")
        }
    }

    var person2 = Person2("2")
    person2.process() // 생성자로 생성된 변수의 값은 2입니다.
}

    

   ✓ 생성자 파라미터 앞에 var도 사용할 수 있으나, 읽기 전용인 val을 사용하는 것을 권장


 2) 세컨더리 생성자


세컨더리 Secondary 생성자는 constructor 키워드를 마치 함수처럼 클래스 스코프 안에 직접 작성할 수 있음
그리고 다음과 같이 init 블럭을 작성하지 않고 constructor 다음에 괄호를 붙여서 코드를 작성할 수 있음

    class Person3 {
        constructor(str: String) {
            println("생성자로부터 전달받은 값은 ${str}입니다.")
        }
    }

 

  📍 세컨더리 생성자는 파라미터의 개수, 또는 파라미터의 타입이 다르면 (오버로딩) 여러 개를 중복해서 만들 수 있음

fun main() {
    class Sample {
        constructor(str: String) {
            println("생성자로부터 전달받은 값은 ${str}입니다.")
        }

        constructor(value: Int) {
            println("생성자로부터 전달받은 값은 ${value}입니다.")
        }

        constructor(value1: Int, value2: String) {
            println("생성자로부터 전달받은 값은 ${value1}, ${value2}입니다.")
        }
    }

    val sample = Sample(1,"2") // 생성자로부터 전달받은 값은 1, 2입니다.
}

3) Default 생성자


생성자를 작성하지 않을 경우 파라미터가 없는 프라이머리 생성자가 하나 있는 것과 동일

fun main() {
    class Student { // 생성자를 작성하지 않아도 기본 생성자가 동작.
        init {
            // 기본 생성자가 없더라도 초기화가 필요하면 여기에 코드를 작성.
        }
    }
}

 


 3.  클래스의 사용

클래스명()

 

👻  클래스의 이름에 괄호를 붙여서 클래스의 생성자를 호출. constructor 키워드를 호출하지 않음
    ⚡️ 아무런 파라미터 없이 클래스명에 괄호에 붙여주면 생성자가 호출되면서 init 블록 안의 코드가 자동으로 실행
    ⚡️ 세컨더리 생성자의 경우 init 블록이 먼저 실행되고 constructor 블록 안의 코드가 실행

👻  코틀린에서는 자바보다 클래스를 좀 더 편하게 정의할 수 있음
    ⚡️ 자바의 보일러 플레이트 코드가 삭제되고 필요한 코드들만 작성하면 되도록 바뀜
         * 보일러 플레이트 코드 : 상용구 코드. 변형이 거의 또는 전혀 없이 여러 위치에서 반복되는 코드 문구.

fun main() {
   
    class Car(val color: String)

    /*
    객체를 생성. 자바에서는 new 키워드를 사용했지만, 코틀린에서는 필요가 없음.
     */
    var car = Car("blue") // 객체 생성

}

 

 

 

[ 내용 참고 : IT 학원 강의 ]


 

1.  객체

🚀   개발을 하다 보면 정수나 실수 또는 문자열 등 기본적인 자료형으로 표현하기 힘든 것들이 존재
         ➡️  예를 들어 어떤 게시글을 파이썬으로 표현을 한다면 [게시글 번호, 제목, 작성자, 비밀번호, 내용, 최초작성일자, 최종수정일자, 조회수]가 필요한데 이를 손쉽게 관리 하려면 8개의 항목을 하나의 이름을 가진 객체 object로 만들어서 사용

 


2. 클래스

🚀  클래스 class를 한 마디로 정의하면 객체를 만드는 도구
🚀  하나의 클래스를 만들어 두면 그 클래스를 통해서 (동일한 구조를 가진) 여러 개의 객체를 만들수 있다
        ➡️  같은 클래스로 만든 객체라 하더라도 객체들은 서로 다른 값을 가질수 있음
        ➡️  인스턴스 instance 역시 클래스를 이용해서 생성한 객체를 가르키는 용어

 

    💡  객체와 인스턴스의 미묘한 차이
            a. 와플머신 클래스로 만든 와플은 객체 object
            b. 와플은 와플머신 클래스의 인스턴스 instance


1) 클래스의 구성

👾  클래스의 기본 구성
    -  객체를 만들어내는 클래스는 객체가 가져야 할 값과 기능을 가지고 있어야 함
         ▶️  값은 변수, 기능은 함수
    -  클래스를 구성하는 변수는  a. 클래스를 기반으로 생성된 모든 인스턴스들이 공유하는 변수인 '클래스 변수'
                                                    b. 모든 인스턴스들이 개별적으로 가지는 변수인 '인스턴스 변수'로 분리됨
    -  클래스를 구성하는 함수는 메소드 method라고 하고
         a) 클래스 메소드 b) 정적 메소드 c) 인스턴스 메소드로 분리


2) 클래스 정의방법

👾 class 키워드로 클래스를 정의
👾 클래스 이름은 Upper Camel Case 규칙을 따름
👾
파이썬은 변수나 함수의 이름을 네이밍할 때 언더바(_)를 이용해 단어를 연결하는 Snake Case 방식을 사용하지만

     클래스는 Upper Camel Case 규칙을 따름
      ex. print + member : printmember 1) print_member 2) printMember 3) PrintMember

# 클래스는 다음과 같은 형식으로 정의
class 클래스 :
    본문

3. 객체 생성

# 클래스가 정의되었다면 다음과 같은 형식으로 객체를 생성
객체 = 클래스()

# 2개의 객체를 만들고 싶으면
객체1 = 클래스()
객체2 = 클래스()

# 클래스 정의와 객체 생성
class WaffleMachine : # WaffleMachine이라는 클래스 정의
    pass  # 내부코드를 작성하지 않을 때 쓰임

waffle1 = WaffleMachine()  # WaffleMachine 이라는 클래스를 이용해 waffle이라는 객체 생성
waffle2 = WaffleMachine()

print(waffle1)  # <__main__.WaffleMachine object at 0x102beee60>
# 메모리의 0x102beee60번지에 저장된 WaffleMachine의 객체라는 의미
print(waffle2)

4. 인스턴스 변수와 인스턴스 메소드

🚀  인스턴스 변수란 클래스를 기반으로 만들어지는 모든 인스턴스들이 각각 따로 저장하는 변수
      ⚡️ 모든 인스턴스 변수는 self라는 키워드를 앞에 붙여줌
🚀  인스턴스 메소드란 인스턴스 변수를 사용하는 메소드
      ⚡️ 인스턴스 메소드는 반드시 첫 번째 매개변수로 self를 추가해야 함

class Person :  # Person 클래스를 정의
    # 첫 번째 매개변수가 self이므로 인스턴스 메소드
    # 모든 인스턴스는 who_am_i() 메소드를 호출할 수 있음
    # 매개변수 self에는 메서드를 호출하는 인스턴스가 전달
    # self를 제외한 나머지 매개변수에 실제로 사용될 데이터가 전달
    def who_am_i(self, name, age, tel, address):
        # 인스턴스 변수 = 매개변수. 모든 인스턴스 변수는 최초에 값이 대입되는 시점에 알아서 생성.
        self.name = name
        self.age = age
        self.tel = tel
        self.address = address

boy = Person()  # 인스턴스 boy가 생성. 클래스의 생성자가 호출
#print(boy.name)  # 'Person' object has no attribute 'name'
boy.who_am_i('john', 15, '123-1234', 'toronto')  #인스턴스 메소드 호출
print(boy.name)  # john
print(boy.age)  # 15
print(boy.tel)  # 123-1234
print(boy.address)  # toronto

# 클래스에 없는 속성도 추가가 가능함. 다른 언어의 객체와는 다른 방식.
boy.email = 'test@test.com'
print(boy.email)  # test@test.com

 

 


 

5. 생성자  constructor

 

🚀  클래스 이름과 같은 함수를 생성자라고 한다.  

🚀  값을 가진 인스턴스를 생성하기 위해 생성자를 이용
🚀  생성자는 인스턴스를 생성할 때 자동으로 호출되는 특별한 메소드

 

    ⚡️  모든 클래스는 __init__() 이라는 이름을 가진 함수를 가지고 있음
            ➡️  인스턴스가 생성될 때 자동으로 호출되기 때문에 인스턴스 변수의 초기화 용도로 사용

class Candy:
    def __init__(self, shape, color):
        print('실행이 될까?')
        self.shape = shape
        self.color = color

satang = Candy('circle', 'brown')
print(satang.color) 
# 실행이 될까?
# brown

 


 

6. 소멸자  destructor

🚀  인스턴스가 생성될 때 자동으로 호출되는 생성자와 마찬가지로 인스턴스가 소멸될 때 자동으로 호출되는 메소드
🚀  소멸자는 __del__()

class Sample:
    def __del__(self):
        print('인스턴스가 소멸됩니다')

sample = Sample()

del sample  # 인스턴스가 소멸됩니다


# 매직 메서드 샘플
class Sample:
    def __int__(self):
        pass

    def __len__(self):
        return 6

    def __str__(self):
        return 'what?'

li = [1, 2, 3]
print(len(li))  # 3

sample = Sample()
print(len(sample))  # 6
print(sample)  # what?

 

7.  메소드  method

🚀  클래스가 가지고 있는 함수를 말한다.

🚀  파이썬 프로그래밍에서는 멤버 함수(member funcion) 혹은 인스턴스 함수(instance function) 등의 용어를 더 많이 사용함

class 클래스 이름:
    def 메소드 이름(self, 추가적인 매개변수):
        pass

 

 

 

 

[ 내용 참고 : IT 학원 강의 및 책 '혼자 공부하는 파이썬' ]

+ Recent posts