90일차 수업 정리(Swift - Function, 구조체, Class, Method)

**Function(함수)

    => 독립적으로 존재하지만 독립적으로 실행할수 있는 모듈

    => 실제 작업의 처리 단위

    => Function이 클래스 안에 작성되어 클래스나 인스턴스를 이용해서 호출되면 메소드

    => 호출하는 대상(Receiver)이 있으면 메소드, 없으면 함수라고 함

    => 함수의 원형 : 함수의 모양(어떻게 호출하고 어떤 결과를 남겨주는지 확인)

        - 함수명(매개변수) -> 리턴타입

        - 다른 언어에서는 리턴타입 함수명(매개변수)의 형태로 작성

        - 자신이 만든 메소드는 자신이 호출하므로 오른쪽의 패키지나 프로젝트 창을 보면 모양이 보임

        - SDK나 Framework가 제공하는 함수, 메소드의 경우 Document에서 원형을 찾아 개발자가 직접 호출

        - SDK학습시 이 메소드가 재사용 될것 같으면 Document에서 원형을 찾아 기록하던가 외우는 것이 좋음

    => 함수, 메소드 학습 순서

        - 원형을 보고 호출하는 방법 학습

        - 구현하고자하는 기능의 메소드 원형을 만드는 것을 학습

        - 메소드 안의 내용을 채우는 것을 학습

1. swift에서 함수 만드는 방법

func 함수명(매개변수 나열) -> 리턴타입{
	함수내용
    리턴타입이 void가 아니면 return 데이터
}

    => 매개변수가 없으면 ( ) : 괄호는 없어도 생략할 수 없음

    => 리턴 타입이 없으면 Void라고 적거나 -> 리턴타입 부분 생략

 

2. swift에서 함수 호출

    - 함수명(매개변수 명 : 매개변수...)

 

3. 클라이언트 프로그램과 서버 프로그램에서의 매개변수 생성의 차이점

    => 매개변수가 2개 이상인 경우 서버 프로그래머들은 이 부분을 DTO 클래스나 Map으로 묶어서 처리

    => 클라이언트 프로그래머들은 나열하는 방식 선호

        - swift나 kotlin에서는 나열하는 방식 선호, spring 같은 서버 프레임워크에서는 DTO형태로 묶는 것을 선호

 

4. 함수를 선언하는 부분이 호출하는 부분보다 아래 있어도 됨

    => 함수, 구조체, 클래스, 프로토콜과 같은 선언부는 호출하는 부분보다 아래있어도 됨

        - 실제 구현시에는 함수들을 별도의 파일에 만들어서 사용하는 것을 권장

        - 인터페이스를 생성하는 이유 : 유저는 무엇을 할수 있는지만 보고(인터페이스), 개발 소스는 serviceImpl에 작성

          (DAO의 경우에도 기획자나, PM과 대화시에는 필요할 수도 있음 - 필요여부는 생각해봐야 함)

    => 컴파일러는 해석시 선언부를 전부 찾아서 메모리에 할당하고(static) 그 이후 다시 처음부터 읽어가면서 수행

 

5. 매개변수(Argument)

    => 함수나 메소드 호출시 넘겨주는 데이터

    => 매개변수는 함수 내에서만 사용할 수 있는 지역변수(Local Variable - 선언된 영역에서만 사용가능 변수)

    => 함수 내부에서 부를 경우 Parameter라고 함

    => 함수 호출시 매개변수를 대입할 때, 매개변수 명과 함께 대입해야 함

        - 함수(매개변수명:매개변수) 형태로 호출

  1) 매개변수명을 사용함으로써 발생하는 문제

    => 매개변수명을 이해하기 쉽도록 장문으로 작성시 외부에서 대입할 때 불편(별명을 사용할 수 있도록 함)

    => 누구나 예측 할 수 있는 매개변수명을 사용하는 것은 자원의 낭비가 될수 있음

        - 앞에 _를 붙여서 생략할 수 있도록 해줌

    => 이렇게 생략하는 것은 맨 앞에 하나만 해주는 것이 좋고, 예측이 가능해야 함

//위의 함수를 별명을 이용하여 매개변수를 대입하도록 수정
//뒤의 이름은 친절한 설명인 경우가 많고, 앞의 이름은 약자인 경우가 많음
func disp(msg message : String)->Void{
    print(message)
}
disp(msg: "매개변수에 별명 사용")

