Swift 클래스

객체지향 용어
- Swift
  - 멤버 변수 = 프로퍼티(Property)
  - 멤버 함수 = 메소드(Method)
- Objective-C
  - 멤버 변수 = 인스턴스(Instance)
  - 멤버 함수 = 메소드(method)
- 객체 인스턴스
  - 실제로 메모리에 할당된 객체(object)
- 객체의 구성
  - 데이터 변수(data variable) or 속성(property)
  - 함수 or 메서드(method)

클래스

기본 클래스 선언 방식

  class 새로운 클래스 이름: 부모 클래스 {
  // 프로퍼티      => 클래스 내에 포함되는 변수(var)와 상수(let)를 정의한다.
  // 인스턴스 메서드      => 객체가 호출하는 메서드를 정의한다.
  // 타입(type) 메서드(클래스 메서드)   => 클래스가 호출하는 메서드를 정의한다.
  }

클래스에 property 추가하기
- Property는
  
  ㄴ 초기값이 있거나 ㄴ init을 이용해서 초기화하거나 ㄴ 옵셔널 변수(상수)로 선언
- property는 저장 프로퍼티(stored property)과 계산 프로퍼티(computed property)가 있다.
```
  class Ho{
    let age : Int = 21   		// stored property 는 초기값이 있어야한다.
    var weight : Double = 3.4
    var height : Double? 		// 옵셔널 변수는 자동으로 =nil
  }
```

메서드(Method)

인스턴스(instance) 메서드, 클래스 또는 타입(class or type)메서드

인스턴스 메서드는 인스턴스에서 동작

  class Ho{
    let age : Int = 21   			// stored property 는 초기값이 있어야한다.
    var weight : Double = 70
    var height : Double? 			// 옵셔널 변수는 자동으로 =nil
    func display(){
      print("나이 = \(age), 몸무게 = \(weight), 키 = \(height)")
    }					//나이 = 21 몸무게 = 70 키 = nil
  }
  var x : Int
  var shin : Ho = Ho() 			// : Ho 생략가능 + 디폴트 생성자
  print(shin.age)				// 21
  shin.display() 				//인스터스 메서드는 인스턴스가 호출

클래스(class or type) 메서드

타입 메서드 / 클래스 메서드 = 클래스 레벨에서 동작 ㄴ 클래스의 새로운 인스턴스를생성하는 것과 같은 동작
타입 메서드는 인스턴스 메서드와 동일한 방법으로 선언하지만 class 나 static 키워드를 앞에 붙여서 선언
class키워드로 만든 클래스 메서드는 자식 클래스에서 override가능

  class Ho{
    let age : Int = 21   
    var weight : Double = 70
    var height : Double?
    func display(){
      print("나이 = \(age), 몸무게 = \(weight), 키 = \(height)")
    }
    class func Hy(){				//override 가능
      print("Hy은 클래스 메서드 입니다.")
    }
    static func Shh(){
      print("Shh은 클래스 메서드(static)")
    }
  }
  var x : Int
  var shin : Ho = Ho() 			// : Ho 생략가능 + 디폴트 생성자
  print(shin.age)
  shin.display() 			//인스턴스 메서드는 인스턴스가 호출
  Ho.Hy()				//클래스 메서드는 클래스가 호출
  Ho.Shh()			//클래스 메서드는 클래스가 호출

인스턴스 초기화 : init()

클래스, 구조체, 열거형(enum) 인스턴스가 생성되는 시점에서 해야 할 초기화 작업

  class Ho{
    let age : Int    			// 초기값이 없어도 init()으로 인해 없어도 가능하다
    var weight : Double
    var height : Double 
    func display(){
      print("나이 = \(age), 몸무게 = \(weight), 키 = \(height)")
    }
   init(hoAge : Int, hoWeight : Double, hoheight : Double){
     age = hoAge
     weight = hoWeight
     height = hoheight
   }  		//designaed initializer	 = 모든 프로퍼티(age,weight,height)를 다 초기화 시키는 생성자
     
  }
  var shin : Ho = Ho(hoAge : 21, hoWeight : 70, hoheight : 170) 
  shin.display()

Self

현재 클래스 내 메서드나 프로퍼티를 가리킬 때 메서드나 프로퍼티 앞에 붙인다.

  class Ho{
    let age : Int    
    var weight : Double
    var height : Double 
    func display(){
      print("나이 = \(age), 몸무게 = \(weight), 키 = \(height)")
    }
   init(age : Int, weight : Double, height : Double){
     self.age = age		//self.age = 클래스 메서드 가리킨다.
     self.weight = weight		//weight = init 메소드안 지역변수를 가리킨다.
     self.height = height
   }  
     
  }
  var shin : Ho = Ho(age : 21, weight : 70, height : 170) 
  shin.display()

