TIL: git clone, git branch, git switch , data class , 생성자 ,상속, 인터페이스

git clone "주소"    //프로젝트를  복사하기

git switch "브랜치 이름"    //브랜치 바꾸기. 최근에 추가된 명령어이다.
git checkout "브랜치 이름"    //브랜치 바꾸기. 위랑 같은 역할

git branch  //현재 브랜치 확인

git push origin "브랜치 이름"  //해당 브랜치로 올리기

 

data class

data class 클래스이름 {
    정보1
    정보2
}

프로퍼티만 갖고 있는 클래스이다. 앞에 data를 붙이면 된다는데 사용해본 적이 없어서 모르겠다. 

 

 

sealed class

sealed class 부모클래스 {
	class 자식클래스1 : 부모클래스생성자
	class 자식클래스2 : 부모클래스생성자
}

open class를 붙이면 상속을 해줄 수 있다. 앞에 sealed를 붙이면 자식클래스를 미리 정의해줄 수 있어서 내가 의도하지 않은 상속을 피할 수 있다. 

 

생성자

마법사 클래스로 마법사 객체를 만든다고 가정한다.

fun main() {
	//기본 생성
	var magician = Character()
    
    var magician1 = Character2("멀린", "white", 172.7)
    
    // 인자 순서 바꿔도 변수의 이름을 지정해주면 가능
    var magician2 = Character2(_hairColor="white",_heigh=182.7,_name="로랜스")
    
    //인수를 다 넣지 않아도 2개만 넣어도 되는 생성자가 있기 때문에 생성된다.
    //나머지값은 정해지지 않은 상태
    var magician3 = Characte2r("랄프", "blue")
}

// 클래스 선언부에 생성자를 명시함
class Character(_name:String, _hairColor:String, _height:Double) {
    var name:String = ""
    var hairColor:String = ""
    var height:Double = 0.0

		// 매개변수를 직접 넘기지않음
    init {
        println("매개변수없는 생성자 실행 완료!")
    }

    fun fireBall() {
        println("파이어볼!")
    }
    fun compositing(device1:String, device2:String): String {
        var device3 = device1 + device2
        println("새로운 무기인 ${device3}입니다")
        return device3
    }
}



  class Character2 {
      var name:String = ""
      var hairColor:String = ""
      var height:Double = 0.0

      // 명시적 생성자 (Constructor)
      // _name, _hairColor, _height와 같이 생성자에 변수를 넘기는 경우에 사용함
      constructor(_name:String, _hairColor:String, _height:Double) {
          println("${_name}을 생성자로 넘겼어요")
          println("${_hairColor}를 생성자로 넘겼어요")
          println("${_height}를 생성자로 넘겼어요")
      }
      // 인수를 다르게하여 여러개 만들 수 있다.
      constructor(_name:String, _hairColor:String) {
          println("${_name}을 생성자로 넘겼어요")
          println("${_hairColor}를 생성자로 넘겼어요")
      }
      constructor(_name:String) {
          println("${_name}을 생성자로 넘겼어요")
          println("${_hairColor}를 생성자로 넘겼어요")
      }

      fun fireBall() {
          println("파이어볼!")
      }
      fun compositing(device1:String, device2:String): String {
          var device3 = device1 + device2
          println("새로운 무기인 ${device3}입니다")
          return device3
      }
  }

 

인터페이스

상속할 클래스 뒤에 : 인터페이스 이름을 입력한다.

interface WaterBirdBehavior {
    fun swim()
// 	아래 내용을 넣어주고 싶지만 인터페이스이기 때문에 구현해서는 안된다.  
//    fun swim() {
//        println("수영 합니다")
//    }
}


fun main() {
	//객체 생성. 상속받는 자식클래스를 생성할 때,상속하는 부모클래스의 인자도 넣어줘야한다.
    var bird = Bird("새")
    var chicken = Chicken("닭")
    var sparrow = Sparrow("참새")
    var pigeon = Pigeon("비둘기")
    var duck = Duck("오리")

	//함수 실행
    bird.fly()
    chicken.fly()
    sparrow.fly()
    pigeon.fly()
    duck.swim()
}


open class Bird(name:String) {
    var name: String = ""

    init {
        // this는 현재 클래스의 상태변수를 의미합니다
        // var name: String = ""
        this.name = name
    }
	
    fun fly() {
        println("${name} 날아요~")
    }

}

class Chicken(name: String) : Bird(name) {
	//구현되어 있지 않지만 상속으로 Bird 클래스로부터 메소드를 받아온다.
    }

class Sparrow(name: String) : Bird(name) {
	//구현되어 있지 않지만 상속으로 Bird 클래스로부터 메소드를 받아온다.
}

class Pigeon(name: String) : Bird(name) {
	//구현되어 있지 않지만 상속으로 Bird 클래스로부터 메소드를 받아온다.
}

//WaterBirdBehavior 인터페이스 적용
class Duck(name: String) : Bird(name), WaterBirdBehavior {
    // 인터페이스 구현!!! 오버라이드로 swim 메소드를 재정의한다. 
    override fun swim() {
        println("${name}가 수영해요~")
    }
}

 

상속

클래스 뒤에 : 상속 으로 합니다.

여러개를 써야할 때는 : 상속자1, 상속자2 형태로 씁니다.

fun main() {
	//객체 생성. 상속받는 자식클래스를 생성할 때,상속하는 부모클래스의 인자도 넣어줘야한다.
    var bird = Bird("새")
    var chicken = Chicken("닭", 2)
    var sparrow = Sparrow("참새", "갈색")
    var pigeon = Pigeon("비둘기", "서울")

    bird.fly()
    chicken.fly()
    sparrow.fly()
    pigeon.fly()
}

open class Bird(name:String) {
    var name: String = ""

    init {
        // this는 현재 클래스의 상태변수를 의미합니다
        // var name: String = ""
        this.name = name
    }

    open fun fly() {
        println("${name}은 날아요~")
    }

}

class Chicken(name: String, age: Int) : Bird(name) {
    var age:Int = 0

    init {
        this.age = age
    }

    override fun fly() {
//        super객체는 부모의 객체를 의미하며 자동으로 생성됨
//        즉 부모객체의 fly메소드를 부르는 행위임
//        필요없으니 주석처리완료
//        super.fly()
        println("${age}살의 ${name}가 날아봅니다~ 꼬끼오!")
    }
}

class Sparrow(name: String, color: String) : Bird(name) {
    var color:String = ""

    init {
        this.color = color
    }

    override fun fly() {
//        super객체는 부모의 객체를 의미하며 자동으로 생성됨
//        즉 부모객체의 fly메소드를 부르는 행위임
//        필요없으니 주석처리완료
//        super.fly()
        println("${color}의 ${name}이 날아봅니다~ 짹짹!")
    }
}

class Pigeon(name: String, address: String) : Bird(name) {
    var address: String = ""

    init {
        this.address = address
    }

    override fun fly() {
//        super객체는 부모의 객체를 의미하며 자동으로 생성됨
//        즉 부모객체의 fly메소드를 부르는 행위임
//        필요없으니 주석처리완료
//        super.fly()
        println("${address} 살고있는 ${name}가 날아봅니다~ 구구!")
    }
}