//위의 함수를 매개변수명을 생략하고 사용할 수 있도록 수정
//iOS SDK에서는 첫번째만 생략가능
func disp(_ message:String){
    print(message)
}
disp("매개변수명 생략")

 

  2) 매개변수의 생략 - 기본값을 설정

    => 매개변수를 생략할 수 있도록 하려면 반드시 매개변수의 자료형을 기재해야 함

        - func 함수명(매개변수명 : 자료형 = 기본값...)

    => 위의 매개변수는 생략시 기본값이 설정

    => 생략은 뒤에서부터 해야 함(앞의 매개변수를 생략하고, 뒤의 매개변수를 대입하는 구조는 불가)

  3) varargs

    => 매개변수의 개수를 가변으로 입력하는 구조

        - func 함수명(매개변수명:자료형...)

    => 내부적으로 처리할 때는 데이터를 묶어서 배열로 간주

    => java, kotlin에도 있는데 거의 사용하지 않음

    => 데이터베이스 연동 프레임워크에서 PreparedStatement 구조를 만들 때 ?를 사용하는 경우, ?에 값 대입시 이용, 출력 함수에 이용

  4) Call by Value & Call by Reference

    => Call by Value : 매개변수의 자료형이 일반 데이터인 경우

        - 값을 복사해서 대입하는 형태가 되어 호출하는 곳의 데이터를 함수가 변경 할 수 없음

    => Call by Reference : 매개변수의 자료형이 참조형인 경우

        - 저장하고 있는 값이 참조라서 참조를 복사하여 대입하는 형태가 되어, 호출하는 곳의 데이터를 함수가 변경 불가

        - 자바에서 메소드에 참조를 넘겨주었으면 값이 변경될 수 있음

    => 프로그래밍에서는 Call by Value를 선호

        - 넘겨준 데이터를 함수가 변경시 어떤 이유로 변경되었는지 확인해야 하기 때문

        - Call by Reference를 사용하는 경우 메모리 절약을 위해 사용됨

  5) 복사

    => 저장하고 있는 데이터를 그냥 대입

    => weak copy : 참조하고 있는 데이터를 복사 - 재귀적으로 복사하지는 않음

    => deep copy : 참조하고 있는 데이터를 복사 - 재귀적으로 복사

    => 참조형 -> 일반값 : weak copy나 deep copy가 차이가 없음

        - 참조형 -> 참조형 -> 일반값 : weak copy는 두번째 참조형 데이터만 복제, deep copy는 끝까지 찾아가서 일반값을 복사

        - deep copy는 일반 값이 나올 때까지 재귀적으로 찾아가서 값을 복사해주는 방식

  6) swift에 참조복사

    => swift의 함수는 매개변수에 대입시 기본적으로데이터를 복제해서 대입

    => 참조를 대입하고자하면 매개변수 앞에 inout을 추가해주면 됨

    => 함수를 호출할 때는 &를 붙여서 대입

    => 예외적으로 클래스로부터 만들어진 인스턴스를 매개변수로 사용하는 경우 참조가 복사됨

  7) swift에서는 함수가 일급객체

    => 함수를 하나의 자료형으로 간주 : javascript도 동일

    => 함수를 하나의 변수에 대입할 수 있고, 리턴할 수 있음

    => 자바스크립트 closure : 함수가 함수를 리턴하여 외부에서 함수 내부의 데이터를 조작할 수 있도록 하는 기능

 

6. return

    => 함수는 수행을 종료하고 호출한 곳으로 돌아가는데 이것을 return 이라고 함

        - 호출한 곳으로 돌아가는 것

    => 함수는 return시 하나의 데이터를 가지고 돌아갈 수 있는데  이 데이터의 자료형을 return type라고 함

        - 함수를 호출한 곳에서는 이 return되는 데이터를 확인해서 다음 작업을 수행 할 수 있음

    => return 시 여러개의 데이터를 가지고 리턴을 해야하면 Dictionary나 DTO 클래스를 이용 가능

        - swift에서는 구조체와 튜플을 이용할 수도 있음

    => 파이썬, 스위프트에서 함수가 여러 데이터 리턴시 튜플을 사용해야 한다라는 부분이 있으면 이 의미는 튜플로도 할 수 있다라는 의미

    => 리턴할 데이터가 없으면 리턴타입을 Void라고 하고 생략해도 되고, Void라고 작성해도 됨

    => 리턴되는 데이터가 있으면 그 데이터를 이용하여 다른 함수를 호출할 수 있음

