코틀린 - 클래스

1. Init 블록

 

- 통하지 않고도 init {} 이라는 블록을 통해 클래스가 생성되자마자 자동으로 처리해야할 코드를 만들 수 있다.

 

class TestClass1
{
   Init()
   {
      println("지금 실행되었다!");
   }
}

---

2. 생성자

 

- Class 선언 시 뒤에 constructor을 붙여서 만들거나, 추가 생성자를 만들 수 있다.
- 코틀린의 생성자의 의미는 클래스 생성 시 매개변수를 받아 멤버변수의 값을 초기화하는 의미 이다.
- 추가 생성자는 반드시 뒤에 this를 붙여서 기본 생성자를 초기화(?) 시켜줘야한다.

 

fun main(args : Array<String>)
{
  var t1 = TestClass1(10, 400);

  println(t1.a1);
}

//기본 생성자
class TestClass1 constructor(a1 : Int)
{
  var a1 = a1
  var a2 = 0
  var a3 = 0

  //추가 생성자
  //뒤에 기본 생성자 this를 꼭 붙여줘야 하며, 매개 변수에 기본생성자에 있는게 들어가야함.
  constructor(a1 : Int, a4 : Int) : this(a1)
  {
    this.a1 = a1;
    this.a2 = a4;
  }
}

---

 

3. 상속

 

- 부모 Class에 open 키워드를 붙여야 다른 클래스가 상속할 수 있다.

- 자식 Class의 constructor는 반드시 부모 클래스의 constructor을 super()로 호출해야한다.

fun main(args : Array<String>)
{
  var su= Super();
  su.super_me();

  var si = Sub1();
  si.sub_me();
  si.super_me();

  var s3 = Sub2(100, 200);
  println(s3.a1);
  println(s3.a3)
}

// open 이라는 키워드를 붙여야 다른 클래스가 상속받을 수 있다.
open class Super
{
  var super_m3m = 100

  fun super_me()
  {
  println("dd");
  }
}

class Sub1 : Super
{
  // 자식클래스는 "반드시" 부모클래스의 상속자를 호출하는것이 필요하다.
  constructor() : super()

  fun sub_me()
  {
    println("웩");
  }
}

open class Super2 constructor(a1 : Int)
{
  var a1 = a1;
}

class Sub2 : Super2
{
  var a2 = 0;
  var a3 = 0;

  constructor() : super(100);
  constructor(a1 : Int, a2 : Int) : super(a1)
  {
    a3 = a2;
  }
}

---

4. 캡슐화(정보은닉)

 

- 프로퍼티 : 프로그래밍 언어에서 변수에 직접 접근할 수 없게 하고 메서드를 통해 변수에 값을 설정하거나 반환할 수 있도록 만드는 것
- setter : 변수에 값을 세팅하는 메서드
- getter : 변수의 값을 반환하기 위해 만든 메서드

class TestClass2{
  private var a1 = 100;

  // getter, setter 생성방법
  var value1 : Int
  set(v1)
  {
    println("Setter 호출");
    this.a1 = v1;
  }
  // 1번 표기 get() = this.a1
  // 2 번표기
  get()
  {
    println("Getter 호출");
    return this.a1;
  }
}

fun main(args : Array<String>)
{
  var t2 = TestClass2();

  //value를 통해 get, set 호출
  t2.value1 = 20;
  println(t2.value1);
}

---

5. 오버라이딩

 

- 부모클래스의 메서드를 자식 클래스에서 재구현 하는것

 

- 부모클래스 함수 앞에 open

- 자식클래스 함수 앞에 override

- 부모 클래스 참조변수로 만든 자식 클래스 객체는 자식 클래스에 접근할 수 없다.

fun main(args : Array<String>)
{
  var s1 = Sub1();
  s2.method1();

  // 부모 클래스 참조변수로 만든 자식 클래스 객체는 자식 클래스에 접근할 수 없다.
  var s2 : Super1 = Sub1();
  s1.method1();
  //s2.method2();
}

open class Super1
{
  open fun method1()
  {

  }
}

class Sub1 : Super1()
{
  override fun method1()
  {
    println("자식");
  }
}

---

6. 추상 클래스

 

- 추상 메서드(구현되지 않은 메서드)를 갖고있는 클래스

- 반드시 상속을 받는 자식 클래스가 있어야 한다.

- 추상 클래스의 목적은 상속을 통해 메서드 오버라이딩에 대한 강제성을 부여하기 위함에 있다.

 

- open abstract 키워드를 붙인다.

fun main(args : Array<String>)
{

}

open abstract class Super
{
  // 추상메소드
  open abstract fun method2()
  {
  }
}

class Sub1 : Super()
{
  override fun method2()
  {
  }
}

---

7. 인터페이스

- 생성된 객체를 다양한 타입의 변수에 담을 수 있도록 하는 것.

- 자체적으로 객체 생성이 불가하기 때문에 인터페이스를 구현한 클래스 객체 생성이 필요하다.

 

- 클래스를 설계할 때 여러 인터페이스를 구현하게 되면 생성된 객체는 각 인터페이스 타입 변수에
담을 수 있으며 이를 통해 인터페이스에 정의된 메서드를 호출할 수 있다.

- interface 키워드 사용

 

fun main( args : Array<String>)
{
  var t1 = TestClass();

  test_method1(t1);

  test_method2(t1);
}

interface Inter1
{
  fun method1()
  fun method2()
  {
  println("Inter1의 method2");
  }
}

interface Inter2
{
  fun method3()
  fun method4()
}

fun test_method1(a1 : Inter1)
{
  a1.method1();
  a1.method2();
}

fun test_method2(a2 : Inter2)
{
  a2.method3();
}

class TestClass : Inter1, Inter2
{
  override fun method1()
  {
    println("메쏘드 1");
  }

override fun method3()
{
  println("3333");
}

override fun method4()
{
}
}

---

8. DataClass

 

- 개념: 어떤 메서드를 정의하지 않고 단순히 데이터를 관리하기 위한 목적으로 사용하는 클래스.
- copy() = 데이터클래스로 만든 객체를 복사해서 새로운걸 만드는것.

 

- data class 키워드 사용

fun main(args : Array<String>)
{
  var d1 = Dataclass1(100, "문자열2");

  //카피
  var d5 = d1.copy();

  println(d5.a1);
}

data class Dataclass1(var a1 : Int, var a2 : String);
data class Dataclass2(var a1 : Int = 0, var a2 : String = "초기화 문자열");

---