Stored property 와 Computed property

computed property(계산프로퍼티)는 property가 설정되거나 검색되는 시점에서 계산 또는 파생된 값

값을 리턴하는 게터(getter) 메서드

  class Ho{
    let age : Int    	// stored property
    var weight : Double	// stored property
    var height : Double 	
    var manAge : Int{	// computed property

  	//setter가 없으면 get{ }는생략할수 있으며 변경하지않더라도 var로 선언해야함
    get{			// get{} 생략가능 
      return age-1
    }
    }
    func display(){
      print("나이 = \(age), 몸무게 = \(weight), 키 = \(height)")
    }
   init(age : Int, weight : Double, height : Double){
     self.age = age
     self.weight = weight
     self.height = height
   }  //designaed initializer
         
  }
  var shin : Ho = Ho(age : 21, weight : 70, height : 170) 
  shin.display() 
  print(shin.manAge)	//20

값을 대입하는 세터(setter) 메서드

  class Ho{
    var age : Int    
    var weight : Double
    var height : Double 
    var manAge : Int{
      get{ return age-1 }			//set 과 같이 사용 할 땐 get{}생략 불가
      set(USAAge){ age = USAAge + 1 }	//(USAAge)대신 (newValue) 사용시 set의 괄호 생략가능
     }
    func display(){
      print("나이 = \(age), 몸무게 = \(weight), 키 = \(height)")
    }
   init(age : Int, weight : Double, height : Double){
     self.age = age
     self.weight = weight
     self.height = height
   }  //designaed initializer
         
  }
  var shin : Ho = Ho(age : 21, weight : 70, height : 170) 
  shin.display() 
  print(shin.manAge)		//20, getter 호출
  print(shin.age)			//21
  shin.manAge = 19		//setter 호출
  print(shin.age)			//20

Method Overloading : 생성자 중첩

  class Ho{
    var age : Int    
    var weight : Double = 70
    var height : Double = 170
    func display(){
      print("나이 = \(age), 몸무게 = \(weight), 키 = \(height)")
    }
   init(age : Int, weight : Double, height : Double){
     self.age = age
     self.weight = weight
     self.height = height
   }  //designaed initializer
   init(age : Int){			//매개변수의 개수와 자료형이 다른 같은 이름의 함수를 여러 개 정의
     self.age = age
   }
  }
  var shin : Ho = Ho(age : 21, weight : 70, height : 170)
  	var shin1 : Ho = Ho(age : 20)   //20 //overloading 호출
  shin.display() 
  shin1.display()
  }

Failable Initializers(실패 가능한 생성자: init?)

init?로 만든 인스턴스는 옵셔널형으로 만들어져서,

사용하려면 옵셔널을 언래핑해야 해서 제일 마지막에 “!”사용

오류 상황에 nil을 리턴하는 조건문이 있다 [return nil]

  class Ho{
    var age : Int    
    var weight : Double = 70
    var height : Double = 170
    func display(){
      print("나이 = \(age), 몸무게 = \(weight), 키 = \(height)")
    }
   init?(age : Int, weight : Double, height : Double){
     if age <= 0 || weight <= 0 || height <= 160 {
       return nil
     }
     else{
       self.age = age
       self.weight = weight
       self.height = height
     }
           
   }
  }
  var shin : Ho? = Ho(age : 21, weight : 70, height : 170)		// 옵셔널 형으로 선언
  if let shin1 = shin{  						//옵셔녈 바인딩
    shin1.display() 						//나이 = 21, 몸무게 = 70.0, 키 = 170.0
  } 
  var shin2 : Ho? = Ho(age : 0, weight : 70, height : 170)
  if let shin3 = shin2{
    shin3.display()   						//nil
  }
  if let shin4 = Ho(age : 19, weight : 70, height : 150){		//인스턴스 생성과 동시에 옵셔널 바인딩
    shin4.display()   						//nil
  }

                                                                                                     
  //강제 언래핑 하는 방법은 충돌이 발생해 위험하다.
  var shin5 : Ho = Ho(age : 21, weight : 70, height : 170)!	//인스턴스 생성하면서 바로 강제 언래핑
  shin5.display()

  var shin6 : Ho? = ho(age : 21, weight : 70, height : 170)	//옵셔널 인스턴스를 사용시 강제 언래핑
  shin6!.display()

Swift 클래스

Swift Basic

Swift 클래스

Swift Basic