//swift는 함수가 일급객체 - 하나의 자료형
//함수를 다른 변수에 대입하는 것이 가능
var display = disp
display("스위프트는 함수가 일급객체")

//양수를 입력받아서 양수까지의 피보나치 수열을 리턴하는 함수
func fiboNoRecursion(su:UInt32) -> UInt32{
    if(su == 1 || su == 2){
        return 1
    }
    //이전 첫번째 항의 값을 저장할 변수
    var x1:UInt32 = 1
    //이전 두번째 항의 값을 저장할 변수
    var x2:UInt32 = 1
    //피보나치 수열의 값을 저장할 변수
    var result:UInt32 = 1
    
    for _ in 3...su{
        result = x1 + x2
        x2 = x1
        x1 = result
    }
    return result
}
print(fiboNoRecursion(su: 10))

 

  1) Recursion(재귀함수)

    => 함수가 자기 자신을 다시 리턴하는 함수

    => 함수가 내부에서 다시 함수를 호출하는 구조라서 메모리 사용량이 많고 속도는 느림

    => 소스 코드를 이해하기 쉽고 짧게 만들수 있음

    => 합계, 팩토리얼, 하노이의 탑, 미로찾기, 퀵소트 등이 재귀를 사용하는 대표적인 예

  2) nested function

    => 함수 안에 만들어진 함수

    => 함수 안에서 함수를 만들어서 리턴하여 함수 외부에서 함수 내부의 값을 변경하기 위해서 생성

    => 이 개념을 자바스크립트에서는 클로저라고 함

//내부함수 - 함수 안에 포함된 함수
//함수를 리턴
func outer() -> (() -> Void){
    //x는 지역변수 : 함수 외부에서는 변경 불가
    var x = 0
    //내부에 함수를 생성
    func inner() -> Void{
        x = x + 1
        print(x)
    }
    //함수를 리턴
    return inner
}

//외부 함수를 호출해서 함수를 저장
var f = outer()
//outer에 만들어진 inner를 호출
f()
f()

    => 변수는 영역에 따라 나눌때 지역변수, 인스턴스 변수, 전역변수로 나누어 사용하는 경우가 있음

        - 서로다른 영역에서 하나의 변수를 공유하려면 전역변수를 사용해야 함

    => 객체 지향에서는 전역변수 사용을 금기시 함

        - 전역변수는 모든 영역에서 수정이 가능하므로 전역변수의 값을 확인하려면 프로그램 모든 부분을 확인해야 함

        - 프로그램을 이해하기 어렵게 만들어 유지보수가 어렵게 됨

    => 함수 안에서 함수를 리턴하는 구조를 만들어서 함수 내부의 데이터를 수정할 수 있으면 전역변수를 사용하지 않아도 됨

    => 자바 스크립트에서는 이 개념을 Closure라고 하고 자바 스크립트 기본 문법 책들에는 거의 이내용이 없음 or 마지막 세션

        - 개념과 용도가 많이 중요

        - Web 프로그래밍 면접시 Front End에서 가장 어렵고 중요하게 생각하는 개념이 ajax와 closure

  3) swift의 closure

    => Java의 람다의 개념(이름없는 함수를 만드는 개념)

    => 이벤트 처리를 할 때 작업은 함수가 수행하기 때문에 swift에서는 이벤트 처리 핸들러가 객체가 아니고 함수

        - 함수도 하나의 이름을 가지고 정의하는 것이므로 한번 만들면 계속 존재

        - 순간 만들었다가 필요 없어지면 삭제할 수 있도록 해야하는데 이렇게 하려면 이름이 없어야 함

    => 생성

{(매개변수 나열) -> 리턴타입 in
	함수의 내용
}

    => 매개변수가 1개인 경우 ()를 생략하는 것이 가능

    => 매개변수가 없거나 2개 이상인 경우 () 생략 불가

 

    => trailing closure

        - swift에서 함수의 매개변수로 함수가 설정된 경우 매개변수가 가장 마지막이라면 ()안이 아닌, () 바깥에 클로저를 제작 및  연결 가능

        - iOS SDK의 샘플 코드들의 이벤트 처리가 이 trailing closure로 만들어진 경우가 많음

    => @escaping

        - 함수의 매개변수로 함수가 설정된 경우 내부에서 매개변수로 대입된 함수를 다른 변수에 대입 불가, @escaping 사용시 다른 변수에

          대입하고 사용할 수 있음

    => @autoclosure

        - 일반 구문을 대입해도 클로저 구문으로 변경하고자 할 때 사용하는 어노테이션

//배열생성
var  ar = [30, 10, 20]
//기본 정렬
//ar.sort()

//2개의 크기를 비교해서 Bool로 리턴하는 함수
func mycomp(n1:Int, n2:Int) -> Bool{
    return n1 > n2
}
//원하는 함수를 적용하여 정렬
ar.sort(by:mycomp)

//closure를 이용해서 위와 동일한 작업
//closure는 이름없이 코드만으로 함수를 생성
//Java의 람다와 유사
ar.sort(by:{(n1:Int, n2:Int) -> Bool in
    return n1 > n2
})

//trailing closure
//함수가 매개변수의 가장 마지막 요소로 설정된 경우 closure를 ()뒤에 부착하는 것이 가능
//iOS SDK는 이 방법을 많이 사용
ar.sort(){(n1:Int, n2:Int) -> Bool in
    return n1 > n2}
//정렬된 데이터 출력
print(ar)

 

  4) 함수에서 중요

    => 함수를 호출하는 방법

    => iOS SDK에서는 closure - 작성 방법보다는 샘플 코드에서의 의미

        - 함수가 매개변수인 경우 closure 형태로 도큐먼트에 설명되므로 closure를 보고 대입 형태를 잘 파악할 수 있어야 함

    => 이 구조를 잘 파악해야 Call Back 함수를 만들수 있음

        - Call back : 이벤트가 발생 했을 때 호출되는 것

  5) 함수라는 개념이 있지만 iOS SDK에는 함수를 거의 제공하지 않음

 

**객체 지향

    - Class :  관련성있는 변수(저장)와 함수(기능)의 집합

    - Instance : Class를 기반으로 메모리 할당을 받은 객체

 

    - Encapsulation : 불필요한 부분은 숨기고 필요한 부분만 외부로 노출 - 접근 지정자, 정보은닉

    - Inheritance : 상속 - 상위 클래스의 모든 것을 하위 클래스가 물려받는 것, 재사용성 증가

        -> Super(Base) Class : 상위 클래스

        -> Sub(Derived) Class : 하위 클래스

    - Polymorphism : 다형성 - 동일한 메시지에 대하여 다르게 반응하는 성질

                                            - 동일한 코드가 대입된 인스턴스에 따라서 다른 메소드를 호출하는 것

 

    - Abstract : 하위 클래스들에 동일한 요소가 있을 때 이를 위로 올리는 것

    - Interface(Protocol) : 모양만 만들어두고 하위 클래스에서 구현(implementation, conform)하도록 한것

        -> 템플릿 메소드 패턴, 메뉴판(어떠한 것들이 있다)

    - Method Overloading : 하나의 클래스에 메소드명은 같고 매개변수의 개수나 자료형이 다른 메소드가 존재하는 것

    - Method Overriding : 상위 클래스의 메소드를 하위 클래스에서 다시 정의하는 것

        -> swift에서는 상위 클래스 메소드를 재정의하는 것을 오버라이딩, Protocol의 메소드를 재정의 하는 것은 오버라이딩이 아님

 

**구조체(Struct)

    => 공통된 목적을 달성하기 위해 모인 변수와 함수의 집합

    => 사용자 정의 자료형 : 내부 요소를 개발자가 마음대로 구성할 수 있는 자료형

    => Swift에서 Struct는 Value Type이고, Class는 Reference Type

    => Swift에서 제공하는 자료형들은 대부분 Struct, iOS SDK에서 제공하는 자료형들은 대부분 Class

    => 구조체나 클래스안에 만들어진 변수들은 Property or attribute or field라고 함

        - 함수는 method, 이 둘을 합쳐서 member라고 하는 경우가 많음

    => 구조체나 클래스는 하나의 자료형이므로 대부분의 경우 이 자료형을 기반으로 메모리를 할당받아 사용

        - 인스턴스

1. 구조체와 클래스의 공통점

    => 프로퍼티와 메소드를 소유할 수 있음

    => 서브스크립트 : 프로퍼티에 접근하기 위한 방법

    => 초기화 블럭(생성자) : Init

    => 확장(extension) 가능 :  Kotlin과 C#에 유사한 개념이 있음

    => 프로토콜을 사용할 수 있음

 

2. 구조체와 클래스의 차이점

    => 구조체는 상속이 안됨

    => 구조체는 소멸자가 없음

    => 구조체는 데이터 대입시 자료형 검사를 하지 않음

        - 잘못된 데이터 대입시 예외 발생

        - 클래스는 잘못된 데이터 대입시 에러 표시

    => 구조체는 값 형식이고 클래스는 참조 형식

        - 구조체는 값들의 집합일뿐이고, 클래스는 인스턴스를 생성하고 그 인스턴스의 참조를 사용하는 개념

    => 구조체는 참조 카운팅을 하지 않음

    => 구조체는 생성자를 별도로 만들지 않아도 생성시 값을 대입하여 생성하는 것이 가능

 

3. 구조체와 클래스의 사용을 결정

    => 데이터의 집합을 나타내는 경우는 구조체, 그 외의 경우 클래스

        - 이전의 DTO는 구조체나 튜플을 이용

 

4. 구조체 생성

struct 구조체명{
	속성(변수)
    메소드(함수)
    생성자(init)
}

 

5. 구조체를 이용하는 객체 생성

    => 형식 : 구조체명(데이터 나열) or 구조체명.init(데이터 나열)

        - init는 작성해도 되고 안해도 됨

    => 구조체명 변수 = 구조체명(데이터 나열) 형식은 구조체 객체 생성 및 객체를 재사용하기 위해서 변수에 참조를 저장하는 것

 

6. 멤버 호출

    - 변수.속성명

    - 변수.메소드(매개변수) : 메소드를 호출(실행)하는 것

    - 변수.메소드 : 메소드의 참조를 의미하는 것

 

7. 명명법(Camel 표기법 권장)

    => 구조체나 클래스명은 대문자로 시작

    => 속성이나 메소드명은 소문자로 시작

    => 2개 단어 이상의 조합으로 만들어지는 경우에는 두번째 단어의 시작을 대문자로

//구조체(DTO 클래스 대용) 생성
//번호와 이름을 저장하는 구조체를 생성
struct Person{
    //프로퍼티를 선언 : nil을 저장할 수 있도록 ?와 함께 선언
    //Optional Type
    var num:Int?
    var name:String?
    
    //메소드 생성
    func disp() -> Void{
        print("번호는 \(num!) 이름은 \(name!)")
    }
    
    //생성자 - 매개변수가 없는 생성자(Default Constructor)
    //인스턴스 변수의 값을 특정 값으로 초기화하고자 할 때 생성
    init(){
        num = 1
        name = "noname"
    }
    //생성자 오버로딩: 하나의 클래스에 동일한 이름의 메소드가
    //2개 이상 존재
    //매개변수가 있는 생성자: 데이터를 주입받아서 인스턴스
    //변수를 초기화하기 위해서
    init(num:Int?, name:String?){
        self.num = num
        self.name = name
    }
}

//함수, 구조체나 클래스는 사용자 정의 자료형
//생성만 해서는 사용할 수 없고 메모리 할당 받아서 사용
//함수는 호출
//구조체나 클래스는 객체를 생성해서 사용

//구조체 객체 만들기
//swift에서는 생성자만 호출해도 되고 init 으로 직접 초기화
//메소드를 호출해도 됩니다.
var person1 = Person()
var person2 = Person(num: 1, name: "park")
var person3 = Person.init(num: 2, name: "척준경")
//멤버 호출
person1.disp()
//정수, 실수, Bool, 구조체, 열거형은
//대입을 하면 데이터를 복제해서 대입
//대입을 하면 다른 쪽의 변경이 원본에 영향이 없습니다.
var person4 = person1
//person4의 내용을 변경해도 person1은 영향을 받지 않습니다.
person4.num = 99
person4.disp()
person1.disp()

 

**class

    => 동일한 목적을 위해 모인 프로퍼티와 메소드의 모임

    => 사용자 정의 자료형

    => 클래스가 생성하는 인스턴스는 참조형

        - 다른 변수에 참조를 대입하면 데이터가 복사되는 것이 아니고 참조가 복사

1. 클래스의 생성

    => 구조체의 struct를 class로 변경

 

2. 인스턴스 생성

    => 생성자(매개변수 대입)

    => 생성자.init(매개변수 대입)

 

3. Property

    => 데이터를 저장하거나 읽기 위한 목적으로 구조체나 클래스 안에 선언한 변수나 상수

    => 다른 말로는 field, attribute, 속성이라고도 함

    => 변수를 만들때는 var 상수를 만들때는 let을 사용

  1) 종류

    => 저장 프로퍼티 : 값을 저장할 목적으로 생성

        - 저장 프로퍼티를 만들 때는 초기값을 바로 할당할 것이 아니면 Optional Type으로 생성

        - 대다수의 경우 ?보다는 !를 이용하여 선언 - 강제로 Optional을 해제하고 않고 사용 가능

        - init 메소드에서 초기화할 거라면 Optional을 사용하지 않아도 됨

    => 연산 프로퍼티 : 값을 계산해서 리턴할 목적으로 생성

var 프로퍼티명 : 자료형{
	get{
    	return 데이터
    }
    set(value){
    	수행할 작업
    }
}

    => get은 필수이고, set은 선택

    => 만들기는 get과 set을 만들어서 접근자 메소드를 만들지만 사용은 변수처럼 함

        - =를 기준으로 오른쪽에서 사용시 set, 그 외의 경우 무조건 get

    => 연산 프로퍼티를 만드는 경우는 국어, 수학점수를 저장하는 구조체, 클래스 생성시 합계를 자주사용하면 매번구하는 것은 시간이 소요

        - 이런 경우 합계라는 프로퍼티를 만드는 데 합계 프로퍼티는 데이터를 저장하는 것이 목적이 아니라 계산하여 리턴하는 것이 목적

          (저장 프로퍼티 활용이 효율적)

        - 관계형 데이터베이스에서 테이블 제작시 어떤 계산 작업을 자주 사용한다면 컬럼을 만들어두고 사용하는 것이 좋음

          -> 반정규화 : 빠르게 사용할 수 있는 방법 중 하나

  2) lazy init(지연생성)

    => 프로퍼티를 만들 때 앞에 lazy를 추가하면 됨

    => 지연 생성은 인스턴스가 생성될 때 만드는 것이 아니라 처음 프로퍼티 사용시 만들어주는 개념

    => 서버 프로그램과 클라이언트 프로그램의 차이

        - 서버 프로그램은 처음부터 전부 가지고 시작하는 것이 좋음

        - 서버 프로그램은 신뢰성이 우선

        - 클라이언트 프로그램은 필요할 때 생성하는 것이 좋음

        - 클라이언트 프로그램은 가용성이 우선시

    => 클라이언트 프로그램을 만드는 경우 하나의 클래스로부터 여러 인스턴스를 만들고 오랜시간 동작하는 프로그램개발시 지연생성 교려

        - 지연생성을 많이 사용하는 애플리케이션이 게임

class Rect{
    //저장 프로퍼티 : 변수
    var x = 0
    var y = 0
    var width = 0
    var height = 0
    
    //연산 프로퍼티
    //get을 하면 x, y 그리고 width 와 height를
    //가지고 계산해서 리턴
    
    //set을 하면 x, y 값을 수정
    var center:(Int, Int){
        get{
            return ((x+width)/2, (y+height)/2)
        }
        set(value){
            x = (value.0 - width/2)
            y = (value.1 - height/2)
        }
    }
}

//인스턴스 생성
var rect:Rect = Rect()
//저장 프로퍼티에 값을 대입
//스위프트(iOS SDK)에서는 프로퍼티에 값을 대입할 때
//변수를 직접 호출하는 구조로 사용합니다.
rect.x = 100
rect.y = 200
rect.width = 200
rect.height = 200

//연산 프로퍼티 호출 : 프로퍼티를 호출하면 get의 내용을 수행해서
//리턴합니다.
print(rect.center)

//연산 프로퍼티에 값을 대입
//특별한 경우가 아니면 연산 프로퍼티에 set을 만들지는 않습니다.
rect.center = (190, 100)
print(rect.x)
print(rect.y)

 

  3) Property Observer : key Value Observing 이벤트 핸들링

    => 프로퍼티의 값이 변경되는 것을 감시하는 기능

    => swift에서는 willSet과 didSet을 이용하고 다른 언어에서는 setter메소드를 직접 작성하여 만듬

    => willSet은 프로퍼티의 값이 변경되기 전에 수행되는 내용, 이때는 newValue라는 프로퍼티가 전달(변경될 값)

    => didSet은 프로퍼티의 값이 변경된 후에 수행되는 내용 이때는 oldValue라는 프로퍼티가 전달(이전에 저장되어 있던 값)

var 프로퍼티명:자료형{
    willSet{
    	내용
    }
    didSet{
    	내용
    }
}

    => iOS에서는 어떤 상태 변화가 일어나기 직전을 will이라고 표현하고, 상태변화가 일어난 후를 did라고 표현

public void setScore(int score){
	=> willSet - newValue : score
    this.score = score
	=> didSet - oldValue : 변경되기 전의 score
}

    => 이 개념을 잘 이용하면 MediaPlayer를 효율적으로 만들수 있음

        - 여러개의 음악을 재생한다던가 영상으 ㄹ재생할 때 하나의 미디어 재생이 끝나고 난 후 다음 미디어 재생 준비시 일정 대기시간 필요

        - 하나의 미디어가 재생중일때 재생시간의 90%정도가되면 다음 미디어의 재생준비를 함

        - 미디어가 끊김없이 재생되는 효과를 만들수 있음

  4) 클로저를 이용한 프로퍼티 초기화  

    => 프로퍼티는 생성자를 제외한 곳에서는 메소드를 호출해서 초기화 할 수 없습니다.

    => 클로저를 이용하면 가능 : 인스턴스를 만들 때 1번만 호출됩니다.

let/var 프로퍼티이름:자료형 = {
	수행할 내용
	return 데이터
}()

    => 인스턴스를 만들 때 어떤 작업을 수행하기 위해서 이 문법을 사용

  5) static property

    => 앞에 static을 붙이면 클래스가 사용할 수 있는 프로퍼티

    => 인스턴스 없이 사용이 가능한 프로퍼티

    => 인스턴스는 호출할 수 없고 클래스 이름으로만 호출

    => 만드는 목적은 모든 인스턴스가 공유하기 위해 - 동일한 클래스로부터 만들어진 인스턴스 사이의 통신이 목적

    => static이라는 예약어 대신에 class라는 예약어로도 생성가능, class를 붙이면 연산 프로퍼티에만 적용, 상속한 경우 재정의가 가능

 

4. Method

    => self(this, me)

        - 인스턴스가 메소드를 호출할 때 숨겨진 매개변수

        - 인스턴스가 메소드를 호출하면 첫번째 매개변수로 인스턴스 자신의 참조를 같이 전달

        - 인스턴스 메소드 안에서 이 참조를 self라는 이름으로 넘겨 받음

        - self.프로퍼티명 이나 메소드명을 사용하게 되면 메소드 내부에서 프로퍼티나 메소드 명을 찾지않고 메소드 외부에서 찾기 시작

  1) Instance Method

    => 인스턴스가 호출 할 수 있는 메소드

    => statoc 프로퍼티와 instance 프로퍼티 모두 사용 가능

  2) Static Method

    => 클래스가 호출하는 메소드

    => static 프로퍼티만 사용

    => self가 없어 인스턴스가 소유하고 있는 프로퍼티에는 접근 불가

  3) selector

    => Objective-C에서 함수나 메소드를 대입받기 위한 표현

    => 매개변수가 없을 때는 함수나 메소드명만 사용하면 되고 매개변수가 있는 경우 메소드명(매개변수명:, 매개변수명:..)형태로 대입

  4) self를 반드시 사용해야 하는 경우

    => 지역변수와 인스턴스 변수의 이름이 같을 때 인스턴스 변수를 사용하려면 반드시 self.을 붙여야 함

class T{
    static func disp() -> Void{
        print("static 메소드")
    }
    func messageDisp(msg:String) -> Void {
        print("인스턴스 메소드")
    }
}

//disp와 messageDisp를 호출
//disp는 static 메소드이고 매개변수가 없고 리턴타입이 Void
T.disp()

//messageDisp는 static이 없고(인스턴스 생성) 매개변수가 문자열 1개, 매개변수로 문자열을 대입
//리턴타입은 Void
var ob : T = T()
ob.messageDisp(msg: "Hello")

//결과
//static 메소드
//인스턴스 메소드

 

**자바스크립트에서의 함수 선언

function 함수명(매개변수){
	함수 내용
}

var 함수명 = function(매개변수){
	함수 내용
}

    => 아래 방법을 권장